package system

import (
	"context"
	"time"

	"kra/internal/biz/system"
	"kra/internal/data/model"
	"kra/internal/data/query"

	"gorm.io/gorm"
)

// ParamsRepo 系统参数仓储实现
type ParamsRepo struct {
	data *gorm.DB
}

// NewParamsRepo 创建系统参数仓储
func NewParamsRepo(data *gorm.DB) system.ParamsRepo {
	return &ParamsRepo{data: data}
}

// Create 创建参数
func (r *ParamsRepo) Create(ctx context.Context, params *system.Params) error {
	m := toParamsModel(params)
	return query.Use(r.data).SysParam.WithContext(ctx).Create(m)
}

// Delete 删除参数
func (r *ParamsRepo) Delete(ctx context.Context, id uint) error {
	q := query.Use(r.data).SysParam
	_, err := q.WithContext(ctx).Where(q.ID.Eq(int64(id))).Delete()
	return err
}

// DeleteByIds 批量删除参数
func (r *ParamsRepo) DeleteByIds(ctx context.Context, ids []uint) error {
	q := query.Use(r.data).SysParam
	int64Ids := make([]int64, len(ids))
	for i, id := range ids {
		int64Ids[i] = int64(id)
	}
	_, err := q.WithContext(ctx).Where(q.ID.In(int64Ids...)).Delete()
	return err
}

// Update 更新参数
func (r *ParamsRepo) Update(ctx context.Context, params *system.Params) error {
	q := query.Use(r.data).SysParam
	_, err := q.WithContext(ctx).Where(q.ID.Eq(int64(params.ID))).Updates(toParamsModel(params))
	return err
}

// FindByID 根据ID查找参数
func (r *ParamsRepo) FindByID(ctx context.Context, id uint) (*system.Params, error) {
	q := query.Use(r.data).SysParam
	m, err := q.WithContext(ctx).Where(q.ID.Eq(int64(id))).First()
	if err != nil {
		return nil, err
	}
	return toParamsBiz(m), nil
}

// FindByKey 根据Key查找参数
func (r *ParamsRepo) FindByKey(ctx context.Context, key string) (*system.Params, error) {
	q := query.Use(r.data).SysParam
	m, err := q.WithContext(ctx).Where(q.Key.Eq(key)).First()
	if err != nil {
		return nil, err
	}
	return toParamsBiz(m), nil
}

// FindList 查找参数列表
func (r *ParamsRepo) FindList(ctx context.Context, page, pageSize int, filters map[string]interface{}) ([]*system.Params, int64, error) {
	q := query.Use(r.data).SysParam
	do := q.WithContext(ctx)

	// 应用过滤条件
	if name, ok := filters["name"].(string); ok && name != "" {
		do = do.Where(q.Name.Like("%" + name + "%"))
	}
	if key, ok := filters["key"].(string); ok && key != "" {
		do = do.Where(q.Key.Like("%" + key + "%"))
	}
	if startTime, ok := filters["start_time"].(*time.Time); ok && startTime != nil {
		do = do.Where(q.CreatedAt.Gte(*startTime))
	}
	if endTime, ok := filters["end_time"].(*time.Time); ok && endTime != nil {
		do = do.Where(q.CreatedAt.Lte(*endTime))
	}

	// 获取总数
	total, err := do.Count()
	if err != nil {
		return nil, 0, err
	}

	// 分页查询
	if pageSize > 0 {
		do = do.Limit(pageSize).Offset((page - 1) * pageSize)
	}

	list, err := do.Find()
	if err != nil {
		return nil, 0, err
	}

	result := make([]*system.Params, len(list))
	for i, m := range list {
		result[i] = toParamsBiz(m)
	}
	return result, total, nil
}

// toParamsModel 转换为数据模型
func toParamsModel(p *system.Params) *model.SysParam {
	return &model.SysParam{
		ID:    int64(p.ID),
		Name:  p.Name,
		Key:   p.Key,
		Value: p.Value,
		Desc:  p.Desc,
	}
}

// toParamsBiz 转换为业务实体
func toParamsBiz(m *model.SysParam) *system.Params {
	return &system.Params{
		ID:        uint(m.ID),
		CreatedAt: m.CreatedAt,
		UpdatedAt: m.UpdatedAt,
		Name:      m.Name,
		Key:       m.Key,
		Value:     m.Value,
		Desc:      m.Desc,
	}
}