package api

import (
	"encoding/json"
	"net/http"
	"strconv"

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

// MonitorSettings 监控设置
type MonitorSettings struct {
	Target            int  `json:"target"`
	AutoAdd           bool `json:"auto_add"`
	MinInterval       int  `json:"min_interval"`
	CheckInterval     int  `json:"check_interval"` // 自动补号检查间隔（秒）
	PollingEnabled    bool `json:"polling_enabled"`
	PollingInterval   int  `json:"polling_interval"`
	ReplenishUseProxy bool `json:"replenish_use_proxy"` // 补号时使用代理
}

// HandleGetMonitorSettings 获取监控设置
func HandleGetMonitorSettings(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		Error(w, http.StatusMethodNotAllowed, "仅支持 GET")
		return
	}

	if database.Instance == nil {
		Error(w, http.StatusInternalServerError, "数据库未初始化")
		return
	}

	settings := MonitorSettings{
		Target:            50,
		AutoAdd:           false,
		MinInterval:       300,
		CheckInterval:     60,
		PollingEnabled:    false,
		PollingInterval:   60,
		ReplenishUseProxy: false,
	}

	if val, _ := database.Instance.GetConfig("monitor_target"); val != "" {
		if v, err := strconv.Atoi(val); err == nil {
			settings.Target = v
		}
	}
	if val, _ := database.Instance.GetConfig("monitor_auto_add"); val == "true" {
		settings.AutoAdd = true
	}
	if val, _ := database.Instance.GetConfig("monitor_min_interval"); val != "" {
		if v, err := strconv.Atoi(val); err == nil {
			settings.MinInterval = v
		}
	}
	if val, _ := database.Instance.GetConfig("monitor_check_interval"); val != "" {
		if v, err := strconv.Atoi(val); err == nil {
			settings.CheckInterval = v
		}
	}
	if val, _ := database.Instance.GetConfig("monitor_polling_enabled"); val == "true" {
		settings.PollingEnabled = true
	}
	if val, _ := database.Instance.GetConfig("monitor_polling_interval"); val != "" {
		if v, err := strconv.Atoi(val); err == nil {
			settings.PollingInterval = v
		}
	}
	if val, _ := database.Instance.GetConfig("monitor_replenish_use_proxy"); val == "true" {
		settings.ReplenishUseProxy = true
	}

	Success(w, settings)
}

// HandleSaveMonitorSettings 保存监控设置
func HandleSaveMonitorSettings(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		Error(w, http.StatusMethodNotAllowed, "仅支持 POST")
		return
	}

	if database.Instance == nil {
		logger.Error("保存监控设置失败: 数据库未初始化", "", "monitor")
		Error(w, http.StatusInternalServerError, "数据库未初始化")
		return
	}

	var settings MonitorSettings
	if err := json.NewDecoder(r.Body).Decode(&settings); err != nil {
		logger.Error("保存监控设置失败: 解析请求失败 - "+err.Error(), "", "monitor")
		Error(w, http.StatusBadRequest, "解析请求失败")
		return
	}

	logger.Info("收到保存监控设置请求: target="+strconv.Itoa(settings.Target)+
		", auto_add="+strconv.FormatBool(settings.AutoAdd)+
		", check_interval="+strconv.Itoa(settings.CheckInterval)+
		", polling="+strconv.FormatBool(settings.PollingEnabled), "", "monitor")

	// 保存到数据库
	var saveErrors []string
	if err := database.Instance.SetConfig("monitor_target", strconv.Itoa(settings.Target)); err != nil {
		saveErrors = append(saveErrors, "target: "+err.Error())
	}
	if err := database.Instance.SetConfig("monitor_auto_add", strconv.FormatBool(settings.AutoAdd)); err != nil {
		saveErrors = append(saveErrors, "auto_add: "+err.Error())
	}
	if err := database.Instance.SetConfig("monitor_min_interval", strconv.Itoa(settings.MinInterval)); err != nil {
		saveErrors = append(saveErrors, "min_interval: "+err.Error())
	}
	// 检查间隔最小10秒
	checkInterval := settings.CheckInterval
	if checkInterval < 10 {
		checkInterval = 10
	}
	if err := database.Instance.SetConfig("monitor_check_interval", strconv.Itoa(checkInterval)); err != nil {
		saveErrors = append(saveErrors, "check_interval: "+err.Error())
	}
	if err := database.Instance.SetConfig("monitor_polling_enabled", strconv.FormatBool(settings.PollingEnabled)); err != nil {
		saveErrors = append(saveErrors, "polling_enabled: "+err.Error())
	}
	if err := database.Instance.SetConfig("monitor_polling_interval", strconv.Itoa(settings.PollingInterval)); err != nil {
		saveErrors = append(saveErrors, "polling_interval: "+err.Error())
	}
	if err := database.Instance.SetConfig("monitor_replenish_use_proxy", strconv.FormatBool(settings.ReplenishUseProxy)); err != nil {
		saveErrors = append(saveErrors, "replenish_use_proxy: "+err.Error())
	}

	if len(saveErrors) > 0 {
		errMsg := "保存监控设置部分失败: " + saveErrors[0]
		logger.Error(errMsg, "", "monitor")
		Error(w, http.StatusInternalServerError, errMsg)
		return
	}

	// 输出日志
	logger.Success("监控设置已保存: target="+strconv.Itoa(settings.Target)+
		", auto_add="+strconv.FormatBool(settings.AutoAdd)+
		", check_interval="+strconv.Itoa(checkInterval)+"s"+
		", polling="+strconv.FormatBool(settings.PollingEnabled)+
		", polling_interval="+strconv.Itoa(settings.PollingInterval)+"s", "", "monitor")

	Success(w, map[string]interface{}{
		"message":  "设置已保存",
		"settings": settings,
	})
}