package services

import (
	"fmt"
	"regexp"
	"server/models"
	"time"

	"github.com/beego/beego/v2/client/orm"
)

// ========== 字典类型相关服务 ==========

// AddDictType 添加字典类型
func AddDictType(dictType *models.DictType) (int64, error) {
	// 校验字典编码格式（只能包含字母、数字、下划线）
	matched, err := regexp.MatchString(`^[A-Za-z0-9_]+$`, dictType.DictCode)
	if err != nil || !matched {
		return 0, fmt.Errorf("字典编码格式错误，只能包含字母、数字、下划线")
	}

	o := orm.NewOrm()
	
	// 检查字典编码是否已存在（同一租户下唯一）
	existType := &models.DictType{}
	err = o.Raw("SELECT id FROM sys_dict_type WHERE dict_code = ? AND tenant_id = ? AND is_deleted = 0", 
		dictType.DictCode, dictType.TenantId).QueryRow(existType)
	if err == nil {
		return 0, fmt.Errorf("字典编码 %s 已存在", dictType.DictCode)
	}

	// 插入新字典类型
	id, err := o.Insert(dictType)
	if err != nil {
		return 0, fmt.Errorf("添加字典类型失败: %v", err)
	}

	// 清除相关缓存
	clearDictCache(dictType.TenantId, dictType.DictCode)

	return id, nil
}

// UpdateDictType 更新字典类型
func UpdateDictType(dictType *models.DictType) error {
	o := orm.NewOrm()
	
	// 获取原字典类型信息
	oldType := &models.DictType{Id: dictType.Id}
	err := o.Read(oldType)
	if err != nil {
		return fmt.Errorf("字典类型不存在: %v", err)
	}

	// 不允许修改 dict_code（避免业务引用失效）
	if oldType.DictCode != dictType.DictCode {
		return fmt.Errorf("不允许修改字典编码")
	}

	// 更新字段（排除 dict_code）
	_, err = o.Update(dictType, "dict_name", "parent_id", "status", "sort", "remark", "update_by", "update_time")
	if err != nil {
		return fmt.Errorf("更新字典类型失败: %v", err)
	}

	// 清除相关缓存
	clearDictCache(dictType.TenantId, dictType.DictCode)

	return nil
}

// DeleteDictType 删除字典类型（逻辑删除）
func DeleteDictType(id int, tenantId int) error {
	o := orm.NewOrm()
	
	// 检查是否存在
	dictType := &models.DictType{Id: id}
	err := o.Read(dictType)
	if err != nil {
		return fmt.Errorf("字典类型不存在: %v", err)
	}

	// 检查租户权限
	if dictType.TenantId != tenantId {
		return fmt.Errorf("无权操作该字典类型")
	}

	// 检查是否关联字典项
	var count int
	err = o.Raw("SELECT COUNT(*) FROM sys_dict_item WHERE dict_type_id = ? AND is_deleted = 0", id).QueryRow(&count)
	if err == nil && count > 0 {
		return fmt.Errorf("该字典类型下存在字典项，请先删除字典项")
	}

	// 逻辑删除
	dictType.IsDeleted = 1
	dictType.UpdateTime = time.Now()
	_, err = o.Update(dictType, "is_deleted", "update_time")
	if err != nil {
		return fmt.Errorf("删除字典类型失败: %v", err)
	}

	// 清除相关缓存
	clearDictCache(dictType.TenantId, dictType.DictCode)

	return nil
}

// GetDictTypeById 根据ID获取字典类型
func GetDictTypeById(id int) (*models.DictType, error) {
	o := orm.NewOrm()
	dictType := &models.DictType{Id: id}
	err := o.Read(dictType)
	if err != nil {
		return nil, err
	}
	if dictType.IsDeleted == 1 {
		return nil, fmt.Errorf("字典类型已删除")
	}
	return dictType, nil
}

// GetDictTypes 获取字典类型列表
func GetDictTypes(tenantId int, parentId int, status *int8) ([]*models.DictType, error) {
	o := orm.NewOrm()
	qs := o.QueryTable("sys_dict_type").Filter("is_deleted", 0)

	// 租户过滤：0表示平台字典，>0表示租户字典
	if tenantId > 0 {
		// 租户用户只能看到自己的字典和平台字典
		qs = qs.Filter("tenant_id__in", 0, tenantId)
	} else {
		// 平台用户只能看到平台字典
		qs = qs.Filter("tenant_id", 0)
	}

	// 父级过滤
	if parentId >= 0 {
		qs = qs.Filter("parent_id", parentId)
	}

	// 状态过滤
	if status != nil {
		qs = qs.Filter("status", *status)
	}

	var dictTypes []*models.DictType
	_, err := qs.OrderBy("sort", "create_time").All(&dictTypes)
	return dictTypes, err
}

// ========== 字典项相关服务 ==========

// AddDictItem 添加字典项
func AddDictItem(dictItem *models.DictItem) (int64, error) {
	o := orm.NewOrm()
	
	// 检查字典类型是否存在
	dictType := &models.DictType{Id: dictItem.DictTypeId}
	err := o.Read(dictType)
	if err != nil {
		return 0, fmt.Errorf("字典类型不存在: %v", err)
	}
	if dictType.IsDeleted == 1 || dictType.Status == 0 {
		return 0, fmt.Errorf("字典类型已删除或已禁用")
	}

	// 检查同一字典类型下 dict_value 是否已存在
	existItem := &models.DictItem{}
	err = o.Raw("SELECT id FROM sys_dict_item WHERE dict_type_id = ? AND dict_value = ? AND is_deleted = 0", 
		dictItem.DictTypeId, dictItem.DictValue).QueryRow(existItem)
	if err == nil {
		return 0, fmt.Errorf("字典值 %s 已存在", dictItem.DictValue)
	}

	// 插入新字典项
	id, err := o.Insert(dictItem)
	if err != nil {
		return 0, fmt.Errorf("添加字典项失败: %v", err)
	}

	// 清除相关缓存
	clearDictCacheByTypeId(dictItem.DictTypeId)

	return id, nil
}

// UpdateDictItem 更新字典项
func UpdateDictItem(dictItem *models.DictItem) error {
	o := orm.NewOrm()
	
	// 获取原字典项信息
	oldItem := &models.DictItem{Id: dictItem.Id}
	err := o.Read(oldItem)
	if err != nil {
		return fmt.Errorf("字典项不存在: %v", err)
	}

	// 不允许修改 dict_value（避免业务存储值与字典不匹配）
	if oldItem.DictValue != dictItem.DictValue {
		return fmt.Errorf("不允许修改字典值")
	}

	// 如果修改了 dict_type_id，需要检查新类型是否存在
	if oldItem.DictTypeId != dictItem.DictTypeId {
		dictType := &models.DictType{Id: dictItem.DictTypeId}
		err = o.Read(dictType)
		if err != nil {
			return fmt.Errorf("字典类型不存在: %v", err)
		}
	}

	// 更新字段（排除 dict_value）
	_, err = o.Update(dictItem, "dict_label", "dict_type_id", "parent_id", "status", "sort", "color", "icon", "remark", "update_by", "update_time")
	if err != nil {
		return fmt.Errorf("更新字典项失败: %v", err)
	}

	// 清除相关缓存
	clearDictCacheByTypeId(oldItem.DictTypeId)
	if oldItem.DictTypeId != dictItem.DictTypeId {
		clearDictCacheByTypeId(dictItem.DictTypeId)
	}

	return nil
}

// DeleteDictItem 删除字典项（逻辑删除）
func DeleteDictItem(id int) error {
	o := orm.NewOrm()
	
	// 检查是否存在
	dictItem := &models.DictItem{Id: id}
	err := o.Read(dictItem)
	if err != nil {
		return fmt.Errorf("字典项不存在: %v", err)
	}

	// 检查是否有子项
	var count int
	err = o.Raw("SELECT COUNT(*) FROM sys_dict_item WHERE parent_id = ? AND is_deleted = 0", id).QueryRow(&count)
	if err == nil && count > 0 {
		return fmt.Errorf("该字典项下存在子项，请先删除子项")
	}

	// 逻辑删除
	dictItem.IsDeleted = 1
	dictItem.UpdateTime = time.Now()
	_, err = o.Update(dictItem, "is_deleted", "update_time")
	if err != nil {
		return fmt.Errorf("删除字典项失败: %v", err)
	}

	// 清除相关缓存
	clearDictCacheByTypeId(dictItem.DictTypeId)

	return nil
}

// GetDictItemById 根据ID获取字典项
func GetDictItemById(id int) (*models.DictItem, error) {
	o := orm.NewOrm()
	dictItem := &models.DictItem{Id: id}
	err := o.Read(dictItem)
	if err != nil {
		return nil, err
	}
	if dictItem.IsDeleted == 1 {
		return nil, fmt.Errorf("字典项已删除")
	}
	return dictItem, nil
}

// GetDictItems 获取字典项列表
func GetDictItems(dictTypeId int, parentId *int, status *int8) ([]*models.DictItem, error) {
	o := orm.NewOrm()
	qs := o.QueryTable("sys_dict_item").Filter("is_deleted", 0).Filter("dict_type_id", dictTypeId)

	// 父级过滤
	if parentId != nil {
		qs = qs.Filter("parent_id", *parentId)
	}

	// 状态过滤
	if status != nil {
		qs = qs.Filter("status", *status)
	}

	var dictItems []*models.DictItem
	_, err := qs.OrderBy("sort", "create_time").All(&dictItems)
	return dictItems, err
}

// GetDictItemsByCode 根据字典编码获取字典项列表（支持缓存）
func GetDictItemsByCode(dictCode string, tenantId int, includeDisabled bool) ([]*models.DictItem, error) {
	o := orm.NewOrm()
	
	// 先查询字典类型
	dictType := &models.DictType{}
	err := o.Raw("SELECT * FROM sys_dict_type WHERE dict_code = ? AND tenant_id = ? AND is_deleted = 0 AND status = 1", 
		dictCode, tenantId).QueryRow(dictType)
	if err != nil {
		// 如果租户字典不存在，尝试查询平台字典
		if tenantId > 0 {
			err = o.Raw("SELECT * FROM sys_dict_type WHERE dict_code = ? AND tenant_id = 0 AND is_deleted = 0 AND status = 1", 
				dictCode).QueryRow(dictType)
			if err != nil {
				return []*models.DictItem{}, nil // 返回空列表而不是错误
			}
		} else {
			return []*models.DictItem{}, nil
		}
	}

	// 查询字典项
	qs := o.QueryTable("sys_dict_item").Filter("dict_type_id", dictType.Id).Filter("is_deleted", 0)
	if !includeDisabled {
		qs = qs.Filter("status", 1)
	}

	var dictItems []*models.DictItem
	_, err = qs.OrderBy("sort", "create_time").All(&dictItems)
	if err != nil {
		return nil, err
	}

	return dictItems, nil
}

// ========== 缓存相关（简化版，实际应使用Redis） ==========

// 清除字典缓存（简化实现，实际应使用Redis）
func clearDictCache(tenantId int, dictCode string) {
	// TODO: 实现Redis缓存清除
	// 格式：SYS_DICT:ITEM:{tenantId}:{dictCode}
}

// 根据字典类型ID清除缓存
func clearDictCacheByTypeId(dictTypeId int) {
	o := orm.NewOrm()
	dictType := &models.DictType{Id: dictTypeId}
	err := o.Read(dictType)
	if err == nil {
		clearDictCache(dictType.TenantId, dictType.DictCode)
	}
}

// ========== 批量操作 ==========

// BatchUpdateDictItemSort 批量更新字典项排序
func BatchUpdateDictItemSort(items []struct {
	Id   int `json:"id"`
	Sort int `json:"sort"`
}) error {
	o := orm.NewOrm()
	
	for _, item := range items {
		dictItem := &models.DictItem{Id: item.Id}
		err := o.Read(dictItem)
		if err != nil {
			continue
		}
		dictItem.Sort = item.Sort
		dictItem.UpdateTime = time.Now()
		_, err = o.Update(dictItem, "sort", "update_time")
		if err != nil {
			return fmt.Errorf("更新字典项排序失败: %v", err)
		}
	}

	return nil
}