package api

import (
	"fmt"
	"strconv"
	"sync"
	"time"

	"codex-pool/internal/database"
	"codex-pool/internal/logger"
)

var (
	cleanerRunning  bool
	cleanerMu       sync.Mutex
	cleanerStopChan chan struct{}
	lastCleanTime   time.Time
)

// StartErrorCleanerService 启动定期清理错误账号服务
func StartErrorCleanerService() {
	cleanerMu.Lock()
	if cleanerRunning {
		cleanerMu.Unlock()
		return
	}
	cleanerRunning = true
	cleanerStopChan = make(chan struct{})
	cleanerMu.Unlock()

	logger.Info("错误账号清理服务已启动（需在配置中启用）", "", "cleaner")

	go func() {
		for {
			// 读取清理间隔配置 (默认 3600 秒 = 1 小时)
			cleanInterval := 3600
			if database.Instance != nil {
				if val, _ := database.Instance.GetConfig("error_clean_interval"); val != "" {
					if v, err := strconv.Atoi(val); err == nil && v >= 60 {
						cleanInterval = v
					}
				}
			}

			select {
			case <-cleanerStopChan:
				logger.Info("错误账号清理服务已停止", "", "cleaner")
				return
			case <-time.After(time.Duration(cleanInterval) * time.Second):
				checkAndCleanErrors()
			}
		}
	}()
}

// StopErrorCleanerService 停止错误账号清理服务
func StopErrorCleanerService() {
	cleanerMu.Lock()
	defer cleanerMu.Unlock()

	if cleanerRunning && cleanerStopChan != nil {
		close(cleanerStopChan)
		cleanerRunning = false
	}
}

// checkAndCleanErrors 检查配置并清理错误账号
func checkAndCleanErrors() {
	if database.Instance == nil {
		return
	}

	// 检查是否启用了自动清理
	enabled := false
	if val, _ := database.Instance.GetConfig("error_clean_enabled"); val == "true" {
		enabled = true
	}
	if !enabled {
		return
	}

	// 获取错误账号列表
	errorAccounts, err := fetchAllErrorAccounts()
	if err != nil {
		logger.Error(fmt.Sprintf("获取错误账号列表失败: %v", err), "", "cleaner")
		return
	}

	if len(errorAccounts) == 0 {
		logger.Info("无错误账号需要清理", "", "cleaner")
		lastCleanTime = time.Now()
		return
	}

	// 执行清理
	logger.Status(fmt.Sprintf("定期清理错误账号中: 共 %d 个", len(errorAccounts)), "", "cleaner")

	success := 0
	failed := 0

	for _, account := range errorAccounts {
		err := deleteS2AAccount(account.ID)
		if err != nil {
			failed++
			logger.Warning(fmt.Sprintf("删除账号失败: ID=%d, Email=%s, Error=%v", account.ID, account.Email, err), account.Email, "cleaner")
		} else {
			success++
		}
	}

	lastCleanTime = time.Now()
	logger.Success(fmt.Sprintf("定期清理错误账号完成: 成功=%d, 失败=%d, 总数=%d", success, failed, len(errorAccounts)), "", "cleaner")
}

// GetCleanerStatus 获取清理服务状态
func GetCleanerStatus() map[string]interface{} {
	cleanerMu.Lock()
	defer cleanerMu.Unlock()

	enabled := false
	interval := 3600
	if database.Instance != nil {
		if val, _ := database.Instance.GetConfig("error_clean_enabled"); val == "true" {
			enabled = true
		}
		if val, _ := database.Instance.GetConfig("error_clean_interval"); val != "" {
			if v, err := strconv.Atoi(val); err == nil {
				interval = v
			}
		}
	}

	return map[string]interface{}{
		"running":         cleanerRunning,
		"enabled":         enabled,
		"interval":        interval,
		"last_clean_time": lastCleanTime.Format(time.RFC3339),
	}
}