package aliasmanagement

import (
	"context"
	"fmt"

	"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/jmoiron/sqlx"
)

// BatchApprovalTableFieldAliasFlow 批量审批字段别名字典流水记录
func BatchApprovalTableFieldAliasFlow(req *BatchApprovalFlowRequest, ctx context.Context, dbFactory *database.DBFactory, reqCtx *ctx.RequestContext) *response.QueryResult[int64] {
	logger.Debug(fmt.Sprintf("BatchApprovalTableFieldAliasFlow-开始批量审批字段别名字典流水，审批状态: %d, 审批人: %s, 记录数: %d",
		req.ApprovalStatus, req.Approver, len(req.IDs)))

	// 参数验证
	if len(req.IDs) == 0 {
		logger.ErrorC(reqCtx, "审批记录ID列表不能为空")
		return util.CreateErrorResult[int64]("审批记录ID列表不能为空", reqCtx)
	}
	if req.Approver == "" {
		logger.ErrorC(reqCtx, "审批人不能为空")
		return util.CreateErrorResult[int64]("审批人不能为空", reqCtx)
	}
	if req.ApprovalStatus < 0 || req.ApprovalStatus > 2 {
		logger.ErrorC(reqCtx, "审批状态无效（0待审批，1通过，2拒绝）")
		return util.CreateErrorResult[int64]("审批状态无效（0待审批，1通过，2拒绝）", reqCtx)
	}

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

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

	var totalRows int64
	var errors []string

	// 批量处理每个流水记录
	for i, id := range req.IDs {
		logger.Debug(fmt.Sprintf("处理第%d个流水记录审批: id=%s", i+1, id))

		// 检查流水记录是否存在且为待审批状态
		exists, err := checkTableFieldAliasFlowExistsByID(ctx, tx, id)
		if err != nil {
			errors = append(errors, fmt.Sprintf("第%d个流水记录检查存在性失败: %v", i+1, err))
			continue
		}
		if !exists {
			errors = append(errors, fmt.Sprintf("第%d个流水记录ID '%s' 不存在", i+1, id))
			continue
		}

		// 获取流水记录详情
		flowRecord, err := getTableFieldAliasFlowByID(ctx, tx, id)
		if err != nil {
			errors = append(errors, fmt.Sprintf("第%d个流水记录获取详情失败: %v", i+1, err))
			continue
		}

		// 检查是否已经是待审批状态（可选，允许重新审批）
		if flowRecord.ApprovalStatus == req.ApprovalStatus {
			logger.Debug(fmt.Sprintf("第%d个流水记录已是目标审批状态，跳过: id=%s", i+1, id))
			continue
		}

		// 根据审批状态处理
		if req.ApprovalStatus == 1 {
			// 审批通过：将记录插入正式表，更新流水记录
			rows, err := approveTableFieldAliasFlow(ctx, tx, &flowRecord, req.Approver)
			if err != nil {
				errors = append(errors, fmt.Sprintf("第%d个流水记录审批通过失败: %v", i+1, err))
				continue
			}
			totalRows += rows
			logger.Debug(fmt.Sprintf("第%d个流水记录审批通过成功: id=%s", i+1, id))
		} else if req.ApprovalStatus == 2 {
			// 审批拒绝：只更新流水记录状态
			rows, err := rejectTableFieldAliasFlow(ctx, tx, id, req.Approver)
			if err != nil {
				errors = append(errors, fmt.Sprintf("第%d个流水记录审批拒绝失败: %v", i+1, err))
				continue
			}
			totalRows += rows
			logger.Debug(fmt.Sprintf("第%d个流水记录审批拒绝成功: id=%s", i+1, id))
		} else {
			// 状态为0（待审批）：只更新审批状态（可能用于重置）
			rows, err := updateTableFieldAliasFlowStatus(ctx, tx, id, req.ApprovalStatus, req.Approver)
			if err != nil {
				errors = append(errors, fmt.Sprintf("第%d个流水记录更新状态失败: %v", i+1, err))
				continue
			}
			totalRows += rows
			logger.Debug(fmt.Sprintf("第%d个流水记录更新状态成功: id=%s", i+1, id))
		}
	}

	// 如果有错误，回滚事务
	if len(errors) > 0 {
		tx.Rollback()
		errorMsg := ""
		for i, errMsg := range errors {
			if i > 0 {
				errorMsg += "; "
			}
			errorMsg += errMsg
		}
		logger.ErrorC(reqCtx, fmt.Sprintf("批量审批字段别名字典流水失败: %s", errorMsg))
		return util.CreateErrorResult[int64](fmt.Sprintf("批量审批字段别名字典流水失败: %s", errorMsg), reqCtx)
	}

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

	logger.Debug(fmt.Sprintf("成功批量审批 %d 个字段别名字典流水记录，总影响行数: %d", len(req.IDs), totalRows))
	return util.CreateSuccessResultData[int64](totalRows, reqCtx)
}

// checkTableFieldAliasFlowExistsByID 检查字段别名流水记录是否存在（基于ID）
func checkTableFieldAliasFlowExistsByID(ctx context.Context, tx *sqlx.Tx, id string) (bool, error) {
	var count int
	query := "SELECT COUNT(*) FROM dic_table_field_alias_flow WHERE id = ? AND deleted_at IS NULL"
	err := tx.GetContext(ctx, &count, query, id)
	return count > 0, err
}

// getTableFieldAliasFlowByID 根据ID获取字段别名流水记录
func getTableFieldAliasFlowByID(ctx context.Context, tx *sqlx.Tx, id string) (tables.DicTableFieldAliasFlowDB, error) {
	var flowRecord tables.DicTableFieldAliasFlowDB
	query := `
		SELECT id, field_id, table_id, field_name, field_alias, description, where_condition, tenant_id, approval_status, approver, approved_at, created_at, updated_at, deleted_at
		FROM dic_table_field_alias_flow
		WHERE id = ? AND deleted_at IS NULL
	`
	err := tx.GetContext(ctx, &flowRecord, query, id)
	return flowRecord, err
}

// approveTableFieldAliasFlow 审批通过字段别名流水记录
func approveTableFieldAliasFlow(ctx context.Context, tx *sqlx.Tx, flowRecord *tables.DicTableFieldAliasFlowDB, approver string) (int64, error) {
	// 首先插入或更新正式表
	// 检查正式表是否已存在该别名
	aliasExists, err := checkTableFieldAliasExists(ctx, tx, flowRecord.FieldAlias)
	if err != nil {
		return 0, err
	}

	var rowsAffected int64
	if aliasExists {
		// 更新正式表
		query := `
			UPDATE dic_table_field_alias
			SET field_id = ?, table_id = ?, field_name = ?, description = ?, where_condition = ?, updated_at = CURRENT_TIMESTAMP
			WHERE field_alias = ? AND deleted_at IS NULL
		`
		result, err := tx.ExecContext(ctx, query, flowRecord.FieldID, flowRecord.TableID, flowRecord.FieldName, flowRecord.Description, flowRecord.WhereCondition, flowRecord.FieldAlias)
		if err != nil {
			return 0, err
		}
		rows, _ := result.RowsAffected()
		rowsAffected += rows
		logger.Debug(fmt.Sprintf("更新正式字段别名成功: %s", flowRecord.FieldAlias))
	} else {
		// 检查是否有软删除的记录
		softDeletedExists, err := checkSoftDeletedTableFieldAliasExists(ctx, tx, flowRecord.FieldAlias)
		if err != nil {
			return 0, err
		}

		if softDeletedExists {
			// 恢复软删除的记录
			query := `
				UPDATE dic_table_field_alias 
				SET deleted_at = NULL, field_id = ?, table_id = ?, field_name = ?, description = ?, where_condition = ?, updated_at = CURRENT_TIMESTAMP
				WHERE field_alias = ? AND deleted_at IS NOT NULL
			`
			result, err := tx.ExecContext(ctx, query, flowRecord.FieldID, flowRecord.TableID, flowRecord.FieldName, flowRecord.Description, flowRecord.WhereCondition, flowRecord.FieldAlias)
			if err != nil {
				return 0, err
			}
			rows, _ := result.RowsAffected()
			rowsAffected += rows
			logger.Debug(fmt.Sprintf("恢复软删除字段别名成功: %s", flowRecord.FieldAlias))
		} else {
			// 插入新记录
			query := `
				INSERT INTO dic_table_field_alias (id, field_id, table_id, field_name, field_alias, description, where_condition, created_at, updated_at)
				VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
			`
			result, err := tx.ExecContext(ctx, query, flowRecord.ID, flowRecord.FieldID, flowRecord.TableID, flowRecord.FieldName, flowRecord.FieldAlias, flowRecord.Description, flowRecord.WhereCondition)
			if err != nil {
				return 0, err
			}
			rows, _ := result.RowsAffected()
			rowsAffected += rows
			logger.Debug(fmt.Sprintf("插入正式字段别名成功: %s", flowRecord.FieldAlias))
		}
	}

	// 然后更新流水记录状态
	query := `
		UPDATE dic_table_field_alias_flow
		SET approval_status = 1, approver = ?, approved_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
		WHERE id = ? AND deleted_at IS NULL
	`
	result, err := tx.ExecContext(ctx, query, approver, flowRecord.ID)
	if err != nil {
		return 0, err
	}
	rows, _ := result.RowsAffected()
	rowsAffected += rows

	return rowsAffected, nil
}

// rejectTableFieldAliasFlow 审批拒绝字段别名流水记录
func rejectTableFieldAliasFlow(ctx context.Context, tx *sqlx.Tx, id, approver string) (int64, error) {
	query := `
		UPDATE dic_table_field_alias_flow
		SET approval_status = 2, approver = ?, approved_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
		WHERE id = ? AND deleted_at IS NULL
	`
	result, err := tx.ExecContext(ctx, query, approver, id)
	if err != nil {
		return 0, err
	}
	rows, _ := result.RowsAffected()
	return rows, nil
}

// updateTableFieldAliasFlowStatus 更新字段别名流水记录状态（用于重置等操作）
func updateTableFieldAliasFlowStatus(ctx context.Context, tx *sqlx.Tx, id string, approvalStatus int8, approver string) (int64, error) {
	var query string
	var queryArgs []interface{}

	if approvalStatus == 0 {
		// 重置为待审批，清除审批人和审批时间
		query = `
			UPDATE dic_table_field_alias_flow
			SET approval_status = 0, approver = '', approved_at = NULL, updated_at = CURRENT_TIMESTAMP
			WHERE id = ? AND deleted_at IS NULL
		`
		queryArgs = []interface{}{id}
	} else {
		// 其他状态更新
		query = `
			UPDATE dic_table_field_alias_flow
			SET approval_status = ?, approver = ?, approved_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
			WHERE id = ? AND deleted_at IS NULL
		`
		queryArgs = []interface{}{approvalStatus, approver, id}
	}

	result, err := tx.ExecContext(ctx, query, queryArgs...)
	if err != nil {
		return 0, err
	}
	rows, _ := result.RowsAffected()
	return rows, nil
}