package service

import (
	"fmt"
	"psi/database"
	"psi/models"
	systemReq "psi/models/request"
	systemRes "psi/models/response"
	"psi/utils"
	"time"

	"gorm.io/gorm"
)

type OutTaskService struct{}

// GetOutTaskList 获取外部任务列表
func (s *OutTaskService) GetOutTaskList(req systemReq.GetOutTaskListRequest, creatorID int64, role int64, db ...*gorm.DB) (*systemRes.OutTaskListResponse, error) {
	databaseConn := database.OptionalDB(db...)

	if req.Page < 1 {
		req.Page = 1
	}
	if req.PageSize < 1 || req.PageSize > 100 {
		req.PageSize = 20
	}

	query := databaseConn.Model(&models.OutTask{}).Where("out_task.is_del = ?", 0)

	if req.ShopID > 0 {
		query = query.Where("out_task.shop_id = ?", req.ShopID)
	}
	if req.WaveTaskID > 0 {
		query = query.Where("out_task.wave_task_id = ?", req.WaveTaskID)
	}
	if req.ShopType > 0 {
		query = query.Where("out_task.shop_type = ?", req.ShopType)
	}
	if req.TaskType > 0 {
		query = query.Where("out_task.task_type = ?", req.TaskType)
	}
	if req.StartDate > 0 {
		query = query.Where("out_task.created_at >= ?", req.StartDate)
	}
	if req.EndDate > 0 {
		query = query.Where("out_task.created_at <= ?", req.EndDate)
	}

	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, utils.NewError("查询总数失败")
	}

	if total == 0 {
		return &systemRes.OutTaskListResponse{
			List:     []systemRes.OutTaskItem{},
			Total:    0,
			Page:     req.Page,
			PageSize: req.PageSize,
		}, nil
	}

	var tasks []models.OutTask
	offset := (req.Page - 1) * req.PageSize
	if err := query.Order("out_task.created_at DESC").
		Offset(offset).
		Limit(req.PageSize).
		Find(&tasks).Error; err != nil {
		return nil, utils.NewError("查询外部任务列表失败")
	}

	taskItems := make([]systemRes.OutTaskItem, 0, len(tasks))
	for _, task := range tasks {
		taskItems = append(taskItems, systemRes.ConvertOutTaskToItem(task))
	}

	return &systemRes.OutTaskListResponse{
		List:     taskItems,
		Total:    total,
		Page:     req.Page,
		PageSize: req.PageSize,
	}, nil
}

// GetOutTaskLogList 获取外部任务日志列表
func (s *OutTaskService) GetOutTaskLogList(req systemReq.GetOutTaskLogListRequest, creatorID int64, role int64, db ...*gorm.DB) (*systemRes.OutTaskLogListResponse, error) {
	databaseConn := database.OptionalDB(db...)

	if req.Page < 1 {
		req.Page = 1
	}
	if req.PageSize < 1 || req.PageSize > 100 {
		req.PageSize = 20
	}

	query := databaseConn.Model(&models.OutTaskLog{}).Where("out_task_log.is_del = ?", 0).Where("out_task_log.out_task_id = ?", req.OutTaskID)

	if req.ShopID > 0 {
		query = query.Where("out_task_log.shop_id = ?", req.ShopID)
	}
	if req.WaveTaskID > 0 {
		query = query.Where("out_task_log.wave_task_id = ?", req.WaveTaskID)
	}
	if req.ProductID > 0 {
		query = query.Where("out_task_log.product_id = ?", req.ProductID)
	}
	if req.Status >= 0 {
		query = query.Where("out_task_log.status = ?", req.Status)
	}
	if req.StartDate > 0 {
		query = query.Where("out_task_log.created_at >= ?", req.StartDate)
	}
	if req.EndDate > 0 {
		query = query.Where("out_task_log.created_at <= ?", req.EndDate)
	}

	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, utils.NewError("查询总数失败")
	}

	if total == 0 {
		return &systemRes.OutTaskLogListResponse{
			List:     []systemRes.OutTaskLogItem{},
			Total:    0,
			Page:     req.Page,
			PageSize: req.PageSize,
		}, nil
	}

	var logs []models.OutTaskLog
	offset := (req.Page - 1) * req.PageSize
	if err := query.Order("out_task_log.created_at DESC").
		Offset(offset).
		Limit(req.PageSize).
		Find(&logs).Error; err != nil {
		return nil, utils.NewError("查询外部任务日志列表失败")
	}

	logItems := make([]systemRes.OutTaskLogItem, 0, len(logs))
	for _, log := range logs {
		logItems = append(logItems, systemRes.ConvertOutTaskLogToItem(log))
	}

	return &systemRes.OutTaskLogListResponse{
		List:     logItems,
		Total:    total,
		Page:     req.Page,
		PageSize: req.PageSize,
	}, nil
}

// GetOutTaskByShop 按店铺分组获取外部任务列表
func (s *OutTaskService) GetOutTaskByShop(req systemReq.GetOutTaskByShopRequest, creatorID int64, role int64, db ...*gorm.DB) (*systemRes.OutTaskByShopResponse, error) {
	databaseConn := database.OptionalDB(db...)

	if req.Page < 1 {
		req.Page = 1
	}
	if req.PageSize < 1 || req.PageSize > 100 {
		req.PageSize = 20
	}

	// 构建查询条件
	query := databaseConn.Model(&models.OutTask{}).Where("out_task.is_del = ?", 0)

	if req.ShopID > 0 {
		query = query.Where("out_task.shop_id = ?", req.ShopID)
	}
	if req.ShopType > 0 {
		query = query.Where("out_task.shop_type = ?", req.ShopType)
	}
	if req.StartDate > 0 {
		query = query.Where("out_task.created_at >= ?", req.StartDate)
	}
	if req.EndDate > 0 {
		query = query.Where("out_task.created_at <= ?", req.EndDate)
	}

	// 获取总数
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, utils.NewError("查询总数失败")
	}

	if total == 0 {
		return &systemRes.OutTaskByShopResponse{
			List:     []systemRes.OutTaskShopGroup{},
			Total:    0,
			Page:     req.Page,
			PageSize: req.PageSize,
		}, nil
	}

	// 分页查询任务列表
	var tasks []models.OutTask
	offset := (req.Page - 1) * req.PageSize
	if err := query.Order("out_task.shop_id ASC, out_task.created_at DESC").
		Offset(offset).
		Limit(req.PageSize).
		Find(&tasks).Error; err != nil {
		return nil, utils.NewError("查询外部任务列表失败")
	}

	// 按店铺分组
	shopGroupMap := make(map[int64]*systemRes.OutTaskShopGroup)
	shopIDs := make([]int64, 0)

	for _, task := range tasks {
		if _, exists := shopGroupMap[task.ShopID]; !exists {
			shopIDs = append(shopIDs, task.ShopID)
			shopGroupMap[task.ShopID] = &systemRes.OutTaskShopGroup{
				ShopID:       task.ShopID,
				ShopType:     task.ShopType,
				ShopTypeText: systemRes.GetShopTypeText(task.ShopType),
				Tasks:        []systemRes.OutTaskDetail{},
			}
		}

		taskDetail := systemRes.ConvertOutTaskToDetail(task)
		shopGroupMap[task.ShopID].Tasks = append(shopGroupMap[task.ShopID].Tasks, taskDetail)
	}

	// 批量查询店铺名称
	shopNameMap := make(map[int64]string)
	if len(shopIDs) > 0 {
		var shops []models.Shop
		if err := databaseConn.Model(&models.Shop{}).
			Where("id IN ? AND del_flag = ?", shopIDs, 0).
			Find(&shops).Error; err == nil {
			for _, shop := range shops {
				shopNameMap[shop.ID] = shop.ShopAliasName
			}
		}
	}

	// 为每个任务查询日志明细
	for shopID, shopGroup := range shopGroupMap {
		shopGroup.ShopName = shopNameMap[shopID]

		for i := range shopGroup.Tasks {
			task := &shopGroup.Tasks[i]

			// 只查询已发送任务的日志
			if task.OutTaskID == 0 {
				continue
			}

			var logs []models.OutTaskLog
			if err := databaseConn.Model(&models.OutTaskLog{}).
				Where("out_task_log.out_task_id = ? AND out_task_log.is_del = ?", task.OutTaskID, 0).
				Order("out_task_log.created_at DESC").
				Find(&logs).Error; err == nil {

				logItems := make([]systemRes.OutTaskLogItem, 0, len(logs))
				for _, log := range logs {
					logItems = append(logItems, systemRes.ConvertOutTaskLogToItem(log))
				}
				task.Logs = logItems
			}
		}
	}

	// 转换为列表
	shopGroups := make([]systemRes.OutTaskShopGroup, 0, len(shopGroupMap))
	for _, group := range shopGroupMap {
		shopGroups = append(shopGroups, *group)
	}

	return &systemRes.OutTaskByShopResponse{
		List:     shopGroups,
		Total:    total,
		Page:     req.Page,
		PageSize: req.PageSize,
	}, nil
}

// UpdateOutTaskLog 更新外部任务日志
func (s *OutTaskService) UpdateOutTaskLog(req systemReq.UpdateOutTaskLogRequest) error {
	databaseConn, err := database.GetTenantDB(req.UserID)
	if err != nil {
		return fmt.Errorf("获取数据库连接失败: %v", err)
	}

	var log models.OutTaskLog
	if err := databaseConn.Where("out_task_id = ? AND product_id = ?", req.OutTaskID, req.ProductID).First(&log).Error; err != nil {
		return fmt.Errorf("查询外部任务日志失败: %v", err)
	}

	if err := databaseConn.Model(&log).Updates(map[string]interface{}{
		"status":     2,
		"updated_at": time.Now().Unix(),
	}).Error; err != nil {
		return fmt.Errorf("更新外部任务日志失败: %v", err)
	}

	return nil
}