package service

import (
	"context"
	"cms-api/internal/dao"
	"cms-api/internal/model"

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

type sPartner struct{}

func Partner() *sPartner {
	return &sPartner{}
}

// GetById 根据ID获取合作伙伴信息
func (s *sPartner) GetById(ctx context.Context, id int) (*model.Partner, error) {
	return dao.Partner.GetById(ctx, id)
}

// List 获取合作伙伴列表
func (s *sPartner) List(ctx context.Context, req *model.PartnerListRequest) (*model.PageResponse, error) {
	var (
		page     = req.Page
		pageSize = req.PageSize
	)

	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 {
		pageSize = 20
	}

	// 设置分页参数
	req.Page = page
	req.PageSize = pageSize

	// 获取列表
	partners, total, err := dao.Partner.List(ctx, req)
	if err != nil {
		return nil, err
	}

	return &model.PageResponse{
		List:       partners,
		Total:      total,
		Page:       page,
		PageSize:   pageSize,
		TotalPages: (total + pageSize - 1) / pageSize,
	}, nil
}

// GetAll 获取所有启用的合作伙伴
func (s *sPartner) GetAll(ctx context.Context) ([]*model.Partner, error) {
	return dao.Partner.GetAll(ctx)
}

// GetFeatured 获取推荐合作伙伴
func (s *sPartner) GetFeatured(ctx context.Context, limit int) ([]*model.Partner, error) {
	if limit <= 0 {
		limit = 10
	}
	return dao.Partner.GetFeatured(ctx, limit)
}

// GetByCategory 根据分类获取合作伙伴
func (s *sPartner) GetByCategory(ctx context.Context, category string) ([]*model.Partner, error) {
	return dao.Partner.GetByCategory(ctx, category)
}

// Create 创建合作伙伴
func (s *sPartner) Create(ctx context.Context, req *model.CreatePartnerRequest) error {
	// 检查合作伙伴名称是否存在
	existPartner, err := dao.Partner.GetByName(ctx, req.Name)
	if err != nil {
		return err
	}
	if existPartner != nil {
		return gerror.New("合作伙伴名称已存在")
	}

	// 创建合作伙伴
	partner := &model.Partner{
		Name:        req.Name,
		Logo:        req.Logo,
		Website:     req.Website,
		Description: req.Description,
		Category:    req.Category,
		SortOrder:   req.SortOrder,
		IsFeatured:  req.IsFeatured,
		Status:      req.Status,
		CreatedAt:   gtime.Now(),
		UpdatedAt:   gtime.Now(),
	}

	_, err = dao.Partner.Create(ctx, partner)
	return err
}

// Update 更新合作伙伴
func (s *sPartner) Update(ctx context.Context, id int, req *model.UpdatePartnerRequest) error {
	// 检查合作伙伴是否存在
	partner, err := s.GetById(ctx, id)
	if err != nil {
		return err
	}
	if partner == nil {
		return gerror.New("合作伙伴不存在")
	}

	// 检查合作伙伴名称是否被其他记录使用
	existPartner, err := dao.Partner.GetByName(ctx, req.Name)
	if err != nil {
		return err
	}
	if existPartner != nil && existPartner.Id != id {
		return gerror.New("合作伙伴名称已被使用")
	}

	// 更新合作伙伴
	updateData := g.Map{
		"name":        req.Name,
		"logo":        req.Logo,
		"website":     req.Website,
		"description": req.Description,
		"category":    req.Category,
		"sort_order":  req.SortOrder,
		"is_featured": req.IsFeatured,
		"status":      req.Status,
		"updated_at":  gtime.Now(),
	}

	return dao.Partner.Update(ctx, id, updateData)
}

// Delete 删除合作伙伴
func (s *sPartner) Delete(ctx context.Context, id int) error {
	// 检查合作伙伴是否存在
	partner, err := s.GetById(ctx, id)
	if err != nil {
		return err
	}
	if partner == nil {
		return gerror.New("合作伙伴不存在")
	}

	return dao.Partner.Delete(ctx, id)
}

// UpdateStatus 更新合作伙伴状态
func (s *sPartner) UpdateStatus(ctx context.Context, id int, status int) error {
	// 检查合作伙伴是否存在
	partner, err := s.GetById(ctx, id)
	if err != nil {
		return err
	}
	if partner == nil {
		return gerror.New("合作伙伴不存在")
	}

	return dao.Partner.UpdateStatus(ctx, id, status)
}

// SetFeatured 设置推荐状态
func (s *sPartner) SetFeatured(ctx context.Context, id int, isFeatured int) error {
	// 检查合作伙伴是否存在
	partner, err := s.GetById(ctx, id)
	if err != nil {
		return err
	}
	if partner == nil {
		return gerror.New("合作伙伴不存在")
	}

	return dao.Partner.Update(ctx, id, g.Map{
		"is_featured": isFeatured,
		"updated_at":  gtime.Now(),
	})
}

// UpdateSortOrder 更新排序
func (s *sPartner) UpdateSortOrder(ctx context.Context, id int, sortOrder int) error {
	// 检查合作伙伴是否存在
	partner, err := s.GetById(ctx, id)
	if err != nil {
		return err
	}
	if partner == nil {
		return gerror.New("合作伙伴不存在")
	}

	return dao.Partner.Update(ctx, id, g.Map{
		"sort_order": sortOrder,
		"updated_at": gtime.Now(),
	})
}

// GetStats 获取合作伙伴统计信息
func (s *sPartner) GetStats(ctx context.Context) (map[string]interface{}, error) {
	// 获取总合作伙伴数
	totalCount, err := dao.Partner.GetCount(ctx)
	if err != nil {
		return nil, err
	}

	// 获取启用的合作伙伴数
	activeCount, err := dao.Partner.GetCountByStatus(ctx, 1)
	if err != nil {
		return nil, err
	}

	// 获取推荐合作伙伴数
	featuredCount, err := dao.Partner.GetFeaturedCount(ctx)
	if err != nil {
		return nil, err
	}

	// 获取各分类合作伙伴数
	categories, err := dao.Partner.GetCategories(ctx)
	if err != nil {
		return nil, err
	}

	categoryStats := make(map[string]int)
	for _, category := range categories {
		count, err := dao.Partner.GetCountByCategory(ctx, category)
		if err == nil {
			categoryStats[category] = count
		}
	}

	return map[string]interface{}{
		"total_count":     totalCount,
		"active_count":    activeCount,
		"featured_count":  featuredCount,
		"category_stats":  categoryStats,
	}, nil
}

// BatchUpdateStatus 批量更新状态
func (s *sPartner) BatchUpdateStatus(ctx context.Context, ids []int, status int) error {
	for _, id := range ids {
		if err := s.UpdateStatus(ctx, id, status); err != nil {
			g.Log().Error(ctx, "批量更新合作伙伴状态失败, ID:", id, "错误:", err)
			// 继续更新其他记录，不中断整个过程
		}
	}
	return nil
}

// BatchDelete 批量删除合作伙伴
func (s *sPartner) BatchDelete(ctx context.Context, ids []int) error {
	for _, id := range ids {
		if err := s.Delete(ctx, id); err != nil {
			g.Log().Error(ctx, "批量删除合作伙伴失败, ID:", id, "错误:", err)
			// 继续删除其他记录，不中断整个过程
		}
	}
	return nil
}