package aliasmanagement

import (
	"context"
	"fmt"
	"regexp"

	"git.x2erp.com/qdy/go-base/ctx"
	"git.x2erp.com/qdy/go-base/logger"
	"git.x2erp.com/qdy/go-base/model/response"
	"git.x2erp.com/qdy/go-base/util"
	"git.x2erp.com/qdy/go-db/factory/database"
	"git.x2erp.com/qdy/go-svc-configure/internal/tables"
	"github.com/google/uuid"
	"github.com/jmoiron/sqlx"
)

// SaveTableAlias 保存表别名字典（创建或更新）
func SaveTableAlias(req *TableAliasRequest, ctx context.Context, dbFactory *database.DBFactory, reqCtx *ctx.RequestContext) *response.QueryResult[TableAliasDetail] {
	logger.Debug("SaveTableAlias-开始保存表别名字典")

	// 参数验证
	if err := validateTableAliasRequest(req); err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("参数验证失败: %v", err))
		return util.CreateErrorResult[TableAliasDetail](fmt.Sprintf("参数验证失败: %v", err), reqCtx)
	}

	// 获取数据库连接并开始事务
	db := dbFactory.GetDB()
	tx, err := db.BeginTxx(ctx, nil)
	if err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("开始事务失败: %v", err))
		return util.CreateErrorResult[TableAliasDetail](fmt.Sprintf("开始事务失败: %v", err), reqCtx)
	}

	defer func() {
		if p := recover(); p != nil {
			tx.Rollback()
			panic(p)
		}
	}()

	// 获取当前用户
	creator := reqCtx.UserID
	if creator == "" {
		creator = "system"
	}

	// 检查表别名是否已存在（基于table_alias字段的唯一索引）
	aliasExists, err := checkTableAliasExists(ctx, tx, req.TableAlias)
	if err != nil {
		tx.Rollback()
		logger.ErrorC(reqCtx, fmt.Sprintf("检查表别名存在性失败: %v", err))
		return util.CreateErrorResult[TableAliasDetail](fmt.Sprintf("检查表别名存在性失败: %v", err), reqCtx)
	}

	var tableAlias tables.DicTableAliasDB
	if aliasExists {
		// 更新表别名（根据ID或table_alias）
		tableAlias, err = updateTableAlias(ctx, tx, req)
		if err != nil {
			tx.Rollback()
			logger.ErrorC(reqCtx, fmt.Sprintf("更新表别名失败: %v", err))
			return util.CreateErrorResult[TableAliasDetail](fmt.Sprintf("更新表别名失败: %v", err), reqCtx)
		}
		logger.Debug(fmt.Sprintf("更新表别名成功: %s", req.TableAlias))
	} else {
		// 检查是否有软删除的记录
		softDeletedExists, err := checkSoftDeletedTableAliasExists(ctx, tx, req.TableAlias)
		if err != nil {
			tx.Rollback()
			logger.ErrorC(reqCtx, fmt.Sprintf("检查软删除表别名存在性失败: %v", err))
			return util.CreateErrorResult[TableAliasDetail](fmt.Sprintf("检查软删除表别名存在性失败: %v", err), reqCtx)
		}

		if softDeletedExists {
			// 恢复软删除的表别名
			tableAlias, err = restoreTableAlias(ctx, tx, req)
			if err != nil {
				tx.Rollback()
				logger.ErrorC(reqCtx, fmt.Sprintf("恢复软删除表别名失败: %v", err))
				return util.CreateErrorResult[TableAliasDetail](fmt.Sprintf("恢复软删除表别名失败: %v", err), reqCtx)
			}
			logger.Debug(fmt.Sprintf("恢复软删除表别名成功: %s", req.TableAlias))
		} else {
			// 插入新的表别名
			tableAlias, err = insertTableAlias(ctx, tx, req, creator)
			if err != nil {
				tx.Rollback()
				logger.ErrorC(reqCtx, fmt.Sprintf("插入表别名失败: %v", err))
				return util.CreateErrorResult[TableAliasDetail](fmt.Sprintf("插入表别名失败: %v", err), reqCtx)
			}
			logger.Debug(fmt.Sprintf("插入表别名成功: %s", req.TableAlias))
		}
	}

	// 提交事务
	if err := tx.Commit(); err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("提交事务失败: %v", err))
		return util.CreateErrorResult[TableAliasDetail](fmt.Sprintf("提交事务失败: %v", err), reqCtx)
	}

	logger.Debug(fmt.Sprintf("成功保存表别名字典: %s", req.TableAlias))

	// 构建返回结果
	detail := TableAliasDetail{
		TableAlias: tableAlias,
	}

	return util.CreateSuccessResultData[TableAliasDetail](detail, reqCtx)
}

// validateTableAliasRequest 验证表别名字典请求
func validateTableAliasRequest(req *TableAliasRequest) error {
	if req.TableID == "" {
		return fmt.Errorf("表ID不能为空")
	}

	// 验证表ID格式：仅允许字母、数字、下划线
	match, _ := regexp.MatchString("^[a-zA-Z0-9_]+$", req.TableID)
	if !match {
		return fmt.Errorf("表ID只能包含字母、数字、下划线")
	}

	if req.TableAlias == "" {
		return fmt.Errorf("别名不能为空")
	}

	// 验证别名格式：仅允许字母、数字、下划线
	match, _ = regexp.MatchString("^[a-zA-Z0-9_]+$", req.TableAlias)
	if !match {
		return fmt.Errorf("别名只能包含字母、数字、下划线")
	}

	return nil
}

// checkTableAliasExists 检查表别名是否存在（仅活跃记录，基于table_alias）
func checkTableAliasExists(ctx context.Context, tx *sqlx.Tx, tableAlias string) (bool, error) {
	var count int
	query := "SELECT COUNT(*) FROM dic_table_alias WHERE table_alias = ? AND deleted_at IS NULL"
	err := tx.GetContext(ctx, &count, query, tableAlias)
	return count > 0, err
}

// checkSoftDeletedTableAliasExists 检查表别名是否被软删除（基于table_alias）
func checkSoftDeletedTableAliasExists(ctx context.Context, tx *sqlx.Tx, tableAlias string) (bool, error) {
	var count int
	query := "SELECT COUNT(*) FROM dic_table_alias WHERE table_alias = ? AND deleted_at IS NOT NULL"
	err := tx.GetContext(ctx, &count, query, tableAlias)
	return count > 0, err
}

// restoreTableAlias 恢复软删除的表别名
func restoreTableAlias(ctx context.Context, tx *sqlx.Tx, req *TableAliasRequest) (tables.DicTableAliasDB, error) {
	query := `
		UPDATE dic_table_alias 
		SET deleted_at = NULL, table_id = ?, updated_at = CURRENT_TIMESTAMP
		WHERE table_alias = ? AND deleted_at IS NOT NULL
	`
	_, err := tx.ExecContext(ctx, query,
		req.TableID,
		req.TableAlias,
	)
	if err != nil {
		return tables.DicTableAliasDB{}, err
	}

	// 查询恢复后的记录
	var tableAlias tables.DicTableAliasDB
	selectQuery := `
		SELECT id, table_id, table_alias, created_at, updated_at, deleted_at
		FROM dic_table_alias
		WHERE table_alias = ? AND deleted_at IS NULL
	`
	err = tx.GetContext(ctx, &tableAlias, selectQuery, req.TableAlias)
	return tableAlias, err
}

// insertTableAlias 插入表别名
func insertTableAlias(ctx context.Context, tx *sqlx.Tx, req *TableAliasRequest, creator string) (tables.DicTableAliasDB, error) {
	// 生成ID
	id := req.ID
	if id == "" {
		id = uuid.New().String()
	}

	query := `
		INSERT INTO dic_table_alias (id, table_id, table_alias, created_at, updated_at)
		VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
	`
	logger.Debug(fmt.Sprintf("insertTableAlias - 执行插入: query=%s, id=%s, table_id=%s, table_alias=%s", query, id, req.TableID, req.TableAlias))

	_, err := tx.ExecContext(ctx, query,
		id,
		req.TableID,
		req.TableAlias,
	)
	if err != nil {
		logger.Error(fmt.Sprintf("insertTableAlias - 插入失败: %v", err))
		return tables.DicTableAliasDB{}, err
	}

	// 查询刚插入的记录
	var tableAlias tables.DicTableAliasDB
	selectQuery := `
		SELECT id, table_id, table_alias, created_at, updated_at, deleted_at
		FROM dic_table_alias
		WHERE table_alias = ? AND deleted_at IS NULL
	`
	err = tx.GetContext(ctx, &tableAlias, selectQuery, req.TableAlias)
	return tableAlias, err
}

// updateTableAlias 更新表别名
func updateTableAlias(ctx context.Context, tx *sqlx.Tx, req *TableAliasRequest) (tables.DicTableAliasDB, error) {
	// 使用ID更新（如果提供ID），否则使用table_alias
	var query string
	var queryArgs []interface{}

	if req.ID != "" {
		query = `
			UPDATE dic_table_alias
			SET table_id = ?, updated_at = CURRENT_TIMESTAMP
			WHERE id = ? AND deleted_at IS NULL
		`
		queryArgs = []interface{}{req.TableID, req.ID}
	} else {
		query = `
			UPDATE dic_table_alias
			SET table_id = ?, updated_at = CURRENT_TIMESTAMP
			WHERE table_alias = ? AND deleted_at IS NULL
		`
		queryArgs = []interface{}{req.TableID, req.TableAlias}
	}

	_, err := tx.ExecContext(ctx, query, queryArgs...)
	if err != nil {
		return tables.DicTableAliasDB{}, err
	}

	// 查询更新后的记录
	var tableAlias tables.DicTableAliasDB
	selectQuery := `
		SELECT id, table_id, table_alias, created_at, updated_at, deleted_at
		FROM dic_table_alias
		WHERE table_alias = ? AND deleted_at IS NULL
	`
	err = tx.GetContext(ctx, &tableAlias, selectQuery, req.TableAlias)
	return tableAlias, err
}