package task

import (
	"context"
	"database/sql"
	"fmt"

	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"

	"easygoadmin/internal/dao"
	"easygoadmin/internal/logic"
)

func init() {
	logic.RegisterJobHandler("LogClean", logClean)
}

const (
	logCleanBatch    = 5000   // 单批删除行数
	logCleanMaxTotal = 200000 // 单表单次任务删除行数上限（防长事务与 runaway）
)

// logClean 日志清理任务
//
// 分批物理删除操作日志/登录日志/任务日志中超过保留天数的历史记录。
// 任务参数 retentionDays 可覆盖配置 job.logRetentionDays（默认 90 天），为 0 时取配置值。
func logClean(ctx context.Context, params string) (string, error) {
	days := gjson.New(params).Get("retentionDays").Int()
	if days <= 0 {
		days = g.Cfg().MustGet(ctx, "job.logRetentionDays").Int()
	}
	if days <= 0 {
		days = 90
	}
	before := gtime.Now().AddDate(0, 0, -days)

	counts := map[string]int{}
	for name, clean := range map[string]func(context.Context, *gtime.Time) (int, error){
		"操作日志": cleanOperationLog,
		"登录日志": cleanLoginLog,
		"任务日志": cleanJobLog,
	} {
		n, err := clean(ctx, before)
		if err != nil {
			return "", fmt.Errorf("%s清理失败: %w", name, err)
		}
		counts[name] = n
	}
	return fmt.Sprintf("保留 %d 天，清理完成: 操作日志 %d 条，登录日志 %d 条，任务日志 %d 条",
		days, counts["操作日志"], counts["登录日志"], counts["任务日志"]), nil
}

// cleanOperationLog 分批删除超过保留期限的操作日志
func cleanOperationLog(ctx context.Context, before *gtime.Time) (int, error) {
	return deleteInBatches(ctx, func() (int64, error) {
		res, err := dao.OperationLog.Ctx(ctx).WhereLT("create_time", before).Limit(logCleanBatch).Delete()
		return affectedOf(res), err
	})
}

// cleanLoginLog 分批删除超过保留期限的登录日志
func cleanLoginLog(ctx context.Context, before *gtime.Time) (int, error) {
	return deleteInBatches(ctx, func() (int64, error) {
		res, err := dao.LoginLog.Ctx(ctx).WhereLT("create_time", before).Limit(logCleanBatch).Delete()
		return affectedOf(res), err
	})
}

// cleanJobLog 分批删除超过保留期限的任务日志
func cleanJobLog(ctx context.Context, before *gtime.Time) (int, error) {
	return deleteInBatches(ctx, func() (int64, error) {
		res, err := dao.JobLog.Ctx(ctx).WhereLT("create_time", before).Limit(logCleanBatch).Delete()
		return affectedOf(res), err
	})
}

// deleteInBatches 循环分批删除
// 每批删除 logCleanBatch 行，直到不足一批或达到单次上限
func deleteInBatches(ctx context.Context, del func() (int64, error)) (int, error) {
	total := 0
	for {
		n, err := del()
		if err != nil {
			return total, err
		}
		total += int(n)
		if n < int64(logCleanBatch) || total >= logCleanMaxTotal {
			return total, nil
		}
	}
}

// affectedOf 读取受影响行数
// RowsAffected 的错误在此场景可忽略（驱动不支持时按 0 处理，循环自然终止）
func affectedOf(res sql.Result) int64 {
	if res == nil {
		return 0
	}
	n, _ := res.RowsAffected()
	return n
}