package models

import (
	"fmt"
	"ginCms/utils"
	"gorm.io/gorm"
	"strings"
)

// Role 角色模型
type Role struct {
	Model
	Title   string `gorm:"type:varchar(255);uniqueIndex" json:"title"`
	Key     string `gorm:"type:varchar(255);uniqueIndex" json:"key"`
	Enabled bool   `gorm:"" json:"enabled"`
	Weight  int    `gorm:"index;" json:"weight"`
	Comment string `gorm:"type:text" json:"comment"`
}

// RoleRestore 还原
func RoleRestore(idList []uint) (int64, error) {
	// 还原的记录数
	rowsNum := int64(0)
	err := utils.DB().Transaction(func(tx *gorm.DB) error {
		result := tx.Model(&Role{}).Unscoped().Where("`id` IN ?", idList).Update("deleted_at", nil)
		if result.Error != nil {
			return result.Error
		} else {
			// 更新成功
			rowsNum = result.RowsAffected
		}
		return nil
	})

	return rowsNum, err
}

// RoleDelete 角色删除
// @param force bool 是否强制删除
// @return 删除的记录数，error
func RoleDelete(idList []uint, force bool) (int64, error) {
	// 将delete操作在事务里完成，删除时，有时会涉及到关联数据的处理
	rowsNum := int64(0)
	err := utils.DB().Transaction(func(tx *gorm.DB) error {
		query := tx.Model(&Role{})
		// 强制
		if force {
			query.Unscoped()
		}
		result := query.Delete(&Role{}, idList)
		if result.Error != nil {
			return result.Error
		} else {
			// 删除成功
			rowsNum = result.RowsAffected
		}
		return nil
	})

	return rowsNum, err
}

//func RoleDelete(idList []uint) error {
//	// 将delete操作在事务里完成，删除时，有时会涉及到关联数据的处理
//	return utils.DB().Transaction(func(tx *gorm.DB) error {
//		if err := tx.Delete(&Role{}, idList).Error; err != nil {
//			return err
//		}
//		return nil
//	})
//}

// 角色插入
func RoleInsert(row *Role) error {
	// 将insert操作在事务里完成，插入时，有时会涉及到关联数据的处理。
	// 数据及关联数据的插入，放在一个事务中
	return utils.DB().Transaction(func(tx *gorm.DB) error {
		// 完成插入
		if err := tx.Create(&row).Error; err != nil {
			return err
		}
		return nil
	})
}

// 通用的查询列表过滤类型
type RoleFilter struct {
	// 指针类型表示该字段可以不填
	// omitempty, 非零值才校验
	// gt, 字符串长度>0
	Keyword *string `form:"keyword" binding:"omitempty,gt=0"`
}

// Clean 整理Filter
func (f *RoleFilter) Clean() {
	if f.Keyword == nil {
		temp := ""
		f.Keyword = &temp
	}
}

// RoleFetchList 查询列表
// @param filter RoleFilter 过滤参数
// @param sorter Sorter 排序参数
// @param pager Pager 翻页参数
// @param scope uint8 范围参数
// @param assoc bool 是否查询关联
// @return []*Role Role列表
// @return error
func RoleFetchList(filter RoleFilter, sorter Sorter, pager Pager, scope uint8, assoc bool) ([]*Role, error) {
	// 初始化query
	query := utils.DB().Model(&Role{})

	// 1. 过滤
	// 查询范围
	switch scope {
	case SCOPE_ALL:
		query.Unscoped()
	case SCOPE_DELETED:
		query.Unscoped().Where("`deleted_at` IS NOT NULL")
	case SCOPE_UNDELETED:
		fallthrough
	default:
		// do nothing. default case
	}
	// 条件过滤
	if *filter.Keyword != "" {
		query.Where("`title` LIKE ?", "%"+*filter.Keyword+"%")
	}
	// 其他字段过滤

	// 2. 排序
	query.Order(fmt.Sprintf("`%s` %s", *sorter.SortField, strings.ToUpper(*sorter.SortMethod)))

	// 3. 翻页 offset limit
	// 在pagesize>0时，才进行翻页
	if *pager.PageSize > 0 {
		// 偏移 ==（当前页码 - 1） 乘以 每页记录数
		offset := (*pager.PageNum - 1) * *pager.PageSize
		query.Offset(offset).Limit(*pager.PageSize)
	}

	// 4. 查询
	var rows []*Role
	if err := query.Find(&rows).Error; err != nil {
		return nil, err
	}

	// 5. 关联查询
	if assoc {
	}

	// 返回
	return rows, nil
}

func RoleFetch(id uint, assoc bool) (*Role, error) {
	return RoleFetchRow(assoc, "`id` = ?", id)
}

// RoleFetchRow 根据条件查询单条
// assoc 是否查询管理数据
// where, args 查询条件
func RoleFetchRow(assoc bool, where any, args ...any) (*Role, error) {
	// 查询本条
	row := &Role{}
	if err := utils.DB().Where(where, args...).First(&row).Error; err != nil {
		return nil, err
	}

	// 关联查询
	if assoc {
	}

	return row, nil
}

// 填充数据
func roleSeed() {
	// 构建数据
	rows := []Role{
		{
			Title:   "管理员",
			Key:     "administrator",
			Enabled: true,
			Model:   Model{ID: 1},
		},
		{
			Title:   "常规用户",
			Key:     "regular",
			Enabled: true,
			Model:   Model{ID: 2},
		},
	}

	// 插入
	for _, row := range rows {
		if err := utils.DB().FirstOrCreate(&row, row.ID).Error; err != nil {
			utils.Logger().With(err.Error())
		}
	}
}