package trafficcutoffconfig

import (
	"context"
	"math"
	"sort"
	"strings"

	"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/os/gtime"

	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/consts"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/dao"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/do"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/entity"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/service/batchresult"
)

type Repository struct {
	db          gdb.DB
	results     batchresult.Generator
	lockEnabled bool
}

func NewRepository() *Repository {
	return &Repository{results: batchresult.New(), lockEnabled: true}
}

func (r *Repository) database() gdb.DB {
	if r.db != nil {
		return r.db
	}
	return g.DB()
}

func (r *Repository) applyLock(model *gdb.Model) *gdb.Model {
	if r.lockEnabled {
		return model.LockUpdate()
	}
	return model
}

func (r *Repository) Load(ctx context.Context, batchNo string) (*Task, error) {
	batchNo = strings.TrimSpace(batchNo)
	if batchNo == "" {
		return nil, gerror.New("达量断网配置批次号不能为空")
	}

	var main *entity.BatchMain
	if err := r.database().Model(dao.BatchMain.Table()).Safe().Ctx(ctx).
		Where(dao.BatchMain.Columns().BatchNo, batchNo).
		Where(dao.BatchMain.Columns().BatchType, consts.BatchTypeTrafficCutoffConfig).
		Where(dao.BatchMain.Columns().BatchAsyncStatus, consts.BatchAsyncStatusProcessing).
		Scan(&main); err != nil {
		return nil, gerror.Wrap(err, "查询达量断网配置批次主表失败")
	}
	if main == nil || main.Id == 0 {
		return nil, gerror.New("处理中达量断网配置批次不存在")
	}
	config, err := configFromBatchInfo(main.BatchInfo)
	if err != nil {
		return nil, err
	}

	var batchDetails []*entity.BatchDetail
	if err = r.database().Model(dao.BatchDetail.Table()).Safe().Ctx(ctx).
		Where(dao.BatchDetail.Columns().BatchNo, batchNo).
		Where(dao.BatchDetail.Columns().BatchType, consts.BatchTypeTrafficCutoffConfig).
		Where(dao.BatchDetail.Columns().DetailStatus, consts.BatchDetailStatusRunning).
		OrderAsc(dao.BatchDetail.Columns().RowNo).
		Scan(&batchDetails); err != nil {
		return nil, gerror.Wrap(err, "查询达量断网配置批次明细失败")
	}
	if len(batchDetails) == 0 {
		return nil, gerror.New("达量断网配置批次没有运行中明细")
	}

	task := &Task{
		Batch: Batch{
			ID:          main.Id,
			BatchNo:     main.BatchNo,
			BatchType:   main.BatchType,
			TenantID:    main.TenantId,
			CreatedDept: main.CreatedDept,
			CreatedBy:   main.CreatedBy,
			StartTime:   main.StartTime,
			BatchInfo:   main.BatchInfo,
		},
		Config:  config,
		Details: make([]*Detail, 0, len(batchDetails)),
	}
	for _, batchDetail := range batchDetails {
		if batchDetail == nil {
			continue
		}
		detail := &Detail{
			ID:     batchDetail.Id,
			RowNo:  batchDetail.RowNo,
			ICCID:  strings.TrimSpace(batchDetail.ItemId),
			Reason: strings.TrimSpace(batchDetail.ErrorReason),
		}
		if batchDetail.Snapshot != nil {
			if value := firstSnapshot(batchDetail.Snapshot, "ICCID", "iccid"); value != "" {
				detail.ICCID = value
			}
			detail.MSISDN = firstSnapshot(batchDetail.Snapshot, "MSISDN", "msisdn", "inputMsisdn", "input_msisdn")
			detail.IMSI = firstSnapshot(batchDetail.Snapshot, "IMSI", "imsi", "inputImsi", "input_imsi")
			detail.Authorized = batchDetail.Snapshot.Get("authorized").Bool()
		}
		task.Details = append(task.Details, detail)
	}
	if len(task.Details) == 0 {
		return nil, gerror.New("达量断网配置批次没有可读取明细")
	}
	if err = r.loadCards(ctx, task); err != nil {
		return nil, err
	}
	return task, nil
}

func firstSnapshot(snapshot *gjson.Json, keys ...string) string {
	if snapshot == nil {
		return ""
	}
	for _, key := range keys {
		if value := strings.TrimSpace(snapshot.Get(key).String()); value != "" {
			return value
		}
	}
	return ""
}

func (r *Repository) loadCards(ctx context.Context, task *Task) error {
	iccids := make([]string, 0, len(task.Details))
	for _, detail := range task.Details {
		if detail != nil && strings.TrimSpace(detail.ICCID) != "" {
			iccids = append(iccids, strings.TrimSpace(detail.ICCID))
		}
	}
	iccids = uniqueSortedStrings(iccids)
	if len(iccids) == 0 {
		return nil
	}

	var cards []*entity.TSimCardInfo
	columns := dao.TSimCardInfo.Columns()
	if err := r.database().Model(dao.TSimCardInfo.Table()).Safe().Ctx(ctx).
		Where(columns.TenantId, task.Batch.TenantID).
		WhereIn(columns.Iccid, iccids).
		Scan(&cards); err != nil {
		return gerror.Wrap(err, "查询SIM卡档案失败")
	}
	byICCID := make(map[string]*entity.TSimCardInfo, len(cards))
	for _, card := range cards {
		if card != nil {
			byICCID[strings.TrimSpace(card.Iccid)] = card
		}
	}
	for _, detail := range task.Details {
		if detail == nil {
			continue
		}
		card := byICCID[strings.TrimSpace(detail.ICCID)]
		if card == nil {
			continue
		}
		detail.Card = &Card{
			ID:                     card.Id,
			ICCID:                  strings.TrimSpace(card.Iccid),
			MSISDN:                 strings.TrimSpace(card.Msisdn),
			IMSI:                   strings.TrimSpace(card.Imsi),
			CurrentPackageCode:     strings.TrimSpace(card.CurrentPackageCode),
			PackageStatus:          card.PackageStatus,
			BossCardStatus:         card.BossCardStatus,
			IsFlowPool:             card.IsFlowPool,
			PackageTotalFlowMb:     card.PackageTotalFlowMb,
			TrafficCutoffStatus:    card.TrafficCutoffStatus,
			TrafficCutoffThreshold: card.TrafficCutoffThreshold,
		}
	}
	return nil
}

func (r *Repository) Commit(ctx context.Context, task *Task) error {
	if task == nil {
		return gerror.New("达量断网配置任务不能为空")
	}
	successCount, failCount := countResult(task)
	artifact, artifactErr := r.createResultFile(ctx, task)
	if artifactErr != nil {
		g.Log().Warningf(ctx, "traffic cutoff config result file generation failed, batchNo:%s, err:%+v", task.Batch.BatchNo, artifactErr)
	}

	now := gtime.Now()
	err := r.database().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		if successCount > 0 {
			if err := r.updateAllCardConfigs(ctx, tx, task); err != nil {
				return err
			}
		}
		if err := r.updateDetails(ctx, tx, task); err != nil {
			return err
		}

		var ossID, downloadID int64
		if artifactErr == nil {
			var err error
			ossID, downloadID, err = r.persistArtifact(ctx, tx, task, artifact, successCount, failCount, now)
			if err != nil {
				return err
			}
		}
		return r.finalizeBatch(ctx, tx, task, successCount, failCount, ossID, downloadID, now, artifactErr != nil)
	})
	if err != nil && artifactErr == nil && artifact.Path != "" {
		batchresult.RemoveLocalFile(artifact)
	}
	return gerror.Wrap(err, "保存达量断网配置批次结果失败")
}

func (r *Repository) updateAllCardConfigs(ctx context.Context, tx gdb.TX, task *Task) error {
	cardIDs := successDetailCardIDs(task.Details)
	if len(cardIDs) == 0 {
		return nil
	}
	columns := dao.TSimCardInfo.Columns()
	var lockedCards []*entity.TSimCardInfo
	model := tx.Ctx(ctx).Model(dao.TSimCardInfo.Table()).Safe().
		Fields(columns.Id).
		Where(columns.TenantId, task.Batch.TenantID).
		WhereIn(columns.Id, cardIDs)
	if err := r.applyLock(model).Scan(&lockedCards); err != nil {
		return gerror.Wrap(err, "锁定达量断网配置卡档案失败")
	}
	if len(lockedCards) != len(cardIDs) {
		return gerror.New("部分达量断网配置卡档案已发生变化")
	}
	_, err := tx.Ctx(ctx).Model(dao.TSimCardInfo.Table()).Safe().
		Where(columns.TenantId, task.Batch.TenantID).
		WhereIn(columns.Id, cardIDs).
		Data(trafficCutoffConfigData(task)).Update()
	if err != nil {
		return gerror.Wrap(err, "保存达量断网配置失败")
	}
	return nil
}

func (r *Repository) updateDetails(ctx context.Context, tx gdb.TX, task *Task) error {
	for _, detail := range task.Details {
		if detail == nil {
			continue
		}
		if err := r.updateDetail(ctx, tx, task, detail); err != nil {
			return err
		}
	}
	return nil
}

func (r *Repository) updateDetail(ctx context.Context, tx gdb.TX, task *Task, detail *Detail) error {
	status := consts.BatchDetailStatusFailed
	if detail.Success() {
		status = consts.BatchDetailStatusSuccess
	}
	result, err := tx.Ctx(ctx).Model(dao.BatchDetail.Table()).
		Where(dao.BatchDetail.Columns().Id, detail.ID).
		Where(dao.BatchDetail.Columns().BatchNo, task.Batch.BatchNo).
		Where(dao.BatchDetail.Columns().BatchType, consts.BatchTypeTrafficCutoffConfig).
		Where(dao.BatchDetail.Columns().DetailStatus, consts.BatchDetailStatusRunning).
		Data(do.BatchDetail{
			DetailStatus: status,
			ErrorReason:  detail.Reason,
			Snapshot:     detail.Snapshot(task.Config),
			UpdatedBy:    task.Batch.CreatedBy,
		}).Update()
	if err != nil {
		return gerror.Wrap(err, "更新达量断网配置批次明细失败")
	}
	affected, err := result.RowsAffected()
	if err != nil {
		return err
	}
	if affected != 1 {
		return gerror.Newf("达量断网配置批次明细%d已不是运行中状态", detail.ID)
	}
	return nil
}

func (r *Repository) finalizeBatch(ctx context.Context, tx gdb.TX, task *Task, successCount, failCount int, ossID, downloadID int64, now *gtime.Time, resultFileFailed bool) error {
	batchAsyncStatus, runResult := batchResult(successCount, failCount)
	result, err := tx.Ctx(ctx).Model(dao.BatchMain.Table()).
		Where(dao.BatchMain.Columns().BatchNo, task.Batch.BatchNo).
		Where(dao.BatchMain.Columns().BatchType, consts.BatchTypeTrafficCutoffConfig).
		Where(dao.BatchMain.Columns().BatchAsyncStatus, consts.BatchAsyncStatusProcessing).
		Data(do.BatchMain{
			BatchAsyncStatus: batchAsyncStatus,
			RunResult:        runResult,
			TotalCount:       len(task.Details),
			ValidCount:       successCount,
			SuccessCount:     successCount,
			FailCount:        failCount,
			FailReason:       task.FailureReason,
			BatchInfo:        mergeBatchInfo(task.Batch.BatchInfo, ossID, downloadID, resultFileFailed),
			EndTime:          now,
			UpdatedBy:        task.Batch.CreatedBy,
		}).Update()
	if err != nil {
		return gerror.Wrap(err, "更新达量断网配置批次主表失败")
	}
	affected, err := result.RowsAffected()
	if err != nil {
		return err
	}
	if affected != 1 {
		return gerror.New("达量断网配置批次已不是处理中状态")
	}
	return nil
}

func (r *Repository) createResultFile(ctx context.Context, task *Task) (batchresult.Artifact, error) {
	if r.results == nil {
		return batchresult.Artifact{}, gerror.New("result generator is not configured")
	}
	return r.results.Create(ctx, batchresult.Request{
		BatchNo:   task.Batch.BatchNo,
		BatchType: task.Batch.BatchType,
		TenantID:  task.Batch.TenantID,
		Rows:      task.ResultRows(),
	})
}

func (r *Repository) persistArtifact(ctx context.Context, tx gdb.TX, task *Task, artifact batchresult.Artifact, successCount, failCount int, now *gtime.Time) (int64, int64, error) {
	ossID, err := tx.Ctx(ctx).Model(dao.SysOss.Table()).Data(do.SysOss{
		TenantId:     task.Batch.TenantID,
		FileName:     artifact.FileName,
		OriginalName: artifact.OriginalName,
		FileSuffix:   artifact.FileSuffix,
		Path:         artifact.Path,
		Url:          artifact.URL,
		CreatedDept:  task.Batch.CreatedDept,
		CreatedBy:    task.Batch.CreatedBy,
		UpdatedBy:    task.Batch.CreatedBy,
		Service:      "local",
		Md5:          artifact.MD5,
		FileSize:     artifact.Size,
	}).InsertAndGetId()
	if err != nil {
		return 0, 0, gerror.Wrap(err, "写入达量断网配置结果文件OSS失败")
	}
	downloadID, err := tx.Ctx(ctx).Model(dao.TResourceBatchDownload.Table()).Data(do.TResourceBatchDownload{
		BatchNo:          task.Batch.BatchNo,
		TaskName:         batchresult.TaskName(task.Batch.BatchType),
		ResourceType:     consts.ResourceTypeExcel,
		ExportScene:      consts.BatchTypeTrafficCutoffConfig,
		TotalCount:       len(task.Details),
		SuccessCount:     successCount,
		FailCount:        failCount,
		DownloadStatus:   consts.DownloadStatusGenerated,
		OssId:            ossID,
		FileName:         artifact.FileName,
		FileExt:          artifact.FileSuffix,
		FileUrl:          artifact.URL,
		FilePath:         artifact.Path,
		FileSize:         artifact.Size,
		FileMd5:          artifact.MD5,
		DownloadCount:    0,
		MaxDownloadCount: 0,
		DeptId:           task.Batch.CreatedDept,
		StartTime:        task.Batch.StartTime,
		FinishTime:       now,
		TenantId:         task.Batch.TenantID,
		CreatedDept:      task.Batch.CreatedDept,
		CreatedBy:        task.Batch.CreatedBy,
		UpdatedBy:        task.Batch.CreatedBy,
	}).InsertAndGetId()
	if err != nil {
		return 0, 0, gerror.Wrap(err, "写入达量断网配置结果下载记录失败")
	}
	return ossID, downloadID, nil
}

func configFromBatchInfo(info *gjson.Json) (Config, error) {
	if info == nil || info.IsNil() {
		return Config{}, gerror.New("达量断网配置批次缺少批次参数")
	}
	status := info.Get("trafficCutoffStatus")
	if status.IsNil() {
		return Config{}, gerror.New("达量断网配置批次缺少trafficCutoffStatus")
	}
	config := Config{
		TrafficCutoffCrossMonthHold: info.Get("trafficCutoffCrossMonthHold").Int(),
		TrafficCutoffStatus:         status.Int(),
		TrafficCutoffThreshold:      info.Get("trafficCutoffThreshold").Float64(),
	}
	if config.TrafficCutoffStatus != 0 && config.TrafficCutoffStatus != 1 && config.TrafficCutoffStatus != 2 {
		return Config{}, gerror.New("达量断网启停状态无效")
	}
	if config.TrafficCutoffThreshold < 0 {
		return Config{}, gerror.New("达量断网阈值不能小于0")
	}
	if config.TrafficCutoffStatus == 0 && config.TrafficCutoffThreshold != 0 {
		return Config{}, gerror.New("未配置达量断网时阈值必须为0")
	}
	if config.TrafficCutoffStatus == 1 && config.TrafficCutoffThreshold <= 0 {
		return Config{}, gerror.New("开启达量断网时阈值必须大于0")
	}
	if config.TrafficCutoffCrossMonthHold != 0 && config.TrafficCutoffCrossMonthHold != 1 {
		return Config{}, gerror.New("invalid cross-month traffic cutoff hold value")
	}
	if config.TrafficCutoffStatus != 1 && config.TrafficCutoffCrossMonthHold != 0 {
		return Config{}, gerror.New("cross-month hold requires traffic cutoff to be enabled")
	}
	rounded := math.Round(config.TrafficCutoffThreshold*1000) / 1000
	if math.Abs(config.TrafficCutoffThreshold-rounded) > 0.0000001 {
		return Config{}, gerror.New("达量断网阈值最多保留3位小数")
	}
	return config, nil
}

func trafficCutoffConfigData(task *Task) do.TSimCardTrafficCutoffConfig {
	data := do.TSimCardTrafficCutoffConfig{
		TrafficCutoffStatus:         task.Config.TrafficCutoffStatus,
		TrafficCutoffThreshold:      task.Config.TrafficCutoffThreshold,
		TrafficCutoffCrossMonthHold: task.Config.TrafficCutoffCrossMonthHold,
		UpdatedBy:                   task.Batch.CreatedBy,
	}
	if task.Config.TrafficCutoffStatus != 1 || task.Config.TrafficCutoffCrossMonthHold == 0 {
		data.TrafficCutoffTriggeredAt = gdb.Raw("NULL")
	}
	return data
}

func mergeBatchInfo(info *gjson.Json, ossID, downloadID int64, resultFileFailed bool) *gjson.Json {
	data := make(map[string]any)
	if info != nil {
		for key, value := range info.Map() {
			data[key] = value
		}
	}
	if ossID > 0 {
		data["resultFileOssId"] = ossID
	}
	if resultFileFailed {
		data["resultFile"] = map[string]any{"status": "failed"}
	} else if downloadID > 0 {
		data["resultDownloadId"] = downloadID
		data["resultFile"] = map[string]any{"status": "generated"}
	} else {
		data["resultFile"] = map[string]any{"status": "skipped"}
	}
	return gjson.New(data)
}

func batchResult(successCount, failCount int) (int, int) {
	if failCount == 0 {
		return consts.BatchAsyncStatusSuccess, consts.BatchRunResultSuccess
	}
	if successCount > 0 {
		return consts.BatchAsyncStatusPartialSuccess, consts.BatchRunResultPartialSuccess
	}
	return consts.BatchAsyncStatusFailed, consts.BatchRunResultFailed
}

func successDetailCardIDs(details []*Detail) []int64 {
	ids := make([]int64, 0, len(details))
	seen := make(map[int64]struct{}, len(details))
	for _, detail := range details {
		if detail != nil && detail.Success() && detail.Card != nil && detail.Card.ID > 0 {
			if _, exists := seen[detail.Card.ID]; exists {
				continue
			}
			seen[detail.Card.ID] = struct{}{}
			ids = append(ids, detail.Card.ID)
		}
	}
	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
	return ids
}

func uniqueSortedStrings(values []string) []string {
	seen := make(map[string]struct{}, len(values))
	out := make([]string, 0, len(values))
	for _, value := range values {
		value = strings.TrimSpace(value)
		if value == "" {
			continue
		}
		if _, ok := seen[value]; ok {
			continue
		}
		seen[value] = struct{}{}
		out = append(out, value)
	}
	sort.Strings(out)
	return out
}