package admin

// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// * Copyright 2023 The Geek-AI Authors. All rights reserved.
// * Use of this source code is governed by a Apache-2.0 license
// * that can be found in the LICENSE file.
// * @Author yangjian102621@163.com
// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

import (
	"geekai/core"
	"geekai/core/middleware"
	"geekai/core/types"
	"geekai/handler"
	"geekai/service"
	"geekai/service/oss"
	"geekai/service/payment"
	"geekai/service/sms"
	"geekai/store/model"
	"geekai/utils"
	"geekai/utils/resp"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

type ConfigHandler struct {
	handler.BaseHandler
	licenseService *service.LicenseService
	sysConfig      *types.SystemConfig
	alipayService  *payment.AlipayService
	wxpayService   *payment.WxPayService
	epayService    *payment.EPayService
	smsAliyun      *sms.AliYunSmsService
	smsBao         *sms.BaoSmsService
	smsManager     *sms.SmsManager
	localOss       *oss.LocalStorage
	qiniuOss       *oss.QiNiuOss
	aliyunOss      *oss.AliYunOss
	minioOss       *oss.MiniOss
	smtpService    *service.SmtpService
	captchaService *service.CaptchaService
	wxLoginService *service.WxLoginService
}

func NewConfigHandler(
	app *core.AppServer,
	db *gorm.DB,
	licenseService *service.LicenseService,
	sysConfig *types.SystemConfig,
	alipayService *payment.AlipayService,
	wxpayService *payment.WxPayService,
	epayService *payment.EPayService,
	smsAliyun *sms.AliYunSmsService,
	smsBao *sms.BaoSmsService,
	smsManager *sms.SmsManager,
	localOss *oss.LocalStorage,
	qiniuOss *oss.QiNiuOss,
	aliyunOss *oss.AliYunOss,
	minioOss *oss.MiniOss,
	smtpService *service.SmtpService,
	captchaService *service.CaptchaService,
	wxLoginService *service.WxLoginService,
) *ConfigHandler {
	return &ConfigHandler{
		BaseHandler:    handler.BaseHandler{App: app, DB: db},
		licenseService: licenseService,
		sysConfig:      sysConfig,
		alipayService:  alipayService,
		wxpayService:   wxpayService,
		epayService:    epayService,
		smsAliyun:      smsAliyun,
		smsBao:         smsBao,
		smsManager:     smsManager,
		localOss:       localOss,
		qiniuOss:       qiniuOss,
		aliyunOss:      aliyunOss,
		minioOss:       minioOss,
		smtpService:    smtpService,
		captchaService: captchaService,
		wxLoginService: wxLoginService,
	}
}

// RegisterRoutes 注册路由
func (h *ConfigHandler) RegisterRoutes() {
	rg := h.App.Engine.Group("/api/admin/config")

	// 需要管理员登录的接口
	rg.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
	{
		rg.POST("update/base", h.UpdateBase)
		rg.POST("update/power", h.UpdatePower)
		rg.POST("update/notice", h.UpdateNotice)
		rg.POST("update/captcha", h.UpdateCaptcha)
		rg.POST("update/wx_login", h.UpdateWxLogin)
		rg.POST("update/payment", h.UpdatePayment)
		rg.POST("update/sms", h.UpdateSms)
		rg.POST("update/oss", h.UpdateOss)
		rg.POST("update/smtp", h.UpdateStmp)
		rg.GET("get", h.Get)
		rg.POST("license/active", h.Active)
		rg.GET("license/get", h.GetLicense)
	}
}

// UpdateBase 更新基础配置
func (h *ConfigHandler) UpdateBase(c *gin.Context) {
	var data types.BaseConfig

	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}

	// 未授权的话不允许修改版权
	license := h.licenseService.GetLicense()
	if !license.IsActive && data.Copyright != h.sysConfig.Base.Copyright {
		resp.ERROR(c, "未授权系统不允许修改版权信息")
		return
	}

	// 未授权的话不允许修改 Logo
	if !license.IsActive && data.Logo != h.sysConfig.Base.Logo {
		resp.ERROR(c, "未授权系统不允许修改 Logo")
		return
	}

	err := h.Update(types.ConfigKeySystem, data)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}

	h.sysConfig.Base = data

	resp.SUCCESS(c, data)
}

// UpdatePower 更新系统配置
func (h *ConfigHandler) UpdatePower(c *gin.Context) {
	var data struct {
		InitPower         int            `json:"init_power,omitempty"`          // 新用户注册赠送算力值
		DailyPower        int            `json:"daily_power,omitempty"`         // 每日签到赠送算力
		InvitePower       int            `json:"invite_power,omitempty"`        // 邀请新用户赠送算力值
		MjPower           int            `json:"mj_power,omitempty"`            // MJ 绘画消耗算力
		MjActionPower     int            `json:"mj_action_power,omitempty"`     // MJ 操作（放大，变换）消耗算力
		SdPower           int            `json:"sd_power,omitempty"`            // SD 绘画消耗算力
		SunoPower         int            `json:"suno_power,omitempty"`          // Suno 生成歌曲消耗算力
		LumaPower         int            `json:"luma_power,omitempty"`          // Luma 生成视频消耗算力
		KeLingPowers      map[string]int `json:"keling_powers,omitempty"`       // 可灵生成视频消耗算力
		AdvanceVoicePower int            `json:"advance_voice_power,omitempty"` // 高级语音对话消耗算力
		PromptPower       int            `json:"prompt_power,omitempty"`        // 生成提示词消耗算力
	}
	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}

	h.sysConfig.Base.InitPower = data.InitPower
	h.sysConfig.Base.DailyPower = data.DailyPower
	h.sysConfig.Base.InvitePower = data.InvitePower
	h.sysConfig.Base.MjPower = data.MjPower
	h.sysConfig.Base.MjActionPower = data.MjActionPower
	h.sysConfig.Base.SdPower = data.SdPower
	h.sysConfig.Base.SunoPower = data.SunoPower
	h.sysConfig.Base.LumaPower = data.LumaPower
	h.sysConfig.Base.KeLingPowers = data.KeLingPowers
	h.sysConfig.Base.AdvanceVoicePower = data.AdvanceVoicePower
	h.sysConfig.Base.PromptPower = data.PromptPower

	err := h.Update(types.ConfigKeySystem, h.sysConfig.Base)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}

	resp.SUCCESS(c, h.sysConfig.Base)
}

// UpdateNotice 更新公告配置
func (h *ConfigHandler) UpdateNotice(c *gin.Context) {
	var data struct {
		Content string `json:"content"`
	}
	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}

	err := h.Update(types.ConfigKeyNotice, data)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}

	resp.SUCCESS(c, data)
}

// UpdateCaptcha 更新行为验证码配置
func (h *ConfigHandler) UpdateCaptcha(c *gin.Context) {
	var data types.CaptchaConfig
	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}

	err := h.Update(types.ConfigKeyCaptcha, data)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}
	if data.Enabled {
		h.captchaService.UpdateConfig(data)
	}
	h.sysConfig.Captcha = data
	resp.SUCCESS(c, data)

}

// UpdatePayment 更新支付配置
func (h *ConfigHandler) UpdatePayment(c *gin.Context) {
	var data types.PaymentConfig
	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}

	var config model.Config
	oldData := types.PaymentConfig{}
	err := h.DB.Where("name", types.ConfigKeyPayment).First(&config).Error
	if err == nil {
		utils.JsonDecode(config.Value, &oldData)
	}

	err = h.Update(types.ConfigKeyPayment, data)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}

	// 如果启用状态发生改变，则需要更新支付服务配置
	if data.WxPay.Enabled {
		err = h.wxpayService.UpdateConfig(&data.WxPay)
		if err != nil {
			resp.ERROR(c, err.Error())
			return
		}
	}
	if data.Epay.Enabled {
		h.epayService.UpdateConfig(&data.Epay)
	}
	if data.Alipay.Enabled {
		err = h.alipayService.UpdateConfig(&data.Alipay)
		if err != nil {
			resp.ERROR(c, err.Error())
			return
		}
	}

	h.sysConfig.Payment = data
	resp.SUCCESS(c, data)
}

// UpdateSms 更新短信配置
func (h *ConfigHandler) UpdateSms(c *gin.Context) {
	var data types.SMSConfig
	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}

	var config model.Config
	oldData := types.SMSConfig{}
	err := h.DB.Where("name", types.ConfigKeySms).First(&config).Error
	if err == nil {
		utils.JsonDecode(config.Value, &oldData)
	}

	err = h.Update(types.ConfigKeySms, data)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}

	// 更新服务配置
	switch data.Active {
	case sms.Ali:
		err = h.smsAliyun.UpdateConfig(&data.Ali)
		if err != nil {
			resp.ERROR(c, err.Error())
			return
		}
	case sms.Bao:
		h.smsBao.UpdateConfig(&data.Bao)
	}

	h.smsManager.SetActive(data.Active)

	resp.SUCCESS(c, data)
}

// UpdateOss 更新 Oss 配置
func (h *ConfigHandler) UpdateOss(c *gin.Context) {
	var data types.OSSConfig
	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}

	var config model.Config
	oldData := types.OSSConfig{}
	err := h.DB.Where("name", types.ConfigKeyOss).First(&config).Error
	if err == nil {
		utils.JsonDecode(config.Value, &oldData)
	}

	err = h.Update("oss", data)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}

	// 更新服务配置
	switch data.Active {
	case oss.Local:
		h.localOss.UpdateConfig(&data.Local)
	case oss.QiNiu:
		h.qiniuOss.UpdateConfig(&data.QiNiu)
	case oss.AliYun:
		err := h.aliyunOss.UpdateConfig(&data.AliYun)
		if err != nil {
			resp.ERROR(c, err.Error())
			return
		}
	case oss.Minio:
		err := h.minioOss.UpdateConfig(&data.Minio)
		if err != nil {
			resp.ERROR(c, err.Error())
			return
		}
	}

	h.sysConfig.OSS = data

	resp.SUCCESS(c, data)
}

// UpdateStmp 更新 Stmp 配置
func (h *ConfigHandler) UpdateStmp(c *gin.Context) {
	var data types.SmtpConfig
	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}

	var config model.Config
	oldData := types.SmtpConfig{}
	err := h.DB.Where("name", types.ConfigKeySmtp).First(&config).Error
	if err == nil {
		utils.JsonDecode(config.Value, &oldData)
	}

	err = h.Update(types.ConfigKeySmtp, data)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}

	// 配置发生改变时更新服务配置
	if !data.Equal(&oldData) {
		h.smtpService.UpdateConfig(&data)
	}

	h.sysConfig.SMTP = data
	resp.SUCCESS(c, data)
}

// UpdateWxLogin 更新微信登录配置
func (h *ConfigHandler) UpdateWxLogin(c *gin.Context) {
	var data types.WxLoginConfig
	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}
	err := h.Update(types.ConfigKeyWxLogin, data)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}

	if data.Enabled {
		h.wxLoginService.UpdateConfig(data)
	}

	h.sysConfig.WxLogin = data
	resp.SUCCESS(c, data)
}

// Update 更新系统配置
func (h *ConfigHandler) Update(name string, value any) error {
	var config model.Config
	err := h.DB.Where("name", name).First(&config).Error
	if err != nil { // 不存在则创建
		config.Name = name
		config.Value = utils.JsonEncode(value)
		return h.DB.Create(&config).Error
	} else { // 存在则更新
		config.Value = utils.JsonEncode(value)
		return h.DB.Updates(&config).Error
	}

}

// Get 获取指定名称的系统配置
func (h *ConfigHandler) Get(c *gin.Context) {
	name := c.Query("key")
	var config model.Config
	res := h.DB.Where("name", name).First(&config)
	if res.Error != nil {
		resp.ERROR(c, res.Error.Error())
		return
	}

	var value map[string]any
	err := utils.JsonDecode(config.Value, &value)
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}

	resp.SUCCESS(c, value)
}

// Active 激活系统
func (h *ConfigHandler) Active(c *gin.Context) {
	var data struct {
		License string `json:"license"`
	}
	if err := c.ShouldBindJSON(&data); err != nil {
		resp.ERROR(c, types.InvalidArgs)
		return
	}

	err := h.licenseService.ActiveLicense(data.License)
	license := h.licenseService.GetLicense()
	if err != nil {
		resp.ERROR(c, err.Error())
		return
	}
	if err := h.Update(types.ConfigKeyLicense, license); err != nil {
		resp.ERROR(c, err.Error())
		return
	}
	// 更新系统配置
	h.sysConfig.License = *license

	resp.SUCCESS(c, license.MachineId)

}

// GetLicense 获取 License 信息
func (h *ConfigHandler) GetLicense(c *gin.Context) {
	license := h.licenseService.GetLicense()
	resp.SUCCESS(c, license)
}

//