package dao

import (
	"context"

	"cidservice/model/dto"
	"cidservice/model/entity"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo/options"

	"gitee.com/red-future---jilin-g/common/http"
	"gitee.com/red-future---jilin-g/common/mongo"
)

// Report DAO 单例
var Report = &report{}

type report struct{}

// Insert 插入报表
func (d *report) Insert(ctx context.Context, report *entity.AdReport) (err error) {
	// 如果 ID 为空，生成一个新的 ObjectID
	if report.Id.IsZero() {
		report.Id = bson.NewObjectID()
	}
	_, err = mongo.Insert(ctx, []interface{}{report}, entity.AdReportCollection)
	return
}

// Update 更新报表
func (d *report) Update(ctx context.Context, req *dto.UpdateReportReq) (err error) {
	objectId, err := bson.ObjectIDFromHex(req.Id)
	if err != nil {
		return
	}
	filter := bson.M{"_id": objectId}

	// 构建动态更新字段
	updateFields := bson.M{}

	if !g.IsEmpty(req.ReportName) {
		updateFields["reportName"] = req.ReportName
	}
	if !g.IsEmpty(req.ReportType) {
		updateFields["reportType"] = req.ReportType
	}
	if !g.IsEmpty(req.ReportPeriod) {
		updateFields["reportPeriod"] = req.ReportPeriod
	}
	if req.StartDate != nil {
		updateFields["startDate"] = *req.StartDate
	}
	if req.EndDate != nil {
		updateFields["endDate"] = *req.EndDate
	}
	if req.ReportConfig != nil {
		updateFields["reportConfig"] = req.ReportConfig
	}
	if !g.IsEmpty(req.FileFormat) {
		updateFields["fileFormat"] = req.FileFormat
	}
	if req.EmailRecipients != nil {
		updateFields["emailRecipients"] = req.EmailRecipients
	}
	if !g.IsEmpty(req.Schedule) {
		updateFields["schedule"] = req.Schedule
	}

	if len(updateFields) > 0 {
		update := bson.M{"$set": updateFields}
		_, err = mongo.Update(ctx, filter, update, entity.AdReportCollection)
	}
	return
}

// Delete 删除报表
func (d *report) Delete(ctx context.Context, id string) (err error) {
	objectId, err := bson.ObjectIDFromHex(id)
	if err != nil {
		return
	}
	filter := bson.M{"_id": objectId}

	_, err = mongo.Delete(ctx, filter, entity.AdReportCollection)
	return
}

// GetOne 获取单个报表
func (d *report) GetOne(ctx context.Context, id string) (result *entity.AdReport, err error) {
	objectId, err := bson.ObjectIDFromHex(id)
	if err != nil {
		return
	}
	filter := bson.M{"_id": objectId}

	result = &entity.AdReport{}
	err = mongo.FindOne(ctx, filter, result, entity.AdReportCollection)
	return
}

// buildReportListFilter 构建报表列表查询的过滤条件
func (d *report) buildReportListFilter(req *dto.ListReportReq) bson.M {
	filter := bson.M{}

	if !g.IsEmpty(req.ReportName) {
		filter["reportName"] = bson.M{"$regex": req.ReportName, "$options": "i"}
	}
	if !g.IsEmpty(req.ReportType) {
		filter["reportType"] = req.ReportType
	}
	if !g.IsEmpty(req.Status) {
		filter["status"] = req.Status
	}
	if !g.IsEmpty(req.Operator) {
		filter["operator"] = req.Operator
	}

	// 处理日期范围
	if len(req.DateRange) == 2 {
		startTime := gconv.Int64(req.DateRange[0])
		endTime := gconv.Int64(req.DateRange[1])
		filter["createdAt"] = bson.M{
			"$gte": startTime,
			"$lte": endTime,
		}
	}

	return filter
}

// checkReportTotalCount 检查报表总数
func (d *report) checkReportTotalCount(ctx context.Context, filter bson.M) (total int64, err error) {
	total, err = mongo.Count(ctx, filter, entity.AdReportCollection)
	return
}

// List 获取报表列表
func (d *report) List(ctx context.Context, req *dto.ListReportReq) (list []*entity.AdReport, total int64, err error) {
	// 构建查询过滤条件
	filter := d.buildReportListFilter(req)

	// 检查总数
	total, err = d.checkReportTotalCount(ctx, filter)
	if err != nil {
		return
	}

	// 分页参数处理
	pageNum := req.PageNum
	if pageNum <= 0 {
		pageNum = 1
	}
	pageSize := req.PageSize
	if pageSize <= 0 {
		pageSize = http.PageSize
	}

	limit := int64(pageSize)
	skip := int64((pageNum - 1) * pageSize)

	// 排序处理
	sort := bson.M{"createdAt": -1}

	opts := options.Find().SetLimit(limit).SetSkip(skip).SetSort(sort)

	err = mongo.Find(ctx, filter, &list, entity.AdReportCollection, opts)
	return
}