package service

import (
	"fmt"
	"strconv"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/ghttp"
	"github.com/gogf/gf/v2/os/gtime"
	"nl-video-api/internal/dao"
	"nl-video-api/internal/model/entity"
	"nl-video-api/utility/response"
)

// ConfigService 系统配置服务
type ConfigService struct{}

var Config = &ConfigService{}

// NewConfigService 创建配置服务实例
func NewConfigService() *ConfigService {
	return &ConfigService{}
}

// AdminList 管理员获取配置列表
func (s *ConfigService) AdminList(r *ghttp.Request) {
	response.Success(r, g.Map{
		"list":  []interface{}{},
		"total": 0,
	})
}

// AdminDetail 管理员获取配置详情
func (s *ConfigService) AdminDetail(r *ghttp.Request) {
	response.Success(r, g.Map{
		"id":    1,
		"key":   "site_name",
		"value": "NL视频网站",
		"desc":  "网站名称",
	})
}

// AdminCreate 管理员创建配置
func (s *ConfigService) AdminCreate(r *ghttp.Request) {
	response.Success(r, "创建成功")
}

// AdminUpdate 管理员更新配置
func (s *ConfigService) AdminUpdate(r *ghttp.Request) {
	response.Success(r, "更新成功")
}

// AdminDelete 管理员删除配置
func (s *ConfigService) AdminDelete(r *ghttp.Request) {
	response.Success(r, "删除成功")
}

// AdminBatchDelete 管理员批量删除配置
func (s *ConfigService) AdminBatchDelete(r *ghttp.Request) {
	response.Success(r, "批量删除成功")
}

// AdminGetByKey 管理员根据键获取配置
func (s *ConfigService) AdminGetByKey(r *ghttp.Request) {
	response.Success(r, g.Map{
		"key":   "site_name",
		"value": "NL视频网站",
	})
}

// AdminGetByGroup 管理员根据分组获取配置
func (s *ConfigService) AdminGetByGroup(r *ghttp.Request) {
	response.Success(r, g.Map{
		"list": []interface{}{},
		"total": 0,
	})
}

// AdminSet 管理员设置配置
func (s *ConfigService) AdminSet(r *ghttp.Request) {
	response.Success(r, "设置成功")
}

// AdminBatchSet 管理员批量设置配置
func (s *ConfigService) AdminBatchSet(r *ghttp.Request) {
	response.Success(r, "批量设置成功")
}

// AdminGetGroupList 管理员获取配置分组列表
func (s *ConfigService) AdminGetGroupList(r *ghttp.Request) {
	response.Success(r, g.Map{
		"list": []string{"基础设置", "系统设置", "邮件设置"},
	})
}

// AdminExport 管理员导出配置
func (s *ConfigService) AdminExport(r *ghttp.Request) {
	response.Success(r, "导出成功")
}

// AdminImport 管理员导入配置
func (s *ConfigService) AdminImport(r *ghttp.Request) {
	response.Success(r, "导入成功")
}

// AdminCache 管理员获取缓存配置
func (s *ConfigService) AdminCache(r *ghttp.Request) {
	response.Success(r, g.Map{
		"cache_enabled": true,
		"cache_time": 3600,
	})
}

// AdminClearCache 管理员清除配置缓存
func (s *ConfigService) AdminClearCache(r *ghttp.Request) {
	response.Success(r, "缓存清除成功")
}

// AdminValidate 管理员验证配置
func (s *ConfigService) AdminValidate(r *ghttp.Request) {
	response.Success(r, "配置验证通过")
}

// AdminBackup 管理员备份配置
func (s *ConfigService) AdminBackup(r *ghttp.Request) {
	response.Success(r, "配置备份成功")
}

// AdminRestore 管理员恢复配置
func (s *ConfigService) AdminRestore(r *ghttp.Request) {
	response.Success(r, "配置恢复成功")
}

// AdminGetHistory 管理员获取配置历史
func (s *ConfigService) AdminGetHistory(r *ghttp.Request) {
	response.Success(r, g.Map{
		"list": []interface{}{},
		"total": 0,
	})
}

// GetList 获取配置列表
func (s *ConfigService) GetList(r *ghttp.Request) {
	// 获取请求参数
	keyword := r.Get("keyword").String()
	pageStr := r.Get("page", "1").String()
	pageSizeStr := r.Get("page_size", "10").String()

	page, err := strconv.Atoi(pageStr)
	if err != nil || page < 1 {
		page = 1
	}

	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil || pageSize < 1 {
		pageSize = 10
	}

	// 构建查询条件
	query := dao.Config.Ctx(r.Context())
	if keyword != "" {
		query = query.Where("`key` LIKE ? OR name LIKE ?", 
			fmt.Sprintf("%%%s%%", keyword), 
			fmt.Sprintf("%%%s%%", keyword))
	}

	// 获取总数
	total, err := query.Count()
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取配置总数失败")
		return
	}

	// 获取列表
	var list []*entity.Config
	err = query.Page(page, pageSize).OrderAsc("`key`").Scan(&list)
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取配置列表失败")
		return
	}

	response.Success(r, g.Map{
		"list":      list,
		"total":     total,
		"page":      page,
		"page_size": pageSize,
	})
}

// GetByKey 根据键获取配置
func (s *ConfigService) GetByKey(r *ghttp.Request) {
	// 获取请求参数
	configKey := r.Get("key").String()
	if configKey == "" {
		response.Error(r, response.CodeInvalidParam, "配置键不能为空")
		return
	}

	// 查询配置
	var config entity.Config
	err := dao.Config.Ctx(r.Context()).Where("`key`", configKey).Scan(&config)
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取配置失败")
		return
	}

	if config.Id == 0 {
		response.Error(r, response.CodeNotFound, "配置不存在")
		return
	}

	response.Success(r, config)
}

// Add 添加配置
func (s *ConfigService) Add(r *ghttp.Request) {
	// 获取请求参数
	configKey := r.Get("config_key").String()
	configName := r.Get("config_name").String()
	configValue := r.Get("config_value").String()
	configType := r.Get("config_type").String()
	description := r.Get("description").String()

	// 参数验证
	if configKey == "" || configName == "" {
		response.Error(r, response.CodeInvalidParam, "配置键和配置名称不能为空")
		return
	}

	// 检查配置键是否已存在
	count, err := dao.Config.Ctx(r.Context()).Where("config_key", configKey).Count()
	if err != nil {
		response.Error(r, response.CodeInternalError, "检查配置键失败")
		return
	}
	if count > 0 {
		response.Error(r, response.CodeInvalidParam, "配置键已存在")
		return
	}

	// 创建配置
	_, err = dao.Config.Ctx(r.Context()).Data(g.Map{
		"config_key":   configKey,
		"config_name":  configName,
		"config_value": configValue,
		"config_type":  configType,
		"description":  description,
		"created_at":   gtime.Now(),
		"updated_at":   gtime.Now(),
	}).Insert()

	if err != nil {
		response.Error(r, response.CodeInternalError, "添加配置失败")
		return
	}

	response.Success(r, "添加成功")
}

// Update 更新配置
func (s *ConfigService) Update(r *ghttp.Request) {
	// 获取请求参数
	idStr := r.Get("id").String()
	configName := r.Get("config_name").String()
	configValue := r.Get("config_value").String()
	configType := r.Get("config_type").String()
	description := r.Get("description").String()

	if idStr == "" {
		response.Error(r, response.CodeInvalidParam, "配置ID不能为空")
		return
	}

	id, err := strconv.Atoi(idStr)
	if err != nil {
		response.Error(r, response.CodeInvalidParam, "配置ID格式错误")
		return
	}

	// 检查配置是否存在
	count, err := dao.Config.Ctx(r.Context()).Where("id", id).Count()
	if err != nil {
		response.Error(r, response.CodeInternalError, "检查配置失败")
		return
	}
	if count == 0 {
		response.Error(r, response.CodeNotFound, "配置不存在")
		return
	}

	// 更新配置
	updateData := g.Map{
		"updated_at": gtime.Now(),
	}
	if configName != "" {
		updateData["config_name"] = configName
	}
	if configValue != "" {
		updateData["config_value"] = configValue
	}
	if configType != "" {
		updateData["config_type"] = configType
	}
	if description != "" {
		updateData["description"] = description
	}

	_, err = dao.Config.Ctx(r.Context()).Where("id", id).Data(updateData).Update()
	if err != nil {
		response.Error(r, response.CodeInternalError, "更新配置失败")
		return
	}

	response.Success(r, "更新成功")
}

// Delete 删除配置
func (s *ConfigService) Delete(r *ghttp.Request) {
	// 获取请求参数
	idStr := r.Get("id").String()
	if idStr == "" {
		response.Error(r, response.CodeInvalidParam, "配置ID不能为空")
		return
	}

	id, err := strconv.Atoi(idStr)
	if err != nil {
		response.Error(r, response.CodeInvalidParam, "配置ID格式错误")
		return
	}

	// 检查配置是否存在
	count, err := dao.Config.Ctx(r.Context()).Where("id", id).Count()
	if err != nil {
		response.Error(r, response.CodeInternalError, "检查配置失败")
		return
	}
	if count == 0 {
		response.Error(r, response.CodeNotFound, "配置不存在")
		return
	}

	// 删除配置
	_, err = dao.Config.Ctx(r.Context()).Where("id", id).Delete()
	if err != nil {
		response.Error(r, response.CodeInternalError, "删除配置失败")
		return
	}

	response.Success(r, "删除成功")
}

// BatchDelete 批量删除配置
func (s *ConfigService) BatchDelete(r *ghttp.Request) {
	// 获取请求参数
	var ids []int
	err := r.Parse(&ids)
	if err != nil {
		response.Error(r, response.CodeInvalidParam, "参数格式错误")
		return
	}

	if len(ids) == 0 {
		response.Error(r, response.CodeInvalidParam, "请选择要删除的配置")
		return
	}

	// 批量删除
	_, err = dao.Config.Ctx(r.Context()).Where("id IN (?)", ids).Delete()
	if err != nil {
		response.Error(r, response.CodeInternalError, "批量删除失败")
		return
	}

	response.Success(r, "删除成功")
}

// GetPublicConfigs 获取公开配置（用户端）
func (s *ConfigService) GetPublicConfigs(r *ghttp.Request) {
	// 返回默认的公开配置
	configMap := map[string]interface{}{
		"site_name":        "NL在线影院",
		"site_logo":        "",
		"site_description": "NL在线影院 - 海量高清影视资源在线观看",
		"site_keywords":    "NL影院,在线观看,高清影视",
		"upload_max_size":  "10485760",
		"upload_allowed_types": "jpg,jpeg,png,gif,mp4,avi,mkv",
	}

	response.Success(r, configMap)
}