package aliasmanagement

import (
	"context"
	"fmt"
	"strings"

	"git.x2erp.com/qdy/go-base/ctx"
	"git.x2erp.com/qdy/go-base/logger"
	"git.x2erp.com/qdy/go-base/model/request/queryreq"
	"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"
)

// ListTableAliasFlow 查询表别名字典流水列表（支持分页、搜索、排序）
func ListTableAliasFlow(req *TableAliasFlowQueryRequest, ctx context.Context, dbFactory *database.DBFactory, reqCtx *ctx.RequestContext) *response.QueryResult[[]tables.DicTableAliasFlowDB] {
	if logger.IsDebug() {
		logger.Debug("ListTableAliasFlow req: %v", req)
	}

	// 检查请求参数是否为nil
	if req == nil {
		logger.ErrorC(reqCtx, "ListTableAliasFlow请求参数为nil，创建默认参数")
		req = &TableAliasFlowQueryRequest{}
		req.Page = 0
		req.PageSize = 10
	}

	// 验证和规范化请求参数
	req.Validate()

	// 将旧字段转换为新的Filters和Sorts（向后兼容）
	convertLegacyTableAliasFlowFields(req)

	logger.Debug(fmt.Sprintf("ListTableAliasFlow-开始查询表别名字典流水，参数: page=%d, pageSize=%d, filters=%d, sorts=%d, legacyFields=[tableID=%s, tableAlias=%s, tenantID=%s, approvalStatus=%d]",
		req.Page, req.PageSize, len(req.Filter), len(req.Filter), req.TableID, req.TableAlias, req.TenantID, req.ApprovalStatus))

	// 获取数据库连接
	db := dbFactory.GetDB()

	// 定义字段映射函数：前端字段名 -> 数据库列名
	fieldMapper := func(field string) string {
		switch field {
		case "id":
			return "id"
		case "tableID":
			return "table_id"
		case "tableAlias":
			return "table_alias"
		case "tenantID":
			return "tenant_id"
		case "approvalStatus":
			return "approval_status"
		case "approver":
			return "approver"
		case "approvedAt":
			return "approved_at"
		case "createdAt":
			return "created_at"
		case "updatedAt":
			return "updated_at"
		case "deletedAt":
			return "deleted_at"
		default:
			// 未知字段，返回空字符串（将被忽略）
			return ""
		}
	}

	// 使用通用查询构建器构建SQL
	whereClause, whereArgs := queryreq.BuildWhereClause(req.Filter, fieldMapper)
	orderByClause := queryreq.BuildOrderByClause(req.Sort, fieldMapper)

	// 构建基础查询
	baseQuery := `
		SELECT id, table_id, table_alias, tenant_id, approval_status, approver, approved_at, created_at, updated_at, deleted_at
		FROM dic_table_alias_flow
		WHERE deleted_at IS NULL
	`

	// 构建计数查询
	countQuery := "SELECT COUNT(*) FROM dic_table_alias_flow WHERE deleted_at IS NULL"
	if whereClause != "" {
		// 移除"WHERE"前缀并清理空格
		conditions := strings.TrimSpace(strings.TrimPrefix(whereClause, "WHERE"))
		if conditions != "" {
			countQuery += " AND " + conditions
		}
	}

	// 构建数据查询
	dataQuery := baseQuery
	if whereClause != "" {
		// 移除"WHERE"前缀并清理空格
		conditions := strings.TrimSpace(strings.TrimPrefix(whereClause, "WHERE"))
		if conditions != "" {
			dataQuery += " AND " + conditions
		}
	}
	if orderByClause != "" {
		dataQuery += " " + orderByClause
	} else {
		// 默认排序
		dataQuery += " ORDER BY created_at DESC"
	}

	// 添加分页限制
	dataQuery += " LIMIT ? OFFSET ?"
	queryArgs := append(whereArgs, req.PageSize, req.GetOffset())

	// 查询总记录数
	var totalCount int64
	err := db.GetContext(ctx, &totalCount, countQuery, whereArgs...)
	if err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("查询表别名字典流水总数失败: %v", err))
		return util.CreateErrorResult[[]tables.DicTableAliasFlowDB](fmt.Sprintf("查询表别名字典流水总数失败: %v", err), reqCtx)
	}

	// 查询分页数据
	var tableAliasFlowList []tables.DicTableAliasFlowDB
	err = db.SelectContext(ctx, &tableAliasFlowList, dataQuery, queryArgs...)
	if err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("查询表别名字典流水失败: %v", err))
		return util.CreateErrorResult[[]tables.DicTableAliasFlowDB](fmt.Sprintf("查询表别名字典流水失败: %v", err), reqCtx)
	}

	logger.Debug(fmt.Sprintf("查询到 %d 条表别名字典流水，总记录数: %d", len(tableAliasFlowList), totalCount))

	// 创建结果，设置TotalCount
	result := util.CreateSuccessResultData[[]tables.DicTableAliasFlowDB](tableAliasFlowList, reqCtx)
	result.TotalCount = int(totalCount)

	// 计算总页数
	pageSize := req.PageSize
	if pageSize <= 0 {
		pageSize = 10 // 默认每页10条
	}
	lastPage := 1
	if pageSize > 0 && totalCount > 0 {
		lastPage = (int(totalCount) + pageSize - 1) / pageSize
	}
	result.LastPage = lastPage

	logger.Debug(fmt.Sprintf("设置QueryResult TotalCount: %d, LastPage: %d", result.TotalCount, result.LastPage))
	return result
}

// convertLegacyTableAliasFlowFields 将旧字段转换为新的Filters和Sorts（向后兼容）
func convertLegacyTableAliasFlowFields(req *TableAliasFlowQueryRequest) {
	// 转换旧搜索字段为Filters
	if req.TableID != "" {
		req.Filter = append(req.Filter, queryreq.FilterParam{
			Field:    "tableID",
			Operator: queryreq.OpLike,
			Value:    req.TableID,
		})
	}
	if req.TableAlias != "" {
		req.Filter = append(req.Filter, queryreq.FilterParam{
			Field:    "tableAlias",
			Operator: queryreq.OpLike,
			Value:    req.TableAlias,
		})
	}
	if req.TenantID != "" {
		req.Filter = append(req.Filter, queryreq.FilterParam{
			Field:    "tenantID",
			Operator: "=",
			Value:    req.TenantID,
		})
	}
	if req.ApprovalStatus >= 0 && req.ApprovalStatus <= 2 {
		req.Filter = append(req.Filter, queryreq.FilterParam{
			Field:    "approvalStatus",
			Operator: "=",
			Value:    req.ApprovalStatus,
		})
	}

	// 转换旧排序字段为Sorts
	if req.SortField != "" {
		// 映射可能的旧字段名
		sortField := req.SortField
		switch sortField {
		case "table_id":
			sortField = "tableID"
		case "table_alias":
			sortField = "tableAlias"
		case "tenant_id":
			sortField = "tenantID"
		case "approval_status":
			sortField = "approvalStatus"
		case "approver":
			sortField = "approver"
		case "approved_at":
			sortField = "approvedAt"
		case "created_at":
			sortField = "createdAt"
		case "updated_at":
			sortField = "updatedAt"
		}

		sortOrder := req.SortOrder
		if sortOrder != "asc" && sortOrder != "desc" {
			sortOrder = "asc"
		}

		req.Sort = append(req.Sort, queryreq.SortParam{
			Field: sortField,
			Order: sortOrder,
		})
	}
}

// SearchTableAliasFlow 搜索表别名字典流水（简单搜索）
func SearchTableAliasFlow(ctx context.Context, dbFactory *database.DBFactory, tableID, tableAlias, tenantID string, approvalStatus int8, reqCtx *ctx.RequestContext) *response.QueryResult[[]tables.DicTableAliasFlowDB] {
	logger.Debug("SearchTableAliasFlow-开始搜索表别名字典流水")

	// 获取数据库连接
	db := dbFactory.GetDB()

	// 构建查询条件和参数
	query := `
		SELECT id, table_id, table_alias, tenant_id, approval_status, approver, approved_at, created_at, updated_at, deleted_at
		FROM dic_table_alias_flow 
		WHERE deleted_at IS NULL
	`
	var args []interface{}

	if tableID != "" {
		query += " AND table_id LIKE ?"
		args = append(args, "%"+tableID+"%")
	}
	if tableAlias != "" {
		query += " AND table_alias LIKE ?"
		args = append(args, "%"+tableAlias+"%")
	}
	if tenantID != "" {
		query += " AND tenant_id = ?"
		args = append(args, tenantID)
	}
	if approvalStatus >= 0 && approvalStatus <= 2 {
		query += " AND approval_status = ?"
		args = append(args, approvalStatus)
	}

	query += " ORDER BY created_at DESC"

	var tableAliasFlowList []tables.DicTableAliasFlowDB
	err := db.SelectContext(ctx, &tableAliasFlowList, query, args...)
	if err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("搜索表别名字典流水失败: %v", err))
		return util.CreateErrorResult[[]tables.DicTableAliasFlowDB](fmt.Sprintf("搜索表别名字典流水失败: %v", err), reqCtx)
	}

	logger.Debug(fmt.Sprintf("搜索到 %d 条表别名字典流水", len(tableAliasFlowList)))
	return util.CreateSuccessResultData(tableAliasFlowList, reqCtx)
}