package cardobservation

import (
	"context"
	stderrors "errors"
	"strconv"
	"strings"
	"time"

	"gorm.io/gorm"

	cardapp "github.com/break/junhong_cmp_fiber/internal/application/cardobservation"
	carddomain "github.com/break/junhong_cmp_fiber/internal/domain/cardobservation"
	"github.com/break/junhong_cmp_fiber/internal/gateway"
	"github.com/break/junhong_cmp_fiber/internal/infrastructure/integrationlog"
	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/internal/store/postgres"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	apperrors "github.com/break/junhong_cmp_fiber/pkg/errors"
)

// SeriesAttemptLogger 将未发送的序列结果写入统一 Integration Log。
type SeriesAttemptLogger struct {
	repository *integrationlog.Repository
}

// NewSeriesAttemptLogger 创建未发送尝试日志适配器。
func NewSeriesAttemptLogger(repository *integrationlog.Repository) *SeriesAttemptLogger {
	return &SeriesAttemptLogger{repository: repository}
}

// Record 写入互斥、限频或提前完成结果。
func (l *SeriesAttemptLogger) Record(ctx context.Context, payload cardapp.SeriesTaskPayload, result, reason string) error {
	if l == nil || l.repository == nil {
		return apperrors.New(apperrors.CodeInternalError, "卡观测 Integration Log 未配置")
	}
	resourceID := payload.ResourceID
	source, scene, seriesID := payload.Source, payload.Scene, payload.SeriesID
	requestID, correlationID := optionalText(payload.RequestID), optionalText(payload.CorrelationID)
	_, err := l.repository.Start(ctx, integrationlog.Attempt{
		IntegrationID: unsentIntegrationID(payload), Provider: constants.IntegrationProviderGateway,
		Direction: constants.IntegrationDirectionOutbound, Operation: operationForSyncType(payload.SyncType),
		ResourceType: payload.ResourceType, ResourceID: &resourceID, TriggerSource: &source,
		TriggerScene: &scene, TriggerSeries: &seriesID, ScheduledAt: &payload.ScheduledAt,
		Attempt: payload.Attempt, InitialResult: result, RequestID: requestID, CorrelationID: correlationID,
		Metadata: map[string]any{"reason": reason, "sync_type": payload.SyncType},
	})
	return err
}

// RecordMerged 记录同场景重复触发被合并，不创建第二组三任务。
func (l *SeriesAttemptLogger) RecordMerged(ctx context.Context, request cardapp.SeriesRequest, seriesID string) error {
	resourceID := request.ResourceID
	source, scene := request.Source, request.Scene
	now := time.Now().UTC()
	_, err := l.repository.Start(ctx, integrationlog.Attempt{
		Provider: constants.IntegrationProviderGateway, Direction: constants.IntegrationDirectionOutbound,
		Operation: operationForSyncType(request.SyncType), ResourceType: request.ResourceType,
		ResourceID: &resourceID, TriggerSource: &source, TriggerScene: &scene, TriggerSeries: &seriesID,
		ScheduledAt: &now, Attempt: 1, InitialResult: constants.IntegrationResultMerged,
		RequestID: optionalText(request.RequestID), CorrelationID: optionalText(request.CorrelationID),
		Metadata: map[string]any{"reason": "同场景未结束序列已存在", "sync_type": request.SyncType},
	})
	return err
}

// SeriesRunner 负责卡本地预期判断、Gateway 查询和公共观测应用。
type SeriesRunner struct {
	db          *gorm.DB
	gateway     *gateway.Client
	observation *cardapp.Service
	integration *integrationlog.Repository
	carrier     *postgres.CarrierStore
}

// NewSeriesRunner 创建卡观测序列 Gateway 执行器。
func NewSeriesRunner(db *gorm.DB, gatewayClient *gateway.Client, observation *cardapp.Service, integration *integrationlog.Repository) *SeriesRunner {
	return &SeriesRunner{db: db, gateway: gatewayClient, observation: observation, integration: integration, carrier: postgres.NewCarrierStore(db)}
}

// Provider 返回用于请求互斥的运营商接入标识。
func (r *SeriesRunner) Provider(ctx context.Context, payload cardapp.SeriesTaskPayload) (string, error) {
	card, err := r.loadCard(ctx, payload)
	if err != nil {
		return "", err
	}
	provider := strings.ToLower(strings.TrimSpace(card.CarrierType))
	if provider == "" {
		provider = "carrier-" + strconv.FormatUint(uint64(card.CarrierID), 10)
	}
	return provider, nil
}

// ExpectationMet 在访问 Gateway 前读取本地权威快照。
func (r *SeriesRunner) ExpectationMet(ctx context.Context, payload cardapp.SeriesTaskPayload) (bool, error) {
	expected := strings.ToLower(strings.TrimSpace(payload.ExpectedValue))
	if expected == "" {
		return false, nil
	}
	card, err := r.loadCard(ctx, payload)
	if err != nil {
		return false, err
	}
	switch payload.SyncType {
	case constants.CardObservationSyncTypeRealname:
		return (expected == "verified" || expected == "1") && card.RealNameStatus == constants.RealNameStatusVerified, nil
	case constants.CardObservationSyncTypeNetwork:
		if expected == "online" || expected == "1" {
			return card.NetworkStatus == constants.NetworkStatusOnline, nil
		}
		if expected == "offline" || expected == "stopped" || expected == "0" {
			return card.NetworkStatus == constants.NetworkStatusOffline, nil
		}
	}
	return false, nil
}

// Run 执行一次 Gateway 查询，并将结果交给公共卡观测应用服务。
func (r *SeriesRunner) Run(ctx context.Context, payload cardapp.SeriesTaskPayload) (cardapp.RunResult, error) {
	if r == nil || r.db == nil || r.gateway == nil || r.observation == nil || r.integration == nil {
		return cardapp.RunResult{}, apperrors.New(apperrors.CodeInternalError, "卡观测序列 Gateway 能力未完整配置")
	}
	card, err := r.loadCard(ctx, payload)
	if err != nil {
		return cardapp.RunResult{}, err
	}
	attempt, err := r.startAttempt(ctx, payload, card)
	if err != nil {
		return cardapp.RunResult{}, err
	}
	startedAt := time.Now()
	result, runErr := r.queryAndApply(ctx, payload, card, attempt.IntegrationID)
	completionResult := constants.IntegrationResultSuccess
	if runErr != nil {
		completionResult = constants.IntegrationResultFailed
		if isRateLimited(runErr) {
			completionResult = constants.IntegrationResultRateLimited
			result.RateLimited = true
		}
	}
	_, completeErr := r.integration.Complete(ctx, attempt.IntegrationID, integrationlog.Completion{
		Result: completionResult, DurationMS: time.Since(startedAt).Milliseconds(), StateChanged: result.StateChanged,
		ResponseSummary: map[string]any{"sync_type": payload.SyncType, "applied": runErr == nil},
	})
	if completeErr != nil {
		return result, completeErr
	}
	return result, runErr
}

func (r *SeriesRunner) startAttempt(ctx context.Context, payload cardapp.SeriesTaskPayload, card *model.IotCard) (*model.IntegrationLog, error) {
	resourceID, source, scene, seriesID := payload.ResourceID, payload.Source, payload.Scene, payload.SeriesID
	resourceKey := "card:" + formatCardID(card.ID)
	return r.integration.Start(ctx, integrationlog.Attempt{
		IntegrationID: gatewayIntegrationID(payload), Provider: constants.IntegrationProviderGateway,
		Direction: constants.IntegrationDirectionOutbound, Operation: operationForSyncType(payload.SyncType),
		ResourceType: payload.ResourceType, ResourceID: &resourceID, ResourceKey: &resourceKey,
		TriggerSource: &source, TriggerScene: &scene, TriggerSeries: &seriesID,
		ScheduledAt: &payload.ScheduledAt, Attempt: payload.Attempt,
		RequestSummary: map[string]any{"card_id": card.ID, "sync_type": payload.SyncType},
		RequestID:      optionalText(payload.RequestID), CorrelationID: optionalText(payload.CorrelationID),
	})
}

func (r *SeriesRunner) queryAndApply(ctx context.Context, payload cardapp.SeriesTaskPayload, card *model.IotCard, observationID string) (cardapp.RunResult, error) {
	metadata := carddomain.ObservationMetadata{
		ObservationID: observationID, Source: constants.CardObservationSourceBusinessEvent,
		Scene: payload.Scene, ObservedAt: time.Now().UTC(), RequestID: payload.RequestID,
		CorrelationID: payload.CorrelationID,
	}
	switch payload.SyncType {
	case constants.CardObservationSyncTypeRealname:
		response, err := r.gateway.QueryRealnameStatus(ctx, &gateway.CardStatusReq{CardNo: card.ICCID})
		if err != nil {
			return cardapp.RunResult{}, err
		}
		decision, err := r.observation.ApplyCardObservation(ctx, carddomain.RealnameObservation{CardID: card.ID, Verified: response.RealStatus, Metadata: metadata})
		return cardapp.RunResult{StateChanged: decision.StatusChanged}, err
	case constants.CardObservationSyncTypeTraffic:
		response, err := r.gateway.QueryFlow(ctx, &gateway.FlowQueryReq{CardNo: card.ICCID})
		if err != nil {
			return cardapp.RunResult{}, err
		}
		decision, err := r.observation.ApplyTrafficObservation(ctx, carddomain.TrafficObservation{
			CardID: card.ID, GatewayReadingMB: float64(response.Used), ResetDay: r.carrier.GetDataResetDay(ctx, card.CarrierID), Metadata: metadata,
		})
		return cardapp.RunResult{StateChanged: decision.IncrementMB > 0 || decision.CrossMonth}, err
	case constants.CardObservationSyncTypeNetwork:
		response, err := r.gateway.QueryCardStatus(ctx, &gateway.CardStatusReq{CardNo: card.ICCID})
		if err != nil {
			return cardapp.RunResult{}, err
		}
		decision, err := r.observation.ApplyNetworkObservation(ctx, carddomain.NetworkObservation{
			CardID: card.ID, GatewayStatus: response.CardStatus, GatewayExtend: response.Extend,
			GatewayIMEI: response.IMEI, Metadata: metadata,
		})
		return cardapp.RunResult{StateChanged: decision.StatusChanged}, err
	default:
		return cardapp.RunResult{}, apperrors.New(apperrors.CodeInvalidParam, "设备信息观测执行器尚未注册")
	}
}

func (r *SeriesRunner) loadCard(ctx context.Context, payload cardapp.SeriesTaskPayload) (*model.IotCard, error) {
	if payload.ResourceType != constants.CardObservationResourceTypeCard {
		return nil, apperrors.New(apperrors.CodeInvalidParam, "当前观测执行器仅支持 IoT 卡资源")
	}
	cardID, err := strconv.ParseUint(payload.ResourceID, 10, 64)
	if err != nil || cardID == 0 {
		return nil, apperrors.New(apperrors.CodeInvalidParam, "卡观测资源 ID 无效")
	}
	var card model.IotCard
	if err := r.db.WithContext(ctx).Where("id = ?", uint(cardID)).First(&card).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, apperrors.New(apperrors.CodeNotFound, "IoT卡不存在")
		}
		return nil, apperrors.Wrap(apperrors.CodeDatabaseError, err, "查询卡观测本地快照失败")
	}
	return &card, nil
}

func isRateLimited(err error) bool {
	var appErr *apperrors.AppError
	if stderrors.As(err, &appErr) && appErr.Code == apperrors.CodeTooManyRequests {
		return true
	}
	return strings.Contains(err.Error(), "429") || strings.Contains(strings.ToLower(err.Error()), "rate limit")
}

func operationForSyncType(syncType string) string {
	switch syncType {
	case constants.CardObservationSyncTypeRealname:
		return constants.IntegrationOperationGatewayRealname
	case constants.CardObservationSyncTypeTraffic:
		return constants.IntegrationOperationGatewayTraffic
	case constants.CardObservationSyncTypeNetwork:
		return constants.IntegrationOperationGatewayNetwork
	default:
		return "query_device_info"
	}
}

func gatewayIntegrationID(payload cardapp.SeriesTaskPayload) string {
	return "card-series:" + payload.SeriesID + ":" + strconv.Itoa(payload.Attempt)
}

func unsentIntegrationID(payload cardapp.SeriesTaskPayload) string {
	return gatewayIntegrationID(payload) + ":unsent"
}

func optionalText(value string) *string {
	value = strings.TrimSpace(value)
	if value == "" {
		return nil
	}
	return &value
}

var _ cardapp.SeriesAttemptLogger = (*SeriesAttemptLogger)(nil)
var _ cardapp.SeriesRunner = (*SeriesRunner)(nil)