package trafficcutoffconfig

import (
	"context"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/batchmetadata"

	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/batchimport"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/logic/iot/simcardbatch/common"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"

	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/net/ghttp"
)

func CreatePendingExcel(ctx context.Context, file *ghttp.UploadFile, in *model.TSimCardTrafficCutoffExcelSubmitParam) (*PendingResult, error) {
	if in == nil {
		in = &model.TSimCardTrafficCutoffExcelSubmitParam{}
	}
	options, err := OptionsFromParams(in)
	if err != nil {
		return nil, err
	}
	processor := NewProcessor()
	req := batchimport.SubmitRequest{
		SourceChannel: batchmetadata.Console,
		ExecutionMode: batchmetadata.Bulk,
		File:          file,
		BizParams:     in,
		SourceType:    consts.BatchSourceTypeFile,
		Operator:      common.CurrentOperator(ctx),
	}
	result, err := batchimport.CreatePendingUpload(ctx, req, processor, prepareOptions(options))
	if err != nil {
		return nil, err
	}
	common.PublishBatchMessage(ctx, result, consts.QueueBatchExecute, "traffic_cutoff_config")
	return pendingResultFromBatch(result), nil
}

func CreatePendingInput(ctx context.Context, in *model.TSimCardTrafficCutoffInputSubmitParam) (*PendingResult, error) {
	if in == nil {
		in = &model.TSimCardTrafficCutoffInputSubmitParam{}
	}
	options, err := OptionsFromParams(in)
	if err != nil {
		return nil, err
	}
	rows, err := ParseInputRows(ctx, in.Input)
	if err != nil {
		return nil, err
	}
	processor := NewProcessor()
	req := batchimport.SubmitRequest{
		SourceChannel: batchmetadata.Console,
		ExecutionMode: batchmetadata.Bulk,
		BizParams:     in,
		SourceType:    consts.BatchSourceTypeBatchInput,
		Operator:      common.CurrentOperator(ctx),
	}
	result, err := batchimport.CreatePendingRows(ctx, req, processor, rows, prepareOptions(options))
	if err != nil {
		return nil, err
	}
	common.PublishBatchMessage(ctx, result, consts.QueueBatchExecute, "traffic_cutoff_config")
	return pendingResultFromBatch(result), nil
}

func CreatePendingRange(ctx context.Context, in *model.TSimCardTrafficCutoffRangeSubmitParam) (*PendingResult, error) {
	if in == nil {
		in = &model.TSimCardTrafficCutoffRangeSubmitParam{}
	}
	options, err := OptionsFromParams(in)
	if err != nil {
		return nil, err
	}
	rows, err := BuildRangeRows(ctx, in.StartIccid, in.EndIccid, in.StartMsisdn, in.EndMsisdn, in.StartImsi, in.EndImsi)
	if err != nil {
		return nil, err
	}
	processor := NewProcessor()
	req := batchimport.SubmitRequest{
		SourceChannel: batchmetadata.Console,
		ExecutionMode: batchmetadata.Bulk,
		BizParams:     in,
		SourceType:    consts.BatchSourceTypeRange,
		Operator:      common.CurrentOperator(ctx),
	}
	result, err := batchimport.CreatePendingRows(ctx, req, processor, rows, prepareOptions(options))
	if err != nil {
		return nil, err
	}
	common.PublishBatchMessage(ctx, result, consts.QueueBatchExecute, "traffic_cutoff_config")
	return pendingResultFromBatch(result), nil
}

func prepareOptions(options Options) batchimport.PendingOptions {
	return batchimport.PendingOptions{
		PrepareRows: func(ctx context.Context, rows []batchimport.Row) error {
			if err := common.PrepareAuthorizedRows(ctx, rows, func(item batchimport.Row) (*Row, error) {
				row, ok := item.(*Row)
				if !ok || row == nil {
					return nil, gerror.New("达量断网配置行类型错误")
				}
				return row, nil
			}, "达量断网配置行类型错误"); err != nil {
				return err
			}
			applyConfigSnapshot(rows, options)
			return nil
		},
	}
}

func applyConfigSnapshot(rows []batchimport.Row, options Options) {
	for _, item := range rows {
		row, ok := item.(*Row)
		if !ok || row == nil {
			continue
		}
		row.Config = options
	}
}

func pendingResultFromBatch(result *batchimport.Result) *PendingResult {
	res := &PendingResult{
		BatchType:        consts.BatchTypeTrafficCutoffConfig,
		BatchAsyncStatus: consts.BatchAsyncStatusPending,
	}
	if result == nil {
		return res
	}
	valid := result.ValidRows
	if result.TotalRows > 0 && valid == 0 {
		valid = result.TotalRows - result.ErrorRows
		if valid < 0 {
			valid = 0
		}
	}
	res.BatchNo = result.BatchNo
	res.BatchType = result.BatchType
	res.Total = result.TotalRows
	res.ValidCount = valid
	res.FailCount = result.ErrorRows
	return res
}