package iot

import (
	"context"
	"database/sql"
	"errors"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/batchmetadata"
	"strings"
	"time"

	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/batchimport"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/contexts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/logic/iot/packageduration"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/logic/iot/simcardbatch/change"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/do"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/iot_excelize"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/ghttp"
	"github.com/gogf/gf/v2/os/gtime"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/xuri/excelize/v2"
)

const (
	cardChangeEffectiveImmediate = "immediate"
	cardChangeEffectiveNextMonth = "next_month"
)

type sIotTSimCardChange struct{}

func NewIotTSimCardChange() *sIotTSimCardChange {
	return &sIotTSimCardChange{}
}

func init() {
	service.RegisterIotTSimCardChange(NewIotTSimCardChange())
}

func (s *sIotTSimCardChange) DownloadExcelTemplate(ctx context.Context) error {
	f := excelize.NewFile()
	defer func() { _ = f.Close() }()

	headers := change.ExcelTemplateHeaders()
	if err := f.SetSheetRow("Sheet1", "A1", &headers); err != nil {
		return err
	}
	if err := iot_excelize.ApplyHeaderColumnsTextStyle(f); err != nil {
		return err
	}
	return iot_excelize.WriteHTTP(ctx, f, "sim_card_change_template")
}

// SubmitExcel Excel 仅作为 prepare source：构造 batch_type=4 的 Pending 变更预处理批次。
func (s *sIotTSimCardChange) SubmitExcel(ctx context.Context, in *model.TSimCardChangeExcelSubmitParam) (*model.TSimCardChangeExcelSubmitRes, error) {
	if in == nil {
		in = &model.TSimCardChangeExcelSubmitParam{}
	}

	file, err := s.getChangeUploadFile(ctx)
	if err != nil {
		return nil, err
	}

	excelProcessor := change.NewExcelProcessor()
	processor := change.NewPrepareProcessor()
	req := batchimport.SubmitRequest{
		SourceChannel: batchmetadata.Console,
		ExecutionMode: batchmetadata.Bulk,
		File:          file,
		SourceType:    consts.BatchSourceTypeFile,
		Operator:      currentOperator(ctx),
		BeforeSave: func(ctx context.Context, tx gdb.TX, request *batchimport.SubmitRequest, rows []batchimport.Row) error {
			opts := excelProcessor.ExcelSubmitOptions()
			if opts == nil {
				return gerror.New("excel change params are empty")
			}
			submitParam := opts.ToBatchSubmitParam()
			request.BizParams = submitParam
			changeRows, err := batchRowsToChangeRows(rows)
			if err != nil {
				return err
			}
			return s.prepareChangeRows(ctx, tx, request, processor, submitParam, changeRows)
		},
	}

	result, err := batchimport.CreatePendingUpload(ctx, req, processor, batchimport.PendingOptions{
		PrepareRows: func(ctx context.Context, rows []batchimport.Row) error {
			if len(rows) == 0 {
				return nil
			}
			return excelProcessor.ValidateRows(ctx, rows)
		},
	})
	if err != nil {
		return nil, err
	}

	res := changeExcelSubmitResult(result)
	if result.ImportStatus != consts.ImportStatusSuccess {
		return res, nil
	}

	if err = s.mergeChangeExcelBatchFileInfo(ctx, result.BatchNo, result.ImportFileOssId, result.ResultFileOssId, result.ResultDownloadId); err != nil {
		return nil, err
	}

	publishPendingExecute(ctx, result.BatchNo, consts.BatchTypePrepare, contexts.GetTenantId(ctx))
	return res, nil
}

func (s *sIotTSimCardChange) PrepareBatch(ctx context.Context, in *model.TSimCardChangeBatchPrepareParam) (*model.TSimCardChangeBatchPrepareRes, error) {
	if in == nil {
		in = &model.TSimCardChangeBatchPrepareParam{}
	}
	in.SourceBatchNo = strings.TrimSpace(in.SourceBatchNo)
	if in.SourceBatchNo == "" {
		return nil, gerror.New("sourceBatchNo cannot be empty")
	}

	rows, err := s.buildChangeRows(ctx, in.SourceBatchNo)
	if err != nil {
		return nil, err
	}
	return s.prepareRows(ctx, &model.TSimCardChangeBatchSubmitParam{}, rows, consts.BatchSourceTypeBatchSelect, in.SourceBatchNo, in.SourceBatchNo, &model.TSimCardChangeBatchPrepareParam{
		SourceBatchNo: in.SourceBatchNo,
	})
}

func (s *sIotTSimCardChange) PrepareInput(ctx context.Context, in *model.TSimCardChangeInputPrepareParam) (*model.TSimCardChangeBatchPrepareRes, error) {
	if in == nil {
		in = &model.TSimCardChangeInputPrepareParam{}
	}
	rows, err := change.ParseInputRows(ctx, in.Input)
	if err != nil {
		return nil, err
	}
	changeRows, err := batchRowsToChangeRows(rows)
	if err != nil {
		return nil, err
	}
	return s.prepareRows(ctx, changeSubmitParamFromInput(in), changeRows, consts.BatchSourceTypeBatchInput, "", "input-prepare", nil)
}

func (s *sIotTSimCardChange) PrepareRange(ctx context.Context, in *model.TSimCardChangeRangePrepareParam) (*model.TSimCardChangeBatchPrepareRes, error) {
	if in == nil {
		in = &model.TSimCardChangeRangePrepareParam{}
	}
	rows, err := change.BuildRangeRows(ctx, in.StartIccid, in.EndIccid, in.StartMsisdn, in.EndMsisdn, in.StartImsi, in.EndImsi)
	if err != nil {
		return nil, err
	}
	changeRows, err := batchRowsToChangeRows(rows)
	if err != nil {
		return nil, err
	}
	return s.prepareRows(ctx, changeSubmitParamFromRange(in), changeRows, consts.BatchSourceTypeRange, "", "range-prepare", nil)
}

func (s *sIotTSimCardChange) InputOptions(ctx context.Context, in *model.TSimCardChangeInputOptionsParam) (*model.TSimCardChangeOptionsRes, error) {
	if in == nil {
		in = &model.TSimCardChangeInputOptionsParam{}
	}
	rows, err := change.ParseInputRows(ctx, in.Input)
	if err != nil {
		return nil, err
	}
	changeRows, err := batchRowsToChangeRows(rows)
	if err != nil {
		return nil, err
	}
	return s.changeOptions(ctx, changeRows, "")
}

func (s *sIotTSimCardChange) RangeOptions(ctx context.Context, in *model.TSimCardChangeRangeOptionsParam) (*model.TSimCardChangeOptionsRes, error) {
	if in == nil {
		in = &model.TSimCardChangeRangeOptionsParam{}
	}
	rows, err := change.BuildRangeRows(ctx, in.StartIccid, in.EndIccid, in.StartMsisdn, in.EndMsisdn, in.StartImsi, in.EndImsi)
	if err != nil {
		return nil, err
	}
	changeRows, err := batchRowsToChangeRows(rows)
	if err != nil {
		return nil, err
	}
	return s.changeOptions(ctx, changeRows, "")
}

func (s *sIotTSimCardChange) changeOptions(ctx context.Context, rows []*change.Row, sourceBatchNo string) (*model.TSimCardChangeOptionsRes, error) {
	if len(rows) == 0 {
		return nil, gerror.New("change cards cannot be empty")
	}
	processor := change.NewPrepareProcessor()
	operator := currentOperator(ctx)
	var prepared *change.PrepareContext
	err := g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		var err error
		prepared, err = processor.ValidatePrepareContext(ctx, tx, &model.TSimCardChangeBatchPrepareParam{
			SourceBatchNo: strings.TrimSpace(sourceBatchNo),
		}, operator, rows)
		if err != nil {
			return err
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	if prepared == nil || prepared.OldPackage == nil {
		return nil, gerror.New("change prepare result is incomplete")
	}
	packages, err := s.loadChangeablePackageOptions(ctx, prepared.CustomerAgentId, prepared.OldPackage)
	if err != nil {
		return nil, err
	}
	if len(packages) == 0 {
		return nil, gerror.New("current package has no available changeable packages")
	}
	return &model.TSimCardChangeOptionsRes{
		CustomerAgentId: prepared.CustomerAgentId,
		CustomerName:    prepared.CustomerName,
		OldPackageCode:  prepared.OldPackage.PackageCode,
		OldPackageName:  prepared.OldPackage.PackageName,
		OldPackageType:  prepared.OldPackage.PackageType,
		Quantity:        prepared.Quantity,
		Packages:        packages,
	}, nil
}

func (s *sIotTSimCardChange) prepareRows(ctx context.Context, submitParam *model.TSimCardChangeBatchSubmitParam, rows []*change.Row, sourceType int, sourceBatchNo string, sourceName string, prepareParam *model.TSimCardChangeBatchPrepareParam) (*model.TSimCardChangeBatchPrepareRes, error) {
	if submitParam == nil {
		submitParam = &model.TSimCardChangeBatchSubmitParam{}
	}
	processor := change.NewPrepareProcessor()
	importRows := changeRowsToBatchRows(rows)

	req := batchimport.SubmitRequest{
		SourceChannel: batchmetadata.Console,
		ExecutionMode: batchmetadata.Bulk,
		BizParams:     prepareParamOrSubmitParam(prepareParam, submitParam),
		SourceType:    sourceType,
		SourceBatchNo: strings.TrimSpace(sourceBatchNo),
		Operator:      currentOperator(ctx),
		BeforeSave: func(ctx context.Context, tx gdb.TX, request *batchimport.SubmitRequest, batchRows []batchimport.Row) error {
			changeRows, err := batchRowsToChangeRows(batchRows)
			if err != nil {
				return err
			}
			return s.prepareChangeRows(ctx, tx, request, processor, submitParam, changeRows)
		},
	}
	result, err := batchimport.CreatePendingRows(ctx, req, processor, importRows, batchimport.PendingOptions{
		PrepareRows: func(ctx context.Context, rows []batchimport.Row) error {
			if len(rows) == 0 {
				return nil
			}
			return processor.ValidateRows(ctx, rows)
		},
	})
	if err != nil {
		return nil, err
	}

	res := &model.TSimCardChangeBatchPrepareRes{
		BatchNo:          result.BatchNo,
		BatchType:        result.BatchType,
		TargetBatchType:  consts.BatchTypeChange,
		Status:           pendingStatus(result.ImportStatus),
		BatchAsyncStatus: consts.BatchAsyncStatusPending,
		RunResult:        consts.BatchRunResultPending,
		Total:            result.TotalRows,
		ValidCount:       result.ValidRows,
		FailCount:        result.ErrorRows,
		ResultDownloadId: result.ResultDownloadId,
		ResultFileOssId:  result.ResultFileOssId,
	}
	if snapshot, ok := result.ExecutionResult.(*model.TSimCardChangePrepareSnapshot); ok && snapshot != nil {
		fillChangePrepareRes(res, snapshot)
	}

	publishPendingExecute(ctx, res.BatchNo, res.BatchType, contexts.GetTenantId(ctx))
	return res, nil
}

func (s *sIotTSimCardChange) prepareChangeRows(ctx context.Context, tx gdb.TX, request *batchimport.SubmitRequest, processor *change.PrepareProcessor, submitParam *model.TSimCardChangeBatchSubmitParam, rows []*change.Row) error {
	prepared, err := processor.ValidatePrepareContext(ctx, tx, &model.TSimCardChangeBatchPrepareParam{
		SourceBatchNo: request.SourceBatchNo,
	}, request.Operator, rows)
	if err != nil {
		return err
	}
	if prepared == nil || prepared.CustomerAgentId <= 0 || prepared.OldPackage == nil || strings.TrimSpace(prepared.OldPackage.PackageCode) == "" {
		return gerror.New("change prepare result is incomplete")
	}
	if submitParam != nil && strings.TrimSpace(submitParam.NewPackageCode) != "" {
		if strings.TrimSpace(submitParam.NewPackageCode) == strings.TrimSpace(prepared.OldPackage.PackageCode) {
			return gerror.New("newPackageCode cannot equal current package")
		}
		if !containsStringJSON(prepared.OldPackage.ChangeablePackageCodes, submitParam.NewPackageCode) {
			return gerror.New("newPackageCode is not in current package changeable range")
		}
	}
	request.TargetDeptId = prepared.CustomerAgentId
	request.ExecutionResult = &model.TSimCardChangePrepareSnapshot{
		SourceBatchNo:    strings.TrimSpace(request.SourceBatchNo),
		CustomerAgentId:  prepared.CustomerAgentId,
		CustomerName:     prepared.CustomerName,
		OldPackageCode:   prepared.OldPackage.PackageCode,
		OldPackageName:   prepared.OldPackage.PackageName,
		OldPackageType:   prepared.OldPackage.PackageType,
		OldPackageFlowMb: prepared.OldPackage.FlowMb,
		Quantity:         prepared.Quantity,
	}
	return nil
}

// SubmitBatch 作为 confirm 的语义：CAS 转换 batch_type=4+Success -> batch_type=102 Pending，发布异步任务。
func (s *sIotTSimCardChange) SubmitBatch(ctx context.Context, in *model.TSimCardChangeBatchSubmitParam) (*model.TSimCardChangeBatchSubmitRes, error) {
	if in == nil {
		in = &model.TSimCardChangeBatchSubmitParam{}
	}
	in.BatchNo = strings.TrimSpace(in.BatchNo)
	in.NewPackageCode = strings.TrimSpace(in.NewPackageCode)
	in.EffectiveMode = strings.TrimSpace(in.EffectiveMode)
	if in.BatchNo == "" {
		return nil, gerror.New("batchNo cannot be empty")
	}
	if in.NewPackageCode == "" {
		return nil, gerror.New("newPackageCode cannot be empty")
	}
	if in.DurationMonths <= 0 {
		return nil, gerror.New("durationMonths must be greater than 0")
	}
	if in.GiftDurationMonths < 0 {
		return nil, gerror.New("giftDurationMonths cannot be negative")
	}
	if !in.OfflineContractCompleted {
		return nil, gerror.New("please confirm offline contract is completed")
	}
	packageBeginTime, err := calcChangeBeginTime(in.EffectiveMode)
	if err != nil {
		return nil, err
	}

	operator := currentOperator(ctx)
	var prepareSnapshot *model.TSimCardChangePrepareSnapshot
	var priceSnapshot *model.TSimCardChangePriceSnapshot
	var converted *change.AsyncConfirmResult
	var sourceBatchNo string

	err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		batch, err := s.lockPrepareBatchForConfirm(ctx, tx, in.BatchNo)
		if err != nil {
			return err
		}
		prepareSnapshot, err = changePrepareSnapshotFromBatch(batch)
		if err != nil {
			return err
		}
		priceSnapshot, err = changePriceSnapshotFromBatch(batch)
		if err != nil {
			return err
		}
		priceSnapshot, err = s.refreshChangeConfirmPriceSnapshot(ctx, tx, prepareSnapshot, priceSnapshot)
		if err != nil {
			return err
		}
		sourceBatchNo = prepareSnapshot.SourceBatchNo
		if err = validateChangeConfirmContract(
			prepareSnapshot,
			priceSnapshot,
			jsonString(batch.BatchInfo, "effectiveMode", "changePrepareSnapshot.effectiveMode"),
			in,
		); err != nil {
			return err
		}

		converted, err = change.ConvertPrepareToAsync(ctx, tx, &change.AsyncConfirmInput{
			BatchNo:             in.BatchNo,
			TargetBatchType:     consts.BatchTypeChange,
			NewPackageCode:      priceSnapshot.NewPackageCode,
			DurationMonths:      in.DurationMonths,
			GiftDurationMonths:  in.GiftDurationMonths,
			EffectiveMode:       in.EffectiveMode,
			OfflineContract:     in.OfflineContractCompleted,
			BuyerNote:           in.BuyerNote,
			AdminNote:           in.AdminNote,
			Remark:              in.Remark,
			PriceSnapshot:       priceSnapshot,
			SourceBatchNo:       prepareSnapshot.SourceBatchNo,
			PackageBeginTimeStr: formatChangeTime(packageBeginTime),
			Operator:            operator,
		})
		return err
	})
	if err != nil {
		return nil, err
	}
	if converted == nil || prepareSnapshot == nil || priceSnapshot == nil {
		return nil, gerror.New("change submit result is empty")
	}

	publishPendingExecute(ctx, converted.BatchNo, converted.BatchType, contexts.GetTenantId(ctx))

	return &model.TSimCardChangeBatchSubmitRes{
		BatchNo:            converted.BatchNo,
		BatchType:          converted.BatchType,
		BatchAsyncStatus:   converted.BatchAsyncStatus,
		SourceBatchNo:      sourceBatchNo,
		Status:             "pending",
		NewPackageCode:     priceSnapshot.NewPackageCode,
		NewPackageName:     priceSnapshot.NewPackageName,
		OldPackageCode:     prepareSnapshot.OldPackageCode,
		OldPackageName:     prepareSnapshot.OldPackageName,
		DurationMonths:     in.DurationMonths,
		GiftDurationMonths: in.GiftDurationMonths,
		EffectiveMode:      in.EffectiveMode,
		PackageBeginTime:   packageBeginTime,
		PackageEndTime:     nil,
	}, nil
}

func validateChangeConfirmContract(
	prepareSnapshot *model.TSimCardChangePrepareSnapshot,
	priceSnapshot *model.TSimCardChangePriceSnapshot,
	preparedEffectiveMode string,
	in *model.TSimCardChangeBatchSubmitParam,
) error {
	if prepareSnapshot == nil || priceSnapshot == nil || in == nil {
		return gerror.New("change prepare contract is incomplete")
	}
	if strings.TrimSpace(in.NewPackageCode) == strings.TrimSpace(prepareSnapshot.OldPackageCode) {
		return gerror.New("newPackageCode cannot equal current package")
	}
	if strings.TrimSpace(in.NewPackageCode) != strings.TrimSpace(priceSnapshot.NewPackageCode) {
		return gerror.New("newPackageCode differs from prepare contract, please prepare again")
	}
	if !containsInt(priceSnapshot.RenewableDurationOptions, in.DurationMonths) {
		return gerror.New("durationMonths is not allowed for target package")
	}
	preparedEffectiveMode = strings.TrimSpace(preparedEffectiveMode)
	if preparedEffectiveMode != "" && preparedEffectiveMode != strings.TrimSpace(in.EffectiveMode) {
		return gerror.New("effectiveMode differs from prepare contract, please prepare again")
	}
	return nil
}

// PrepareResult 查询预处理批次当前异步状态。
func (s *sIotTSimCardChange) PrepareResult(ctx context.Context, batchNo string) (*model.TSimCardChangePrepareResultRes, error) {
	return loadPrepareResultChange(ctx, batchNo)
}

func (s *sIotTSimCardChange) refreshChangeConfirmPriceSnapshot(ctx context.Context, tx gdb.TX, prepareSnapshot *model.TSimCardChangePrepareSnapshot, priceSnapshot *model.TSimCardChangePriceSnapshot) (*model.TSimCardChangePriceSnapshot, error) {
	if prepareSnapshot == nil || priceSnapshot == nil {
		return nil, gerror.New("change prepare contract is incomplete")
	}
	oldPackageCode := strings.TrimSpace(prepareSnapshot.OldPackageCode)
	newPackageCode := strings.TrimSpace(priceSnapshot.NewPackageCode)
	if oldPackageCode == "" || newPackageCode == "" {
		return nil, gerror.New("change package contract is incomplete")
	}
	if oldPackageCode == newPackageCode {
		return nil, gerror.New("newPackageCode cannot equal current package")
	}

	oldPackage := &entity.TSimFlowPackageInfo{}
	columns := dao.TSimFlowPackageInfo.Columns()
	if err := tx.Ctx(ctx).Model(dao.TSimFlowPackageInfo.Table()).
		Where(columns.TenantId, contexts.GetTenantId(ctx)).
		Where(columns.PackageCode, oldPackageCode).
		Where(columns.Enabled, 1).
		LockUpdate().
		Scan(oldPackage); err != nil {
		return nil, gerror.Wrap(err, "load current package failed")
	}
	if oldPackage.Id == 0 {
		return nil, gerror.New("current package not found or disabled")
	}
	if !containsStringJSON(oldPackage.ChangeablePackageCodes, newPackageCode) {
		return nil, gerror.Newf("target package %s is not in current package %s changeable range", newPackageCode, oldPackageCode)
	}

	refreshed, err := s.buildChangePriceSnapshot(ctx, tx, priceSnapshot.CustomerAgentId, newPackageCode, prepareSnapshot.OldPackageType)
	if err != nil {
		return nil, err
	}
	return refreshed, nil
}

func loadPrepareResultChange(ctx context.Context, batchNo string) (*model.TSimCardChangePrepareResultRes, error) {
	batchNo = strings.TrimSpace(batchNo)
	if batchNo == "" {
		return nil, gerror.New("批次号不能为空")
	}
	columns := dao.BatchMain.Columns()
	batch := &entity.BatchMain{}
	if err := dao.BatchMain.Ctx(ctx).
		Where(columns.BatchNo, batchNo).
		Where(columns.TenantId, contexts.GetTenantId(ctx)).
		Where(columns.CreatedDept, contexts.GetDeptId(ctx)).
		Scan(batch); err != nil {
		return nil, gerror.Wrap(err, "查询预处理批次失败")
	}
	if batch.Id == 0 {
		return nil, gerror.New("预处理批次不存在或不可见")
	}
	if batch.BatchType != consts.BatchTypePrepare && !(batch.BatchInfo != nil && batch.BatchInfo.Get("targetBatchType").Int() == consts.BatchTypeChange) {
		return nil, gerror.New("批次类型不匹配")
	}

	asyncStatus := consts.BatchAsyncStatusPending
	runResult := consts.BatchRunResultPending
	statusKey := "pending"
	switch {
	case batch.BatchAsyncStatus == consts.BatchAsyncStatusProcessing || batch.RunResult == consts.BatchRunResultRunning:
		asyncStatus = consts.BatchAsyncStatusProcessing
		runResult = consts.BatchRunResultRunning
		statusKey = "processing"
	case batch.BatchAsyncStatus == consts.BatchAsyncStatusSuccess && batch.RunResult == consts.BatchRunResultSuccess:
		asyncStatus = consts.BatchAsyncStatusSuccess
		runResult = consts.BatchRunResultSuccess
		statusKey = "success"
	case batch.BatchAsyncStatus == consts.BatchAsyncStatusFailed || batch.RunResult == consts.BatchRunResultFailed:
		asyncStatus = consts.BatchAsyncStatusFailed
		runResult = consts.BatchRunResultFailed
		statusKey = "failed"
	case batch.BatchAsyncStatus == consts.BatchAsyncStatusPartialSuccess || batch.RunResult == consts.BatchRunResultPartialSuccess:
		asyncStatus = consts.BatchAsyncStatusPartialSuccess
		runResult = consts.BatchRunResultPartialSuccess
		statusKey = "partial_success"
	}

	fields := buildChangePrepareFields(batch)
	res := &model.TSimCardChangePrepareResultRes{
		BatchNo:          batch.BatchNo,
		BatchType:        batch.BatchType,
		TargetBatchType:  consts.BatchTypeChange,
		Status:           statusKey,
		BatchAsyncStatus: asyncStatus,
		RunResult:        runResult,
		Total:            batch.TotalCount,
		SuccessCount:     batch.SuccessCount,
		FailCount:        batch.FailCount,
		FailReason:       strings.TrimSpace(batch.FailReason),
		StartTime:        batch.StartTime,
		EndTime:          batch.EndTime,
		Snapshot:         gjson.New(fields),
	}
	if fields != nil {
		res.CustomerAgentId = gconv.Int64(fields["customerAgentId"])
		res.CustomerName = strings.TrimSpace(gconv.String(fields["customerName"]))
		res.PackageCode = strings.TrimSpace(gconv.String(fields["newPackageCode"]))
		res.PackageName = strings.TrimSpace(gconv.String(fields["newPackageName"]))
		res.OldPackageCode = strings.TrimSpace(gconv.String(fields["oldPackageCode"]))
		res.OldPackageName = strings.TrimSpace(gconv.String(fields["oldPackageName"]))
		res.OldPackageType = gconv.Int(fields["oldPackageType"])
		res.OldPackageFlowMb = gconv.Float64(fields["oldPackageFlowMb"])
		res.Quantity = gconv.Int(fields["quantity"])
		res.PriceSource = strings.TrimSpace(gconv.String(fields["priceSource"]))
		res.AgentDefaultPriceId = gconv.Int64(fields["agentDefaultPriceId"])
		res.TargetPriceId = gconv.Int64(fields["targetPriceId"])
		res.ChangeUnitPrice = gconv.Float64(fields["changeUnitPrice"])
		res.RenewableDurationOptions = gconv.Ints(fields["renewableDurationOptions"])
	}
	return res, nil
}

func (s *sIotTSimCardChange) buildChangeRows(ctx context.Context, sourceBatchNo string) ([]*change.Row, error) {
	rows, err := change.NewRepository().GetSourceBindRows(ctx, sourceBatchNo)
	if err != nil {
		return nil, gerror.Wrap(err, "load source order batch card details failed")
	}
	if len(rows) == 0 {
		return nil, gerror.New("source order batch has no changeable cards")
	}
	return rows, nil
}

func (s *sIotTSimCardChange) lockPrepareBatchForConfirm(ctx context.Context, tx gdb.TX, batchNo string) (*entity.BatchMain, error) {
	columns := dao.BatchMain.Columns()
	batch := &entity.BatchMain{}
	err := tx.Ctx(ctx).Model(dao.BatchMain.Table()).
		Where(columns.BatchNo, batchNo).
		Where(columns.BatchType, consts.BatchTypePrepare).
		Where(columns.BatchAsyncStatus, consts.BatchAsyncStatusSuccess).
		Where(columns.RunResult, consts.BatchRunResultSuccess).
		Where(columns.TenantId, contexts.GetTenantId(ctx)).
		Where(columns.CreatedDept, contexts.GetDeptId(ctx)).
		LockUpdate().
		Scan(batch)
	if err != nil {
		return nil, gerror.Wrap(err, "load change prepare batch failed")
	}
	if batch.Id == 0 {
		return nil, gerror.New("change prepare batch not found or not yet completed")
	}
	if batch.BatchInfo == nil {
		return nil, gerror.New("change prepare batch info is missing")
	}
	if batch.BatchInfo.Get("targetBatchType").Int() != consts.BatchTypeChange {
		return nil, gerror.New("batch is not a sim card change prepare batch")
	}
	return batch, nil
}

func (s *sIotTSimCardChange) buildChangePriceSnapshot(ctx context.Context, tx gdb.TX, customerAgentId int64, packageCode string, oldPackageType int) (*model.TSimCardChangePriceSnapshot, error) {
	packageCode = strings.TrimSpace(packageCode)
	if customerAgentId <= 0 {
		return nil, gerror.New("customerAgentId cannot be empty")
	}
	if packageCode == "" {
		return nil, gerror.New("newPackageCode cannot be empty")
	}

	pkg := &entity.TSimFlowPackageInfo{}
	pkgColumns := dao.TSimFlowPackageInfo.Columns()
	if err := tx.Ctx(ctx).Model(dao.TSimFlowPackageInfo.Table()).
		Where(pkgColumns.TenantId, contexts.GetTenantId(ctx)).
		Where(pkgColumns.PackageCode, packageCode).
		Where(pkgColumns.Enabled, 1).
		Scan(pkg); err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, gerror.New("target package not found or disabled")
		}
		return nil, gerror.Wrap(err, "load target package failed")
	}
	if pkg.Id == 0 {
		return nil, gerror.New("target package not found or disabled")
	}
	if oldPackageType > 0 && pkg.PackageType != oldPackageType {
		return nil, gerror.New("target package type does not match current package type")
	}

	options, err := packageduration.ChangeMonths(pkg)
	if err != nil {
		return nil, err
	}

	snapshot := &model.TSimCardChangePriceSnapshot{
		CustomerAgentId:          customerAgentId,
		NewPackageCode:           pkg.PackageCode,
		NewPackageName:           pkg.PackageName,
		NewPackageType:           pkg.PackageType,
		NewPackageFlowMb:         pkg.FlowMb,
		PriceSource:              "system",
		ChangeUnitPrice:          roundAmount(pkg.CostPrice*normalizePriceRatio(pkg.SysDefaultRatio) + pkg.SysDefaultProfit),
		RenewableDurationOptions: options,
	}

	priceOwnerDeptID, err := loadPackagePriceParentDeptID(ctx, tx, contexts.GetTenantId(ctx), customerAgentId)
	if err != nil {
		return nil, err
	}
	salePrice, err := resolvePackageEffectiveSalePrice(ctx, tx, contexts.GetTenantId(ctx), priceOwnerDeptID, customerAgentId, packagePriceSourceFromEntity(pkg))
	if err != nil {
		return nil, err
	}
	snapshot.PriceSource = salePrice.Rule.PriceSource
	snapshot.AgentDefaultPriceId = salePrice.Rule.AgentDefaultPriceId
	snapshot.TargetPriceId = salePrice.Rule.TargetPriceId
	snapshot.ChangeUnitPrice = salePrice.AgentShipmentPrice
	return snapshot, nil
}

func (s *sIotTSimCardChange) loadChangeablePackageOptions(ctx context.Context, customerAgentId int64, oldPackage *entity.TSimFlowPackageInfo) ([]model.TSimCardChangePackageOption, error) {
	if oldPackage == nil {
		return nil, gerror.New("current package is empty")
	}
	codes := stringListFromJSON(oldPackage.ChangeablePackageCodes)
	if len(codes) == 0 {
		return nil, gerror.New("current package has no changeable packages configured")
	}

	options := make([]model.TSimCardChangePackageOption, 0, len(codes))
	err := g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		for _, code := range codes {
			if code == strings.TrimSpace(oldPackage.PackageCode) {
				continue
			}
			snapshot, err := s.buildChangePriceSnapshot(ctx, tx, customerAgentId, code, oldPackage.PackageType)
			if err != nil {
				continue
			}
			options = append(options, model.TSimCardChangePackageOption{
				PackageCode:              snapshot.NewPackageCode,
				PackageName:              snapshot.NewPackageName,
				PackageType:              snapshot.NewPackageType,
				FlowMb:                   snapshot.NewPackageFlowMb,
				ChangeUnitPrice:          snapshot.ChangeUnitPrice,
				RenewableDurationOptions: snapshot.RenewableDurationOptions,
			})
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	return options, nil
}

func (s *sIotTSimCardChange) loadChangePriceOverride(ctx context.Context, tx gdb.TX, scopeType int, targetAgentId int64, packageCode string) (*entity.TSimFlowPackagePrice, error) {
	columns := dao.TSimFlowPackagePrice.Columns()
	price := &entity.TSimFlowPackagePrice{}
	err := tx.Ctx(ctx).Model(dao.TSimFlowPackagePrice.Table()).
		Where(columns.TenantId, contexts.GetTenantId(ctx)).
		Where(columns.DeptId, contexts.GetDeptId(ctx)).
		Where(columns.AgentScopeType, scopeType).
		Where(columns.TargetAgentId, targetAgentId).
		Where(columns.PackageCode, packageCode).
		Scan(price)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, nil
		}
		return nil, gerror.Wrap(err, "load change package price failed")
	}
	if price.Id == 0 {
		return nil, nil
	}
	return price, nil
}

func batchRowsToChangeRows(rows []batchimport.Row) ([]*change.Row, error) {
	result := make([]*change.Row, 0, len(rows))
	for _, item := range rows {
		row, ok := item.(*change.Row)
		if !ok || row == nil {
			return nil, gerror.New("change row type is invalid")
		}
		result = append(result, row)
	}
	return result, nil
}

func changeRowsToBatchRows(rows []*change.Row) []batchimport.Row {
	result := make([]batchimport.Row, 0, len(rows))
	for _, row := range rows {
		result = append(result, row)
	}
	return result
}

func fillChangePrepareRes(res *model.TSimCardChangeBatchPrepareRes, snapshot *model.TSimCardChangePrepareSnapshot) {
	res.SourceBatchNo = snapshot.SourceBatchNo
	res.CustomerAgentId = snapshot.CustomerAgentId
	res.CustomerName = snapshot.CustomerName
	res.OldPackageCode = snapshot.OldPackageCode
	res.OldPackageName = snapshot.OldPackageName
	res.OldPackageType = snapshot.OldPackageType
	res.OldPackageFlowMb = snapshot.OldPackageFlowMb
}

func changePrepareSnapshotFromBatch(batch *entity.BatchMain) (*model.TSimCardChangePrepareSnapshot, error) {
	if batch == nil || batch.BatchInfo == nil {
		return nil, gerror.New("change prepare batch info is missing")
	}
	fields := buildChangePrepareFields(batch)
	snapshot := &model.TSimCardChangePrepareSnapshot{
		SourceBatchNo:    normalizedChangePrepareSourceBatchNo(batch, gconv.String(fields["sourceBatchNo"])),
		CustomerAgentId:  gconv.Int64(fields["customerAgentId"]),
		CustomerName:     strings.TrimSpace(gconv.String(fields["customerName"])),
		OldPackageCode:   strings.TrimSpace(gconv.String(fields["oldPackageCode"])),
		OldPackageName:   strings.TrimSpace(gconv.String(fields["oldPackageName"])),
		OldPackageType:   gconv.Int(fields["oldPackageType"]),
		OldPackageFlowMb: gconv.Float64(fields["oldPackageFlowMb"]),
		Quantity:         gconv.Int(fields["quantity"]),
	}
	if snapshot.OldPackageCode == "" {
		return nil, gerror.New("change prepare batch info is incomplete")
	}
	return snapshot, nil
}

func normalizedChangePrepareSourceBatchNo(batch *entity.BatchMain, sourceBatchNo string) string {
	if batch == nil || batch.SourceType != consts.BatchSourceTypeBatchSelect {
		return ""
	}
	batchNo := strings.TrimSpace(batch.BatchNo)
	sourceBatchNo = strings.TrimSpace(sourceBatchNo)
	if sourceBatchNo == "" || sourceBatchNo == batchNo {
		sourceBatchNo = strings.TrimSpace(batch.SourceBatchNo)
	}
	if sourceBatchNo == batchNo {
		return ""
	}
	return sourceBatchNo
}

func changePriceSnapshotFromBatch(batch *entity.BatchMain) (*model.TSimCardChangePriceSnapshot, error) {
	if batch == nil || batch.BatchInfo == nil {
		return nil, gerror.New("change prepare batch price info is missing")
	}
	fields := buildChangePrepareFields(batch)
	options := gconv.Ints(fields["renewableDurationOptions"])
	snapshot := &model.TSimCardChangePriceSnapshot{
		CustomerAgentId:          gconv.Int64(fields["customerAgentId"]),
		NewPackageCode:           strings.TrimSpace(gconv.String(fields["newPackageCode"])),
		NewPackageName:           strings.TrimSpace(gconv.String(fields["newPackageName"])),
		NewPackageType:           gconv.Int(fields["newPackageType"]),
		NewPackageFlowMb:         gconv.Float64(fields["newPackageFlowMb"]),
		PriceSource:              strings.TrimSpace(gconv.String(fields["priceSource"])),
		AgentDefaultPriceId:      gconv.Int64(fields["agentDefaultPriceId"]),
		TargetPriceId:            gconv.Int64(fields["targetPriceId"]),
		ChangeUnitPrice:          roundAmount(gconv.Float64(fields["changeUnitPrice"])),
		RenewableDurationOptions: options,
	}
	if snapshot.CustomerAgentId <= 0 || snapshot.NewPackageCode == "" || snapshot.ChangeUnitPrice < 0 || len(snapshot.RenewableDurationOptions) == 0 {
		return nil, gerror.New("change prepare batch price info is incomplete")
	}
	return snapshot, nil
}

func buildChangePrepareFields(batch *entity.BatchMain) map[string]any {
	if batch == nil {
		return nil
	}
	fields := prepareInfoMap(batch.BatchInfo)
	if fields == nil {
		fields = map[string]any{}
	}
	if value := jsonField(batch.BatchInfo, "customerAgentId", "customer.deptId", "changePrepareSnapshot.customerAgentId", "changePriceSnapshot.customerAgentId"); value != nil {
		fields["customerAgentId"] = gconv.Int64(value)
	}
	if value := jsonField(batch.BatchInfo, "customerName", "customer.name", "changePrepareSnapshot.customerName"); value != nil {
		fields["customerName"] = strings.TrimSpace(value.String())
	}
	if value := jsonField(batch.BatchInfo, "sourceBatchNo", "changePrepareSnapshot.sourceBatchNo"); value != nil {
		fields["sourceBatchNo"] = strings.TrimSpace(value.String())
	}
	if value := jsonField(batch.BatchInfo, "oldPackageCode", "changePrepareSnapshot.oldPackageCode"); value != nil {
		fields["oldPackageCode"] = strings.TrimSpace(value.String())
	}
	if value := jsonField(batch.BatchInfo, "oldPackageName", "changePrepareSnapshot.oldPackageName"); value != nil {
		fields["oldPackageName"] = strings.TrimSpace(value.String())
	}
	if value := jsonField(batch.BatchInfo, "oldPackageType", "changePrepareSnapshot.oldPackageType"); value != nil {
		fields["oldPackageType"] = gconv.Int(value)
	}
	if value := jsonField(batch.BatchInfo, "oldPackageFlowMb", "changePrepareSnapshot.oldPackageFlowMb"); value != nil {
		fields["oldPackageFlowMb"] = gconv.Float64(value)
	}
	if value := jsonField(batch.BatchInfo, "newPackageCode", "changePriceSnapshot.newPackageCode"); value != nil {
		fields["newPackageCode"] = strings.TrimSpace(value.String())
		fields["packageCode"] = strings.TrimSpace(value.String())
	}
	if value := jsonField(batch.BatchInfo, "newPackageName", "changePriceSnapshot.newPackageName"); value != nil {
		fields["newPackageName"] = strings.TrimSpace(value.String())
		fields["packageName"] = strings.TrimSpace(value.String())
	}
	if value := jsonField(batch.BatchInfo, "newPackageType", "changePriceSnapshot.newPackageType"); value != nil {
		fields["newPackageType"] = gconv.Int(value)
	}
	if value := jsonField(batch.BatchInfo, "newPackageFlowMb", "changePriceSnapshot.newPackageFlowMb"); value != nil {
		fields["newPackageFlowMb"] = gconv.Float64(value)
	}
	if value := jsonField(batch.BatchInfo, "priceSource", "changePriceSnapshot.priceSource"); value != nil {
		fields["priceSource"] = strings.TrimSpace(value.String())
	}
	if value := jsonField(batch.BatchInfo, "agentDefaultPriceId", "changePriceSnapshot.agentDefaultPriceId"); value != nil {
		fields["agentDefaultPriceId"] = gconv.Int64(value)
	}
	if value := jsonField(batch.BatchInfo, "targetPriceId", "changePriceSnapshot.targetPriceId"); value != nil {
		fields["targetPriceId"] = gconv.Int64(value)
	}
	if value := jsonField(batch.BatchInfo, "changeUnitPrice", "changePriceSnapshot.changeUnitPrice"); value != nil {
		fields["changeUnitPrice"] = roundAmount(gconv.Float64(value))
	}
	if values := jsonInts(batch.BatchInfo, "renewableDurationOptions", "changePriceSnapshot.renewableDurationOptions"); len(values) > 0 {
		fields["renewableDurationOptions"] = values
	}
	if value := jsonField(batch.BatchInfo, "quantity", "changePrepareSnapshot.quantity"); value != nil {
		fields["quantity"] = gconv.Int(value)
	} else if batch.TotalCount > 0 {
		fields["quantity"] = batch.TotalCount
	}
	return fields
}

func containsStringJSON(jsonValue any, target string) bool {
	target = strings.TrimSpace(target)
	if target == "" || jsonValue == nil {
		return false
	}
	var values []any
	switch value := jsonValue.(type) {
	case interface{ Interfaces() []any }:
		values = value.Interfaces()
	default:
		values = gconv.SliceAny(value)
	}
	for _, item := range values {
		if strings.TrimSpace(gconv.String(item)) == target {
			return true
		}
	}
	return false
}

func stringListFromJSON(jsonValue any) []string {
	if jsonValue == nil {
		return nil
	}
	var values []any
	switch value := jsonValue.(type) {
	case interface{ Interfaces() []any }:
		values = value.Interfaces()
	default:
		values = gconv.SliceAny(value)
	}
	if len(values) == 0 {
		return nil
	}
	seen := make(map[string]struct{}, len(values))
	result := make([]string, 0, len(values))
	for _, item := range values {
		value := strings.TrimSpace(gconv.String(item))
		if value == "" {
			continue
		}
		if _, ok := seen[value]; ok {
			continue
		}
		seen[value] = struct{}{}
		result = append(result, value)
	}
	return result
}

func calcChangeBeginTime(effectiveMode string) (*gtime.Time, error) {
	switch strings.TrimSpace(effectiveMode) {
	case cardChangeEffectiveImmediate:
		return gtime.Now(), nil
	case cardChangeEffectiveNextMonth:
		now := time.Now()
		nextMonth := time.Date(now.Year(), now.Month()+1, 1, 0, 0, 0, 0, now.Location())
		return gtime.NewFromTime(nextMonth), nil
	default:
		return nil, gerror.New("effectiveMode is unsupported")
	}
}

func changeSubmitParamFromInput(in *model.TSimCardChangeInputPrepareParam) *model.TSimCardChangeBatchSubmitParam {
	if in == nil {
		return &model.TSimCardChangeBatchSubmitParam{}
	}
	return &model.TSimCardChangeBatchSubmitParam{
		NewPackageCode:           strings.TrimSpace(in.NewPackageCode),
		DurationMonths:           in.DurationMonths,
		GiftDurationMonths:       in.GiftDurationMonths,
		EffectiveMode:            strings.TrimSpace(in.EffectiveMode),
		OfflineContractCompleted: in.OfflineContractCompleted,
	}
}

func changeSubmitParamFromRange(in *model.TSimCardChangeRangePrepareParam) *model.TSimCardChangeBatchSubmitParam {
	if in == nil {
		return &model.TSimCardChangeBatchSubmitParam{}
	}
	return &model.TSimCardChangeBatchSubmitParam{
		NewPackageCode:           strings.TrimSpace(in.NewPackageCode),
		DurationMonths:           in.DurationMonths,
		GiftDurationMonths:       in.GiftDurationMonths,
		EffectiveMode:            strings.TrimSpace(in.EffectiveMode),
		OfflineContractCompleted: in.OfflineContractCompleted,
	}
}

func prepareParamOrSubmitParam(prepareParam *model.TSimCardChangeBatchPrepareParam, submitParam *model.TSimCardChangeBatchSubmitParam) any {
	if prepareParam != nil {
		return prepareParam
	}
	return submitParam
}

func (s *sIotTSimCardChange) getChangeUploadFile(ctx context.Context) (*ghttp.UploadFile, error) {
	r := g.RequestFromCtx(ctx)
	if r == nil {
		return nil, gerror.New("current context is not an HTTP request")
	}
	file := r.GetUploadFile("file")
	if file == nil {
		return nil, gerror.New("please select upload file")
	}
	return file, nil
}

func changeExcelSubmitResult(result *batchimport.Result) *model.TSimCardChangeExcelSubmitRes {
	res := &model.TSimCardChangeExcelSubmitRes{
		BatchType:        consts.BatchTypePrepare,
		TargetBatchType:  consts.BatchTypeChange,
		Status:           pendingStatus(result.ImportStatus),
		BatchAsyncStatus: consts.BatchAsyncStatusPending,
		RunResult:        consts.BatchRunResultPending,
		Total:            result.TotalRows,
	}
	if result == nil {
		return res
	}
	res.BatchNo = result.BatchNo
	res.ResultDownloadId = result.ResultDownloadId
	res.ResultFileOssId = result.ResultFileOssId
	return res
}

func (s *sIotTSimCardChange) mergeChangeExcelBatchFileInfo(ctx context.Context, batchNo string, importFileOssId, resultFileOssId, resultDownloadId int64) error {
	operator := currentOperator(ctx)
	columns := dao.BatchMain.Columns()
	batch := &entity.BatchMain{}
	if err := dao.BatchMain.Ctx(ctx).
		Where(columns.BatchNo, strings.TrimSpace(batchNo)).
		Where(columns.TenantId, operator.TenantId).
		Where(columns.CreatedDept, operator.DeptId).
		Scan(batch); err != nil {
		return gerror.Wrap(err, "load change batch failed")
	}
	if batch.Id == 0 {
		return gerror.New("change batch not found")
	}

	info := changeExcelMergeBatchInfo(batch.BatchInfo, importFileOssId, resultFileOssId, resultDownloadId)
	if _, err := dao.BatchMain.Ctx(ctx).
		Where(columns.BatchNo, strings.TrimSpace(batchNo)).
		Data(do.BatchMain{
			SourceOssId: batchFileOssIDValue(importFileOssId),
			ResultOssId: batchFileOssIDValue(resultFileOssId),
			BatchInfo:   info,
			UpdatedBy:   operator.UserId,
			UpdatedAt:   gtime.Now(),
		}).
		Update(); err != nil {
		return gerror.Wrap(err, "update change batch file info failed")
	}
	return nil
}

func changeExcelMergeBatchInfo(info *gjson.Json, importFileOssId, resultFileOssId, resultDownloadId int64) *gjson.Json {
	data := g.Map{}
	if info != nil {
		for key, value := range info.Map() {
			data[key] = value
		}
	}
	if importFileOssId > 0 {
		data["importFileOssId"] = importFileOssId
	}
	if resultFileOssId > 0 {
		data["resultFileOssId"] = resultFileOssId
	}
	if resultDownloadId > 0 {
		data["resultDownloadId"] = resultDownloadId
	}
	return gjson.New(data)
}

func batchFileOssIDValue(ossID int64) any {
	if ossID <= 0 {
		return nil
	}
	return ossID
}

func trimChangeExcelFailReason(cause error) string {
	if cause == nil {
		return "change confirm failed"
	}
	reason := strings.TrimSpace(cause.Error())
	if reason == "" {
		return "change confirm failed"
	}
	const maxLen = 500
	runes := []rune(reason)
	if len(runes) <= maxLen {
		return reason
	}
	return string(runes[:maxLen])
}

func formatChangeTime(t *gtime.Time) string {
	if t == nil {
		return ""
	}
	return t.Format("Y-m-d H:i:s")
}