package approval

import (
	"context"
	approvalapp "github.com/break/junhong_cmp_fiber/internal/application/approval"
	"github.com/break/junhong_cmp_fiber/internal/infrastructure/messaging/outbox"
	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"strconv"
	"time"
)

// RecoveryPort 将恢复请求限制为本地任务入队与事件状态转换。
type RecoveryPort struct{ outbox *outbox.Repository }

func NewRecoveryPort(_ *gorm.DB, _ ...any) *RecoveryPort {
	return &RecoveryPort{outbox: outbox.NewRepository()}
}
func (r *RecoveryPort) EnqueueSubmittedSync(ctx context.Context, tx *gorm.DB, instanceID uint) error {
	return r.enqueueSync(ctx, tx, instanceID)
}
func (r *RecoveryPort) EnqueueUnknownConfirm(ctx context.Context, tx *gorm.DB, instanceID uint) error {
	return r.enqueueUnknown(ctx, tx, instanceID)
}
func (r *RecoveryPort) enqueueSync(ctx context.Context, tx *gorm.DB, instanceID uint) error {
	var instance model.ApprovalInstance
	if err := tx.WithContext(ctx).Where("id = ? AND business_type = ?", instanceID, constants.ApprovalBusinessTypeRefund).First(&instance).Error; err != nil {
		return gorm.ErrInvalidData
	}
	var context model.WeComApprovalContext
	if err := tx.WithContext(ctx).Where("approval_instance_id = ? AND business_type = ?", instanceID, constants.ApprovalBusinessTypeRefund).First(&context).Error; err != nil || context.SPNo == "" || context.SubmissionStatus != constants.WeComSubmissionStatusSubmitted {
		return gorm.ErrInvalidData
	}
	id := strconv.FormatUint(uint64(instanceID), 10)
	payload := map[string]any{"instance_id": instanceID, "application_id": context.ApplicationID, "sp_no": context.SPNo}
	_, err := r.outbox.AppendIdempotent(ctx, tx, outbox.Envelope{EventID: "approval:" + id + ":manual-sync", EventType: constants.OutboxEventTypeApprovalManualSyncRequested, PayloadVersion: 1, AggregateType: "approval", AggregateID: id, ResourceType: instance.BusinessType, ResourceID: strconv.FormatUint(uint64(instance.BusinessID), 10), Payload: payload})
	return err
}
func (r *RecoveryPort) enqueueUnknown(ctx context.Context, tx *gorm.DB, instanceID uint) error {
	var instance model.ApprovalInstance
	if err := tx.WithContext(ctx).Where("id = ? AND business_type = ?", instanceID, constants.ApprovalBusinessTypeRefund).First(&instance).Error; err != nil || instance.Status != constants.ApprovalStatusSubmissionUnknown {
		return gorm.ErrInvalidData
	}
	var context model.WeComApprovalContext
	if err := tx.WithContext(ctx).Where("approval_instance_id = ? AND business_type = ?", instanceID, constants.ApprovalBusinessTypeRefund).First(&context).Error; err != nil || context.SubmissionStatus != constants.WeComSubmissionStatusUnknown || context.SPNo != "" {
		return gorm.ErrInvalidData
	}
	id := strconv.FormatUint(uint64(instanceID), 10)
	_, err := r.outbox.AppendIdempotent(ctx, tx, outbox.Envelope{EventID: "approval:" + id + ":unknown-recovery", EventType: constants.OutboxEventTypeApprovalUnknownRecoveryRequested, PayloadVersion: 1, AggregateType: "approval", AggregateID: id, ResourceType: instance.BusinessType, ResourceID: strconv.FormatUint(uint64(instance.BusinessID), 10), Payload: map[string]any{"instance_id": instanceID}})
	return err
}
func (r *RecoveryPort) RecoverSubmissionEvent(ctx context.Context, tx *gorm.DB, instanceID uint) (bool, error) {
	if tx == nil || instanceID == 0 {
		return false, gorm.ErrInvalidData
	}
	var instance model.ApprovalInstance
	if err := tx.WithContext(ctx).First(&instance, instanceID).Error; err != nil {
		return false, err
	}
	if instance.Status != constants.ApprovalStatusSubmissionFailed {
		return false, gorm.ErrInvalidData
	}
	var context model.WeComApprovalContext
	if err := tx.WithContext(ctx).Where("approval_instance_id = ?", instanceID).First(&context).Error; err != nil || context.SubmissionStatus != constants.WeComSubmissionStatusFailed || context.SPNo != "" {
		return false, gorm.ErrInvalidData
	}
	eventID := "approval:" + strconv.FormatUint(uint64(instanceID), 10) + ":submission"
	var event model.OutboxEvent
	if err := tx.WithContext(ctx).Clauses(clause.Locking{Strength: "UPDATE"}).Where("event_id = ?", eventID).First(&event).Error; err != nil {
		return false, err
	}
	id := strconv.FormatUint(uint64(instanceID), 10)
	rid := strconv.FormatUint(uint64(instance.BusinessID), 10)
	if event.EventType != constants.OutboxEventTypeApprovalSubmissionRequested || event.AggregateType != "approval" || event.AggregateID != id || event.ResourceType != instance.BusinessType || event.ResourceID != rid {
		return false, gorm.ErrInvalidData
	}
	if event.Status == constants.OutboxStatusPending || event.Status == constants.OutboxStatusDelivering {
		return false, nil
	}
	if event.Status != constants.OutboxStatusFailed && event.Status != constants.OutboxStatusDelivered {
		return false, nil
	}
	result := tx.WithContext(ctx).Model(&model.OutboxEvent{}).Where("id = ? AND status IN ?", event.ID, []int{constants.OutboxStatusFailed, constants.OutboxStatusDelivered}).Updates(map[string]any{"status": constants.OutboxStatusPending, "next_attempt_at": time.Now().UTC(), "last_error_code": "", "last_error_summary": "", "lease_owner": nil, "lease_expires_at": nil, "delivered_at": nil, "updated_at": time.Now().UTC()})
	return result.RowsAffected == 1, result.Error
}

var _ approvalapp.RecoveryPort = (*RecoveryPort)(nil)