package system

import (
	"context"

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

	"gorm.io/gorm"
)

type exportTemplateRepo struct {
	db *gorm.DB
}

// NewExportTemplateRepo 创建导出模板仓储
func NewExportTemplateRepo(db *gorm.DB) system.ExportTemplateRepo {
	return &exportTemplateRepo{db: db}
}

func (r *exportTemplateRepo) Create(ctx context.Context, template *system.ExportTemplate) error {
	m := toModelExportTemplate(template)
	if err := r.db.WithContext(ctx).Create(m).Error; err != nil {
		return err
	}
	template.ID = uint(m.ID)

	// 创建条件
	if len(template.Conditions) > 0 {
		for _, c := range template.Conditions {
			c.TemplateID = template.TemplateID
		}
		if err := r.CreateConditions(ctx, template.Conditions); err != nil {
			return err
		}
	}

	// 创建关联
	if len(template.JoinTemplate) > 0 {
		for _, j := range template.JoinTemplate {
			j.TemplateID = template.TemplateID
		}
		if err := r.CreateJoins(ctx, template.JoinTemplate); err != nil {
			return err
		}
	}

	return nil
}

func (r *exportTemplateRepo) Update(ctx context.Context, template *system.ExportTemplate) error {
	m := toModelExportTemplate(template)
	return r.db.WithContext(ctx).Model(&model.SysExportTemplate{}).Where("id = ?", template.ID).Updates(m).Error
}

func (r *exportTemplateRepo) Delete(ctx context.Context, id uint) error {
	return r.db.WithContext(ctx).Delete(&model.SysExportTemplate{}, id).Error
}

func (r *exportTemplateRepo) FindByID(ctx context.Context, id uint) (*system.ExportTemplate, error) {
	var m model.SysExportTemplate
	if err := r.db.WithContext(ctx).First(&m, id).Error; err != nil {
		return nil, err
	}

	// 加载条件
	var conditions []model.SysExportTemplateCondition
	r.db.WithContext(ctx).Where("template_id = ?", m.TemplateID).Find(&conditions)

	// 加载关联
	var joins []model.SysExportTemplateJoin
	r.db.WithContext(ctx).Where("template_id = ?", m.TemplateID).Find(&joins)

	return toBizExportTemplate(&m, conditions, joins), nil
}

func (r *exportTemplateRepo) FindByTemplateID(ctx context.Context, templateID string) (*system.ExportTemplate, error) {
	var m model.SysExportTemplate
	if err := r.db.WithContext(ctx).Where("template_id = ?", templateID).First(&m).Error; err != nil {
		return nil, err
	}

	// 加载条件
	var conditions []model.SysExportTemplateCondition
	r.db.WithContext(ctx).Where("template_id = ?", templateID).Find(&conditions)

	// 加载关联
	var joins []model.SysExportTemplateJoin
	r.db.WithContext(ctx).Where("template_id = ?", templateID).Find(&joins)

	return toBizExportTemplate(&m, conditions, joins), nil
}

func (r *exportTemplateRepo) GetList(ctx context.Context, req *system.ExportTemplateSearchReq) ([]*system.ExportTemplate, int64, error) {
	q := query.SysExportTemplate
	do := q.WithContext(ctx)

	if req.Name != "" {
		do = do.Where(q.Name.Like("%" + req.Name + "%"))
	}
	if req.TableName != "" {
		do = do.Where(q.TblName.Eq(req.TableName))
	}
	if req.TemplateID != "" {
		do = do.Where(q.TemplateID.Eq(req.TemplateID))
	}
	if req.StartCreatedAt != nil && req.EndCreatedAt != nil {
		do = do.Where(q.CreatedAt.Between(*req.StartCreatedAt, *req.EndCreatedAt))
	}

	total, err := do.Count()
	if err != nil {
		return nil, 0, err
	}

	if req.PageSize > 0 {
		do = do.Limit(req.PageSize).Offset((req.Page - 1) * req.PageSize)
	}

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

	result := make([]*system.ExportTemplate, len(list))
	for i, m := range list {
		result[i] = toBizExportTemplateSimple(m)
	}

	return result, total, nil
}

func (r *exportTemplateRepo) DeleteConditionsByTemplateID(ctx context.Context, templateID string) error {
	return r.db.WithContext(ctx).Where("template_id = ?", templateID).Delete(&model.SysExportTemplateCondition{}).Error
}

func (r *exportTemplateRepo) DeleteJoinsByTemplateID(ctx context.Context, templateID string) error {
	return r.db.WithContext(ctx).Where("template_id = ?", templateID).Delete(&model.SysExportTemplateJoin{}).Error
}

func (r *exportTemplateRepo) CreateConditions(ctx context.Context, conditions []*system.Condition) error {
	if len(conditions) == 0 {
		return nil
	}
	models := make([]*model.SysExportTemplateCondition, len(conditions))
	for i, c := range conditions {
		models[i] = &model.SysExportTemplateCondition{
			TemplateID: c.TemplateID,
			From:       c.From,
			Column:     c.Column,
			Operator:   c.Operator,
		}
	}
	return r.db.WithContext(ctx).Create(&models).Error
}

func (r *exportTemplateRepo) CreateJoins(ctx context.Context, joins []*system.JoinTemplate) error {
	if len(joins) == 0 {
		return nil
	}
	models := make([]*model.SysExportTemplateJoin, len(joins))
	for i, j := range joins {
		models[i] = &model.SysExportTemplateJoin{
			TemplateID: j.TemplateID,
			Joins:      j.Joins,
			TblName:    j.Table,
			On:         j.On,
		}
	}
	return r.db.WithContext(ctx).Create(&models).Error
}

func (r *exportTemplateRepo) GetDB(dbName string) interface{} {
	// 简化实现：返回默认数据库
	return r.db
}

func (r *exportTemplateRepo) ExecuteQuery(ctx context.Context, dbName, sql string, args ...interface{}) ([]map[string]interface{}, error) {
	var result []map[string]interface{}
	if err := r.db.WithContext(ctx).Raw(sql, args...).Scan(&result).Error; err != nil {
		return nil, err
	}
	return result, nil
}

func (r *exportTemplateRepo) GetColumnTypes(ctx context.Context, dbName, tableName string) ([]string, error) {
	columns, err := r.db.Migrator().ColumnTypes(tableName)
	if err != nil {
		return nil, err
	}
	result := make([]string, len(columns))
	for i, col := range columns {
		result[i] = col.Name()
	}
	return result, nil
}

func (r *exportTemplateRepo) HasDeletedAtColumn(ctx context.Context, tableName string) bool {
	var count int64
	r.db.Raw("SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ? AND COLUMN_NAME = 'deleted_at'", tableName).Count(&count)
	return count > 0
}

func (r *exportTemplateRepo) ImportData(ctx context.Context, dbName, tableName string, items []map[string]interface{}) error {
	return r.db.WithContext(ctx).Table(tableName).CreateInBatches(&items, 1000).Error
}

// 转换函数
func toModelExportTemplate(t *system.ExportTemplate) *model.SysExportTemplate {
	var limit int64
	if t.Limit != nil {
		limit = int64(*t.Limit)
	}
	return &model.SysExportTemplate{
		ID:           int64(t.ID),
		DbName:       t.DBName,
		Name:         t.Name,
		TblName:      t.TableName,
		TemplateID:   t.TemplateID,
		TemplateInfo: t.TemplateInfo,
		Limit:        limit,
		Order:        t.Order,
	}
}

func toBizExportTemplate(m *model.SysExportTemplate, conditions []model.SysExportTemplateCondition, joins []model.SysExportTemplateJoin) *system.ExportTemplate {
	limit := int(m.Limit)
	t := &system.ExportTemplate{
		ID:           uint(m.ID),
		DBName:       m.DbName,
		Name:         m.Name,
		TableName:    m.TblName,
		TemplateID:   m.TemplateID,
		TemplateInfo: m.TemplateInfo,
		Limit:        &limit,
		Order:        m.Order,
		CreatedAt:    m.CreatedAt,
		UpdatedAt:    m.UpdatedAt,
	}

	// 转换条件
	t.Conditions = make([]*system.Condition, len(conditions))
	for i, c := range conditions {
		t.Conditions[i] = &system.Condition{
			ID:         uint(c.ID),
			TemplateID: c.TemplateID,
			From:       c.From,
			Column:     c.Column,
			Operator:   c.Operator,
		}
	}

	// 转换关联
	t.JoinTemplate = make([]*system.JoinTemplate, len(joins))
	for i, j := range joins {
		t.JoinTemplate[i] = &system.JoinTemplate{
			ID:         uint(j.ID),
			TemplateID: j.TemplateID,
			Joins:      j.Joins,
			Table:      j.TblName,
			On:         j.On,
		}
	}

	return t
}

func toBizExportTemplateSimple(m *model.SysExportTemplate) *system.ExportTemplate {
	limit := int(m.Limit)
	return &system.ExportTemplate{
		ID:           uint(m.ID),
		DBName:       m.DbName,
		Name:         m.Name,
		TableName:    m.TblName,
		TemplateID:   m.TemplateID,
		TemplateInfo: m.TemplateInfo,
		Limit:        &limit,
		Order:        m.Order,
		CreatedAt:    m.CreatedAt,
		UpdatedAt:    m.UpdatedAt,
	}
}
