package data

import (
	"context"
	consts "erp/consts/data"
	dao "erp/dao/data"
	dto "erp/model/dto/data"
	entity "erp/model/entity/data"
	"errors"
	"time"

	"github.com/gogf/gf/v2/util/gconv"
)

type scheduleService struct{}

// Schedule 排班服务
var Schedule = new(scheduleService)

// Create 创建排班
func (s *scheduleService) Create(ctx context.Context, req *dto.CreateScheduleReq) (res *dto.CreateScheduleRes, err error) {
	// 检查开始时间是否小于结束时间
	if req.StartTime.After(req.EndTime) || req.StartTime.Equal(req.EndTime) {
		return nil, errors.New("开始时间必须早于结束时间")
	}

	// 检查主播是否存在
	_, err = dao.Anchor.GetOne(ctx, &dto.GetAnchorReq{Id: int64(req.AnchorId)})
	if err != nil {
		return nil, errors.New("主播不存在")
	}

	// 检查直播账号是否存在
	_, err = dao.LiveAccount.GetOne(ctx, &dto.GetLiveAccountReq{Id: int64(req.AccountId)})
	if err != nil {
		return nil, errors.New("直播账号不存在")
	}

	// 检查时间冲突
	conflictCount, err := dao.Schedule.CheckTimeConflict(ctx, req.AnchorId, req.StartTime, req.EndTime)
	if err != nil {
		return nil, err
	}
	if conflictCount > 0 {
		return nil, errors.New("该主播在此时间段已有排班")
	}

	// 插入数据库
	id, err := dao.Schedule.Insert(ctx, req)
	if err != nil {
		return
	}
	res = &dto.CreateScheduleRes{
		Id: id,
	}
	return
}

// List 获取排班列表
func (s *scheduleService) List(ctx context.Context, req *dto.ListScheduleReq) (res *dto.ListScheduleRes, err error) {
	scheduleList, total, err := dao.Schedule.List(ctx, req)
	if err != nil {
		return
	}

	// 组装响应数据
	list := make([]dto.ScheduleItem, 0, len(scheduleList))
	for _, item := range scheduleList {
		// 获取主播信息
		anchorName := ""
		if item.AnchorId > 0 {
			anchor, _ := dao.Anchor.GetOne(ctx, &dto.GetAnchorReq{Id: int64(item.AnchorId)})
			if anchor != nil {
				anchorName = anchor.Name
			}
		}

		// 获取账号信息
		accountName := ""
		platform := ""
		if item.AccountId > 0 {
			account, _ := dao.LiveAccount.GetOne(ctx, &dto.GetLiveAccountReq{Id: int64(item.AccountId)})
			if account != nil {
				accountName = account.AccountName
				platform = account.Platform
			}
		}

		list = append(list, dto.ScheduleItem{
			Id:          int64(item.Id),
			AnchorId:    item.AnchorId,
			AnchorName:  anchorName,
			AccountId:   item.AccountId,
			AccountName: accountName,
			Platform:    platform,
			StartTime:   item.StartTime.Unix(),
			EndTime:     item.EndTime.Unix(),
			Status:      item.Status,
			StatusName:  consts.ScheduleStatus(item.Status).String(),
			ProductId:   item.ProductId,
			OrderId:     item.OrderId,
			Remark:      item.Remark,
			CreatedAt:   item.CreatedAt.Unix(),
			UpdatedAt:   item.UpdatedAt.Unix(),
		})
	}

	res = &dto.ListScheduleRes{
		List:  list,
		Total: total,
	}
	return
}

// GetOne 获取单个排班
func (s *scheduleService) GetOne(ctx context.Context, req *dto.GetScheduleReq) (res *dto.GetScheduleRes, err error) {
	schedule, err := dao.Schedule.GetOne(ctx, req)
	if err != nil {
		return
	}

	var scheduleEntity *entity.Schedule
	if err = gconv.Struct(schedule, &scheduleEntity); err != nil {
		return
	}

	return &dto.GetScheduleRes{
		Schedule: scheduleEntity,
	}, nil
}

// Update 更新排班
func (s *scheduleService) Update(ctx context.Context, req *dto.UpdateScheduleReq) (err error) {
	// 检查排班是否存在
	exist, err := dao.Schedule.GetOne(ctx, &dto.GetScheduleReq{Id: req.Id})
	if err != nil || exist == nil {
		return errors.New("排班不存在")
	}

	// 如果修改了时间，检查时间合法性
	startTime := exist.StartTime
	endTime := exist.EndTime
	if req.StartTime != nil {
		startTime = *req.StartTime
	}
	if req.EndTime != nil {
		endTime = *req.EndTime
	}
	if startTime.After(endTime) || startTime.Equal(endTime) {
		return errors.New("开始时间必须早于结束时间")
	}

	// 如果修改了主播或时间，检查时间冲突
	anchorId := exist.AnchorId
	if req.AnchorId != nil {
		anchorId = *req.AnchorId
		// 检查主播是否存在
		_, err = dao.Anchor.GetOne(ctx, &dto.GetAnchorReq{Id: int64(anchorId)})
		if err != nil {
			return errors.New("主播不存在")
		}
	}

	conflictCount, err := dao.Schedule.CheckTimeConflict(ctx, anchorId, startTime, endTime, req.Id)
	if err != nil {
		return err
	}
	if conflictCount > 0 {
		return errors.New("该主播在此时间段已有排班")
	}

	// 如果修改了账号，检查账号是否存在
	if req.AccountId != nil {
		_, err = dao.LiveAccount.GetOne(ctx, &dto.GetLiveAccountReq{Id: int64(*req.AccountId)})
		if err != nil {
			return errors.New("直播账号不存在")
		}
	}

	_, err = dao.Schedule.Update(ctx, req)
	return
}

// UpdateStatus 更新排班状态
func (s *scheduleService) UpdateStatus(ctx context.Context, req *dto.UpdateScheduleStatusReq) (err error) {
	_, err = dao.Schedule.UpdateStatus(ctx, req.Id, int(req.Status))
	return
}

// Delete 删除排班
func (s *scheduleService) Delete(ctx context.Context, req *dto.DeleteScheduleReq) (err error) {
	// 检查排班是否存在且未开始
	schedule, err := dao.Schedule.GetOne(ctx, &dto.GetScheduleReq{Id: req.Id})
	if err != nil || schedule == nil {
		return errors.New("排班不存在")
	}

	// 如果已经开始或结束，不允许删除
	if schedule.Status != 0 {
		return errors.New("只能删除待直播的排班")
	}

	_, err = dao.Schedule.Delete(ctx, req)
	return
}

// GetTodaySchedules 获取今日排班
func (s *scheduleService) GetTodaySchedules(ctx context.Context) (res *dto.ListScheduleRes, err error) {
	now := time.Now()
	startOfDay := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
	endOfDay := time.Date(now.Year(), now.Month(), now.Day(), 23, 59, 59, 0, now.Location())

	req := &dto.ListScheduleReq{
		StartDate: startOfDay,
		EndDate:   endOfDay,
	}

	return s.List(ctx, req)
}

// GetAnchorSchedules 获取主播排班
func (s *scheduleService) GetAnchorSchedules(ctx context.Context, anchorId int, startDate, endDate time.Time) (res *dto.ListScheduleRes, err error) {
	req := &dto.ListScheduleReq{
		AnchorId:  &anchorId,
		StartDate: startDate,
		EndDate:   endDate,
	}

	return s.List(ctx, req)
}