package warningconfig

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

	"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/xgorm/handler"
	"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.TSimWarningConfigExcelSubmitParam) (*PendingResult, error) {
	if in == nil {
		in = &model.TSimWarningConfigExcelSubmitParam{}
	}
	options, err := NormalizeContextOptions(in.ItemType, in.WarnUnit)
	if err != nil {
		return nil, err
	}
	processor := NewProcessor(options.ItemType)
	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, "sim_warning_config")
	return pendingResultFromBatch(result), nil
}

func CreatePendingInput(ctx context.Context, in *model.TSimWarningConfigInputSubmitParam) (*PendingResult, error) {
	if in == nil {
		in = &model.TSimWarningConfigInputSubmitParam{}
	}
	contextOptions, err := NormalizeContextOptions(in.ItemType, in.WarnUnit)
	if err != nil {
		return nil, err
	}
	rows, err := ParseInputRows(ctx, in.Input, contextOptions.ItemType, contextOptions.WarnUnit)
	if err != nil {
		return nil, err
	}
	options := contextOptions
	if rowsNeedSharedOptions(rows) {
		options, err = OptionsFromParams(in)
		if err != nil {
			return nil, err
		}
	}
	processor := NewProcessor(options.ItemType)
	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, "sim_warning_config")
	return pendingResultFromBatch(result), nil
}

func CreatePendingRange(ctx context.Context, in *model.TSimWarningConfigRangeSubmitParam) (*PendingResult, error) {
	if in == nil {
		in = &model.TSimWarningConfigRangeSubmitParam{}
	}
	options, err := OptionsFromParams(in)
	if err != nil {
		return nil, err
	}
	if options.ItemType == warnItemTypeFlowPool {
		return nil, gerror.New("流量池预警配置不支持连号")
	}
	rows, err := BuildRangeRows(ctx, in.StartIccid, in.EndIccid, in.StartMsisdn, in.EndMsisdn, in.StartImsi, in.EndImsi)
	if err != nil {
		return nil, err
	}
	processor := NewProcessor(options.ItemType)
	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, "sim_warning_config")
	return pendingResultFromBatch(result), nil
}

func prepareOptions(options Options) batchimport.PendingOptions {
	return batchimport.PendingOptions{
		PrepareRows: func(ctx context.Context, rows []batchimport.Row) error {
			if options.ItemType == warnItemTypeFlowPool {
				return prepareAuthorizedFlowPoolRows(ctx, rows, options)
			}
			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 prepareAuthorizedFlowPoolRows(ctx context.Context, rows []batchimport.Row, options Options) error {
	flowPoolRows := make([]*Row, 0, len(rows))
	codes := make([]string, 0, len(rows))
	for _, item := range rows {
		row, ok := item.(*Row)
		if !ok || row == nil {
			return gerror.New("预警配置行类型错误")
		}
		flowPoolRows = append(flowPoolRows, row)
		if code := strings.TrimSpace(row.FlowPoolCode); code != "" {
			codes = append(codes, code)
		}
	}
	if len(codes) == 0 {
		applyConfigSnapshot(rows, options)
		return nil
	}

	var visible []struct {
		FlowPoolCode string `orm:"flow_pool_code"`
	}
	columns := dao.TSimFlowPool.Columns()
	err := handler.Model(dao.TSimFlowPool.Ctx(ctx), &handler.Option{FilterTenant: true, FilterAuth: true}).
		Fields(columns.FlowPoolCode, columns.TenantId, columns.DeptId, columns.CreatedDept, columns.CreatedBy).
		WhereIn(columns.FlowPoolCode, codes).
		Scan(&visible)
	if err != nil {
		return gerror.Wrap(err, "计算流量池数据权限失败")
	}

	authorized := make(map[string]struct{}, len(visible))
	for _, pool := range visible {
		authorized[strings.TrimSpace(pool.FlowPoolCode)] = struct{}{}
	}
	for _, row := range flowPoolRows {
		_, ok := authorized[strings.TrimSpace(row.FlowPoolCode)]
		row.SetAuthorized(ok)
	}
	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
		}
		if row.ConfigSet {
			continue
		}
		row.Config = options
		row.ConfigSet = true
		if row.ItemType == 0 {
			row.ItemType = options.ItemType
		}
	}
}

func rowsNeedSharedOptions(rows []batchimport.Row) bool {
	for _, item := range rows {
		row, ok := item.(*Row)
		if ok && row != nil && !row.ConfigSet && row.Reason == "" {
			return true
		}
	}
	return false
}

func pendingResultFromBatch(result *batchimport.Result) *PendingResult {
	res := &PendingResult{
		BatchType:        consts.BatchTypeSimWarningConfig,
		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
}