package service

import (
	"context"

	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/ghttp"
	"github.com/gogf/gf/v2/os/gtime"

	"nl-video-api/internal/dao"
	"nl-video-api/internal/model/entity"
	"nl-video-api/utility/response"
)

// BannerService Banner服务
type BannerService struct{}

// NewBannerService 创建Banner服务实例
func NewBannerService() *BannerService {
	return &BannerService{}
}

// 定义请求和响应结构体
type AdminBannerListReq struct {
	Page     int    `json:"page"`
	Size     int    `json:"size"`
	Sort     int    `json:"sort"`
	Status   int    `json:"status"`
	Keyword  string `json:"keyword"`
	Category string `json:"category"`
}

type AdminBannerListRes struct {
	List  []AdminBannerItem `json:"list"`
	Total int               `json:"total"`
	Page  int               `json:"page"`
	Size  int               `json:"size"`
}

type AdminBannerItem struct {
	Id          uint   `json:"id"`
	Title       string `json:"title"`
	ImageUrl    string `json:"image_url"`
	LinkUrl     string `json:"link_url"`
	Sort        int    `json:"sort"`
	Status      int    `json:"status"`
	Description string `json:"description"`
	CreatedAt   int64  `json:"created_at"`
	UpdatedAt   int64  `json:"updated_at"`
}

type AdminBannerDetailReq struct {
	Id uint `json:"id"`
}

type AdminBannerDetailRes struct {
	Banner AdminBannerDetail `json:"banner"`
}

type AdminBannerDetail struct {
	Id          uint   `json:"id"`
	Title       string `json:"title"`
	ImageUrl    string `json:"image_url"`
	LinkUrl     string `json:"link_url"`
	Sort        int    `json:"sort"`
	Status      int    `json:"status"`
	Description string `json:"description"`
	CreatedAt   int64  `json:"created_at"`
	UpdatedAt   int64  `json:"updated_at"`
}

type AdminBannerCreateReq struct {
	Title       string `json:"title"`
	ImageUrl    string `json:"image_url"`
	LinkUrl     string `json:"link_url"`
	Sort        int    `json:"sort"`
	Status      int    `json:"status"`
	Description string `json:"description"`
}

type AdminBannerUpdateReq struct {
	Id          uint   `json:"id"`
	Title       string `json:"title"`
	ImageUrl    string `json:"image_url"`
	LinkUrl     string `json:"link_url"`
	Sort        int    `json:"sort"`
	Status      int    `json:"status"`
	Description string `json:"description"`
}

type AdminBannerDeleteReq struct {
	Id uint `json:"id"`
}

type AdminBannerUpdateStatusReq struct {
	Id     uint `json:"id"`
	Status int  `json:"status"`
}

type AdminBannerBatchDeleteReq struct {
	Ids []uint `json:"ids"`
}

// UserGetList 用户获取轮播图列表
func (s *BannerService) UserGetList(r *ghttp.Request) {
	// 获取请求参数
	page := r.Get("page", 1).Int()
	size := r.Get("size", 10).Int()
	sort := r.Get("sort", 0).Int()

	// 构建查询条件
	query := dao.Banner.Ctx(r.Context()).Where("status", 1) // 只显示启用的轮播图

	// 排序筛选
	if sort > 0 {
		query = query.Where("sort", sort)
	}

	// 获取总数
	total, err := query.Count()
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取轮播图总数失败")
		return
	}

	// 获取列表数据
	var banners []entity.Banner
	err = query.Order("sort ASC, id DESC").
		Limit((page-1)*size, size).
		Scan(&banners)
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取轮播图列表失败")
		return
	}

	// 转换为响应格式
	list := make([]g.Map, 0, len(banners))
	for _, banner := range banners {
		list = append(list, g.Map{
			"id":         banner.Id,
			"title":      banner.Title,
			"image_url":  banner.ImageUrl,
			"link_url":   banner.LinkUrl,
			"sort":       banner.Sort,
			"status":     banner.Status,
			"created_at": banner.CreatedAt.Unix(),
			"updated_at": banner.UpdatedAt.Unix(),
		})
	}

	response.Success(r, g.Map{
		"list":  list,
		"total": total,
		"page":  page,
		"size":  size,
	})
}

// UserGetDetail 用户获取轮播图详情
func (s *BannerService) UserGetDetail(r *ghttp.Request) {
	id := r.Get("id").Uint()
	if id == 0 {
		response.Error(r, response.CodeInvalidParam, "轮播图ID不能为空")
		return
	}

	var banner entity.Banner
	err := dao.Banner.Ctx(r.Context()).Where("id", id).Where("status", 1).Scan(&banner)
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取轮播图详情失败")
		return
	}
	if banner.Id == 0 {
		response.Error(r, response.CodeNotFound, "轮播图不存在")
		return
	}

	response.Success(r, g.Map{
		"id":         banner.Id,
		"title":      banner.Title,
		"image_url":  banner.ImageUrl,
		"link_url":   banner.LinkUrl,
		"sort":       banner.Sort,
		"status":     banner.Status,
		"created_at": banner.CreatedAt.Unix(),
		"updated_at": banner.UpdatedAt.Unix(),
	})
}

// AdminCreate 管理员创建轮播图
func (s *BannerService) AdminCreate(r *ghttp.Request) {
	// 获取请求参数
	title := r.Get("title").String()
	imageUrl := r.Get("image_url").String()
	linkUrl := r.Get("link_url").String()
	sort := r.Get("sort", 0).Int()
	status := r.Get("status", 1).Int()

	// 参数验证
	if title == "" {
		response.Error(r, response.CodeInvalidParam, "标题不能为空")
		return
	}
	if imageUrl == "" {
		response.Error(r, response.CodeInvalidParam, "图片地址不能为空")
		return
	}

	// 创建轮播图
	data := &entity.Banner{
		Title:     title,
		ImageUrl:  imageUrl,
		LinkUrl:   linkUrl,
		Sort:      sort,
		Status:    status,
		CreatedAt: gtime.Now(),
		UpdatedAt: gtime.Now(),
	}

	id, err := dao.Banner.Ctx(r.Context()).Data(data).InsertAndGetId()
	if err != nil {
		response.Error(r, response.CodeInternalError, "创建轮播图失败")
		return
	}

	response.Success(r, g.Map{
		"id": uint(id),
	})
}

// AdminUpdate 管理员更新轮播图
func (s *BannerService) AdminUpdate(ctx context.Context, req *AdminBannerUpdateReq) error {
	// 检查轮播图是否存在
	count, err := dao.Banner.Ctx(ctx).Where("id", req.Id).Count()
	if err != nil {
		return gerror.New("检查轮播图失败")
	}
	if count == 0 {
		return gerror.New("轮播图不存在")
	}

	// 更新轮播图
	data := g.Map{
		"title":       req.Title,
		"image_url":   req.ImageUrl,
		"link_url":    req.LinkUrl,
		"sort":        req.Sort,
		"status":      req.Status,
		"description": req.Description,
		"updated_at":  gtime.Now(),
	}

	_, err = dao.Banner.Ctx(ctx).Where("id", req.Id).Data(data).Update()
	if err != nil {
		return gerror.New("更新轮播图失败")
	}

	return nil
}

// AdminDelete 管理员删除轮播图
func (s *BannerService) AdminDelete(ctx context.Context, req *AdminBannerDeleteReq) error {
	// 检查轮播图是否存在
	count, err := dao.Banner.Ctx(ctx).Where("id", req.Id).Count()
	if err != nil {
		return gerror.New("检查轮播图失败")
	}
	if count == 0 {
		return gerror.New("轮播图不存在")
	}

	// 删除轮播图
	_, err = dao.Banner.Ctx(ctx).Where("id", req.Id).Delete()
	if err != nil {
		return gerror.New("删除轮播图失败")
	}

	return nil
}

// AdminGetDetail 管理员获取轮播图详情
func (s *BannerService) AdminGetDetail(ctx context.Context, req *AdminBannerDetailReq) (*AdminBannerDetailRes, error) {
	var banner entity.Banner
	err := dao.Banner.Ctx(ctx).Where("id", req.Id).Scan(&banner)
	if err != nil {
		return nil, gerror.New("获取轮播图详情失败")
	}
	if banner.Id == 0 {
		return nil, gerror.New("轮播图不存在")
	}

		return &AdminBannerDetailRes{
			Banner: AdminBannerDetail{
				Id:        banner.Id,
				Title:     banner.Title,
				ImageUrl:  banner.ImageUrl,
				LinkUrl:   banner.LinkUrl,
				Sort:      banner.Sort,
				Status:    banner.Status,
				CreatedAt: banner.CreatedAt.Unix(),
				UpdatedAt: banner.UpdatedAt.Unix(),
			},
		}, nil
}

// AdminGetList 管理员获取轮播图列表
func (s *BannerService) AdminGetList(ctx context.Context, req *AdminBannerListReq) (*AdminBannerListRes, error) {
	// 设置默认值
	if req.Page <= 0 {
		req.Page = 1
	}
	if req.Size <= 0 {
		req.Size = 10
	}

	// 构建查询条件
	query := dao.Banner.Ctx(ctx)

	// 状态筛选
	if req.Status >= 0 {
		query = query.Where("status", req.Status)
	}

	// 排序筛选
	if req.Sort > 0 {
		query = query.Where("sort", req.Sort)
	}

	// 关键词搜索
	if req.Keyword != "" {
		keyword := "%" + req.Keyword + "%"
		query = query.Where("title LIKE ?", keyword)
	}

	// 获取总数
	total, err := query.Count()
	if err != nil {
		return nil, gerror.New("获取轮播图总数失败")
	}

	// 获取列表数据
	var banners []entity.Banner
	err = query.Order("sort ASC, id DESC").
		Limit((req.Page-1)*req.Size, req.Size).
		Scan(&banners)
	if err != nil {
		return nil, gerror.New("获取轮播图列表失败")
	}

	// 转换为响应格式
	list := make([]AdminBannerItem, 0, len(banners))
	for _, banner := range banners {
		list = append(list, AdminBannerItem{
			Id:          banner.Id,
			Title:       banner.Title,
			ImageUrl:    banner.ImageUrl,
			LinkUrl:     banner.LinkUrl,
			Sort:        banner.Sort,
			Status:      banner.Status,
			Description: "", // 实体中没有此字段，设为空
			CreatedAt:   banner.CreatedAt.Unix(),
			UpdatedAt:   banner.UpdatedAt.Unix(),
		})
	}

	return &AdminBannerListRes{
		List:  list,
		Total: total,
		Page:  req.Page,
		Size:  req.Size,
	}, nil
}

// AdminUpdateStatus 管理员更新轮播图状态
func (s *BannerService) AdminUpdateStatus(ctx context.Context, req *AdminBannerUpdateStatusReq) error {
	// 检查轮播图是否存在
	count, err := dao.Banner.Ctx(ctx).Where("id", req.Id).Count()
	if err != nil {
		return gerror.New("检查轮播图失败")
	}
	if count == 0 {
		return gerror.New("轮播图不存在")
	}

	// 更新状态
	_, err = dao.Banner.Ctx(ctx).Where("id", req.Id).Data(g.Map{
		"status":     req.Status,
		"updated_at": gtime.Now(),
	}).Update()
	if err != nil {
		return gerror.New("更新轮播图状态失败")
	}

	return nil
}

// AdminBatchDelete 管理员批量删除轮播图
func (s *BannerService) AdminBatchDelete(ctx context.Context, req *AdminBannerBatchDeleteReq) error {
	if len(req.Ids) == 0 {
		return gerror.New("请选择要删除的轮播图")
	}

	// 批量删除
	_, err := dao.Banner.Ctx(ctx).WhereIn("id", req.Ids).Delete()
	if err != nil {
		return gerror.New("批量删除轮播图失败")
	}

	return nil
}