package svcstartup

import (
	"context"
	"fmt"

	"git.x2erp.com/qdy/go-base/ctx"
	"git.x2erp.com/qdy/go-base/logger"
	"git.x2erp.com/qdy/go-base/model/request/configreq"
	"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/service/dao"
	"github.com/jmoiron/sqlx"
)

func CreateStartupSVCConfig(serviceName string, req *configreq.ConfigRequest, ctx context.Context, dbFactory *database.DBFactory, reqCtx *ctx.RequestContext) *response.QueryResult[int64] {

	logger.Debug("CreateStartupSVCConfig-开始删除启动配置:%s", serviceName)

	param := dao.GetConfigStartupParamSVC(serviceName, req)
	if len(param.IDS) == 0 {
		logger.ErrorC(reqCtx, "参数为空")
		return util.CreateErrorResult[int64]("参数为空", reqCtx)
	}

	// 1. 验证配置字段与元信息一致性
	logger.Debug("开始验证配置字段与元信息一致性")
	metaRecords, err := dao.ValidateConfigFieldsWithMeta(ctx, dbFactory, param)
	if err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("配置字段验证失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("配置字段验证失败: %v", err), reqCtx)
	}
	logger.Debug("配置字段验证通过")

	// 2. 验证字段值类型
	logger.Debug("开始验证字段值类型")
	if err := dao.ValidateFieldValues(req, metaRecords); err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("字段值验证失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("字段值验证失败: %v", err), reqCtx)
	}
	logger.Debug("字段值验证通过")

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

	// 4. 开始事务
	logger.Debug("开始数据库事务")
	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)
		}
	}()

	countDel, err := deleteSVCExistingConfig(ctx, tx, param)
	if err != nil {
		tx.Rollback()
		logger.ErrorC(reqCtx, fmt.Sprintf("删除现有配置失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("删除现有配置失败: %v", err), reqCtx)
	}
	logger.Debug(fmt.Sprintf("已删除配置: %s 的 %d 个字段", req.YamlRoot, countDel))

	// 6. 生成批量插入数据
	logger.Debug("开始生成批量插入数据")
	records := generateBatchInsertDataSVC(serviceName, param, reqCtx.UserID)
	logger.Debug(fmt.Sprintf("生成了 %d 条配置记录", len(records)))

	// 7. 批量插入配置记录
	logger.Debug("开始批量插入配置记录")
	count, err := batchInsertConfigRecordsSVC(ctx, tx, records)
	if err != nil {
		tx.Rollback()
		logger.ErrorC(reqCtx, fmt.Sprintf("插入配置记录失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("插入配置记录失败: %v", err), reqCtx)
	}
	logger.Debug(fmt.Sprintf("成功插入 %d 条记录", count))

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

	logger.Debug("启动配置创建完成")
	return util.CreateSuccessResultData[int64](count, reqCtx)
}

func DeleteSVCtartupConfig(serviceName string, req *configreq.ConfigRequest, ctx context.Context, dbFactory *database.DBFactory, reqCtx *ctx.RequestContext) *response.QueryResult[int64] {
	logger.Debug("DeleteSVCtartupConfig-开始删除启动配置:%s", serviceName)

	param := dao.GetConfigStartupParamSVC(serviceName, req)
	if len(param.IDS) == 0 {
		logger.ErrorC(reqCtx, "参数为空")
		return util.CreateErrorResult[int64]("参数为空", reqCtx)
	}

	if len(param.IDS) == 0 {
		return util.CreateErrorResult[int64]("需要指定要删除的配置字段", 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)
	}

	// 执行删除
	count, err := deleteSVCExistingConfig(ctx, tx, param)
	if err != nil {
		tx.Rollback()
		logger.ErrorC(reqCtx, fmt.Sprintf("删除配置失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("删除配置失败: %v", err), 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("成功删除配置: %s 的 %d 个字段", req.YamlRoot, count))
	return util.CreateSuccessResultData[int64](count, reqCtx)
}

// 删除现有配置
func deleteSVCExistingConfig(ctx context.Context, tx *sqlx.Tx, param *dao.ConfigMetaParam) (int64, error) {

	query := `DELETE FROM config_startup_svc WHERE id IN (?)`
	ids := param.GetSvcIDS()
	query, args, err := sqlx.In(query, ids)
	if err != nil {
		return -1, fmt.Errorf("构建删除语句失败: %v", err)
	}

	result, err := tx.ExecContext(ctx, query, args...)

	return dao.ValidateResultRowsAffected(result, err, len(ids))

}

// 生成批量插入数据
func generateBatchInsertDataSVC(serviceName string, param *dao.ConfigMetaParam, creator string) []interface{} {
	// 创建字段类型映射
	//fieldTypeMap := make(map[string]string)
	//for _, record := range metaRecords {
	//	fieldTypeMap[record.YamlName] = record.FieldType
	//}

	req := param.ConfigRequest
	records := make([]interface{}, 0, len(req.ConfigFields))

	for _, configInfo := range req.ConfigFields {

		id := param.GetID(configInfo.YamlName)
		record := map[string]interface{}{
			"id":           id,
			"service_name": serviceName,
			"config_name":  req.YamlRoot,
			"yaml_name":    configInfo.YamlName,
			"yaml_value":   configInfo.YamlValue,
			"creator":      creator,
			"created_at":   "CURRENT_TIMESTAMP",
		}
		records = append(records, record)
	}

	return records
}

// 批量插入配置记录
func batchInsertConfigRecordsSVC(ctx context.Context, tx *sqlx.Tx, records []interface{}) (int64, error) {

	if len(records) == 0 {
		return 0, nil
	}

	query := `
        INSERT INTO config_startup_svc
        (id,service_name,config_name, yaml_name, yaml_value, creator, created_at)
        VALUES (:id, :service_name, :config_name, :yaml_name, :yaml_value, :creator, CURRENT_TIMESTAMP)
    `

	result, err := tx.NamedExecContext(ctx, query, records)

	return dao.ValidateResultRowsAffected(result, err, len(records))

}