package service

import (
	"context"
	"time"

	"github.com/gogf/gf/v2/errors/gerror"

	"cidservice/dao"
	"cidservice/model/dto"
	"cidservice/model/entity"
)

// Report Service 单例
var Report = new(report)

type report struct{}

// Create 创建报表
func (s *report) Create(ctx context.Context, req *dto.CreateReportReq) (res *dto.CreateReportRes, err error) {
	data := &entity.AdReport{
		ReportName:      req.ReportName,
		ReportType:      req.ReportType,
		ReportPeriod:    req.ReportPeriod,
		StartDate:       req.StartDate,
		EndDate:         req.EndDate,
		Status:          "生成中",
		GenerateTime:    time.Now().Unix(),
		FileFormat:      req.FileFormat,
		EmailRecipients: req.EmailRecipients,
		Schedule:        req.Schedule,
	}

	// 存储报表配置
	if req.ReportConfig != nil {
		data.ReportData = []entity.ReportItem{
			{
				Dimension: "config",
				Data:      req.ReportConfig,
			},
		}
	}

	if err = dao.Report.Insert(ctx, data); err != nil {
		return nil, err
	}

	// 异步生成报表
	go s.generateReport(data.Id.Hex(), req)

	res = &dto.CreateReportRes{Id: data.Id.Hex()}
	return
}

// generateReport 生成报表
func (s *report) generateReport(reportId string, req *dto.CreateReportReq) {
	// 模拟生成报表
	time.Sleep(5 * time.Second)

	// 更新报表状态
	ctx := context.Background()

	updateReq := &dto.UpdateReportReq{
		Id:              reportId,
		FileFormat:      req.FileFormat,
		EmailRecipients: req.EmailRecipients,
	}

	err := dao.Report.Update(ctx, updateReq)
	if err != nil {
		// 记录错误日志，这里简化处理
		// 实际项目中应该使用日志框架
	}

	// 发送邮件通知（如果配置了邮件接收人）
	if len(req.EmailRecipients) > 0 {
		// 发送邮件
		// 这里简化处理，实际项目中应该使用邮件服务
	}
}

// GetOne 获取报表详情
func (s *report) GetOne(ctx context.Context, req *dto.GetReportReq) (res *dto.GetReportRes, err error) {
	data, err := dao.Report.GetOne(ctx, req.Id)
	if err != nil {
		return nil, err
	}

	res = &dto.GetReportRes{
		AdReport: data,
	}
	return
}

// List 获取报表列表
func (s *report) List(ctx context.Context, req *dto.ListReportReq) (res *dto.ListReportRes, err error) {
	list, total, err := dao.Report.List(ctx, req)
	if err != nil {
		return nil, err
	}

	res = &dto.ListReportRes{
		List:  list,
		Total: int(total),
	}
	return
}

// Update 更新报表
func (s *report) Update(ctx context.Context, req *dto.UpdateReportReq) (err error) {
	return dao.Report.Update(ctx, req)
}

// Delete 删除报表
func (s *report) Delete(ctx context.Context, req *dto.DeleteReportReq) (err error) {
	return dao.Report.Delete(ctx, req.Id)
}

// Download 下载报表
func (s *report) Download(ctx context.Context, req *dto.DownloadReportReq) (res *dto.DownloadReportRes, err error) {
	data, err := dao.Report.GetOne(ctx, req.Id)
	if err != nil {
		return nil, err
	}

	// 检查报表状态
	if data.Status != "已完成" {
		return nil, gerror.New("报表尚未生成完成")
	}

	// 检查报表是否过期
	if data.ExpiredTime > 0 && data.ExpiredTime < time.Now().Unix() {
		return nil, gerror.New("报表已过期")
	}

	res = &dto.DownloadReportRes{
		DownloadUrl: data.DownloadUrl,
		FileSize:    data.FileSize,
		FileFormat:  data.FileFormat,
	}
	return
}

// Generate 生成报表
func (s *report) Generate(ctx context.Context, req *dto.GenerateReportReq) (err error) {
	data, err := dao.Report.GetOne(ctx, req.Id)
	if err != nil {
		return err
	}

	// 构建创建报表请求
	createReq := &dto.CreateReportReq{
		ReportName:      data.ReportName,
		ReportType:      data.ReportType,
		ReportPeriod:    data.ReportPeriod,
		StartDate:       data.StartDate,
		EndDate:         data.EndDate,
		FileFormat:      data.FileFormat,
		EmailRecipients: data.EmailRecipients,
		Schedule:        data.Schedule,
	}

	// 从ReportData中获取报表配置
	if len(data.ReportData) > 0 {
		for _, item := range data.ReportData {
			if item.Dimension == "config" {
				createReq.ReportConfig = item.Data
				break
			}
		}
	}

	// 异步生成报表
	go s.generateReport(req.Id, createReq)

	// 更新状态
	updateReq := &dto.UpdateReportReq{
		Id: req.Id,
	}

	err = dao.Report.Update(ctx, updateReq)
	return
}