ANTOOZA-BACKEND/Application/Features/Admin/Payment/Toss/Confirm/Cancel/Handler.cs

using Application.Abstractions.Data;
using Application.Abstractions.Messaging;
using Application.Abstractions.Payment;
using Domain.Entities.Common.ValueObject;
using Domain.Entities.Payments;
using Domain.Entities.Payments.Toss;
using Domain.Entities.Payments.Toss.ValueObject;
using Domain.Entities.Payments.ValueObject;
using Domain.Entities.Wallets.ValueObject;
using Microsoft.EntityFrameworkCore;
using SharedKernel.Results;

namespace Application.Features.Admin.Payment.Toss.Confirm.Cancel;

/// <summary>운영자 강제취소 — 토스 취소 API 로 전체 취소 (Phase 1.5 계약 승계)</summary>
public sealed class Handler(
    IAppDbContext db,
    ITossPaymentService tossPay,
    IAppDbContextFactory dbFactory
) : ICommandHandler<Command, Result>
{
    public async Task<Result> Handle(Command request, CancellationToken ct)
    {
        var confirm = await db.TossConfirm.FirstOrDefaultAsync(c => c.ID == request.ID, ct);
        if (confirm is null)
        {
            return Result.Failure(Error.NotFound("Toss.ConfirmNotFound", "결제 내역을 찾을 수 없습니다."));
        }

        var order = await db.PaymentOrder.FirstOrDefaultAsync(c => c.ID == confirm.PaymentOrderID, ct);
        if (order is null)
        {
            return Result.Failure(Error.NotFound("Payment.OrderNotFound", "주문을 찾을 수 없습니다."));
        }

        // 진실의 근원은 PaymentOrder.Status — TossConfirm 응답이 비정상이어도
        // PG 측에 실제 결제가 잡혀있다면(=Paid) 운영자 강제 환불이 필요.
        if (order.Status != PaymentStatus.Paid)
        {
            return Result.Failure(Error.Problem("Payment.InvalidStatusForCancel", "취소할 수 없는 주문 상태입니다."));
        }

        // 이미 성공 취소된 경우 방지
        var hasSuccessfulCancel = await db.TossCancel.AnyAsync(c => c.PaymentOrderID == order.ID && c.ResponseCode == "SUCCESS", ct);
        if (hasSuccessfulCancel)
        {
            return Result.Failure(Error.Problem("Toss.AlreadyCancelled", "이미 결제가 취소되었습니다."));
        }

        // paymentKey 확보 — MarkPaid 시 TransactionID 에 저장됨. 없으면 TossConfirm 에서 보강.
        var paymentKey = string.IsNullOrEmpty(order.TransactionID) ? confirm.PaymentKey : order.TransactionID;

        // 환불 가능성 선검증 — PG 취소 성공 후 지갑 회수가 실패하면 PG-지갑 desync 가 되므로
        // 지갑 존재와 충전 잔액(PgCharged)을 PG 호출 전에 확정한다. (API Cancel 핸들러와 동일 패턴)
        var wallet = await db.Wallet.Include(w => w.Balances).Include(w => w.Transactions).AsSplitQuery().FirstOrDefaultAsync(w => w.MemberID == order.MemberID, ct);
        if (wallet is null)
        {
            return Result.Failure(Error.NotFound("Payment.WalletNotFound", "지갑 정보를 찾을 수 없습니다."));
        }

        var pgCharged = wallet.Balances.Where(b => b.Type == WalletBalanceType.PgCharged).Sum(b => b.Amount.Value);
        if (pgCharged < order.PointAmount)
        {
            return Result.Failure(Error.Problem("Payment.PointAlreadySpent", "회원이 이미 사용한 캐시가 있어 결제를 취소할 수 없습니다. 수동 조정이 필요합니다."));
        }

        var cancelReason = string.IsNullOrWhiteSpace(request.CancelReason) ? "운영자 강제취소" : request.CancelReason;

        // 취소 요청 기록 저장 (전체 취소)
        var cancel = TossCancel.CreateRequest(order.MemberID, order.ID, paymentKey, order.OrderID, order.Amount, cancelReason, request.CancelRequester ?? "admin");

        await db.TossCancel.AddAsync(cancel, ct);
        await db.SaveChangesAsync(ct);

        // 토스 취소 API 호출 (cancelAmount 미전달 = 전액 취소) — 통신 예외도 기록을 남긴다
        TossPaymentResult result;
        try
        {
            result = await tossPay.CancelAsync(paymentKey, cancelReason, null, ct);
        }
        catch (Exception ex)
        {
            cancel.SetError("EXCEPTION", ex.Message);

            await db.TossLog.AddAsync(TossLog.Create(order.MemberID, TossLogType.Error, "EXCEPTION", ex.Message, paymentKey, order.OrderID), ct);
            await db.SaveChangesAsync(ct);

            return Result.Failure(Error.Problem("Toss.CancelFailed", "결제 취소 처리 중 오류가 발생했습니다."));
        }

        if (!result.Success)
        {
            cancel.SetError(result.Code ?? "FAIL", result.Message ?? "취소 실패");

            await db.TossLog.AddAsync(TossLog.Create(order.MemberID, TossLogType.Failed, result.Code ?? "FAIL", result.Message ?? "취소 실패", paymentKey, order.OrderID), ct);
            await db.SaveChangesAsync(ct);

            return Result.Failure(Error.Problem("Toss.CancelFailed", result.Message ?? "결제 취소에 실패했습니다."));
        }

        // 취소 응답 저장
        ApplyCancelResponse(cancel, result);

        order.MarkCancelled();

        // 충전분(PgCharged) 회수 — ChargeCancelled 원장 기록으로 출처를 보존한다.
        // 잔액은 위에서 선검증했으므로 여기서 예외를 흡수하지 않는다.
        // 주문 취소 + 회수는 단일 SaveChanges 원자 커밋 (실패 시 부분 반영 없음)
        wallet.DebitChargeCancel(Money.KRW(order.PointAmount), "결제 취소 환불(운영자)", order.OrderID);

        try
        {
            await db.SaveChangesAsync(ct);
        }
        catch (DbUpdateConcurrencyException ex)
        {
            // Phase 1.5: WalletBalance rowversion 동시성 충돌 — 오염된 컨텍스트는 버리고(커밋된 것 없음)
            // 새 컨텍스트로 리로드해 도메인 연산을 1회 재적용한다. 첫 시도의 원장 기록은 미영속이므로 이중회수 없음.
            try
            {
                return await RetryCancelPersistAsync(order.ID, cancel.ID, result, ct);
            }
            catch (Exception retryEx)
            {
                await TryWriteReconcileLogAsync(order.ID, paymentKey, order.PointAmount, $"ADMIN_CANCEL_PERSIST 재시도 실패: {retryEx.Message} (동시성 충돌: {ex.Message})");
                throw;
            }
        }
        catch (Exception ex)
        {
            // Phase 1.5: PG 취소는 성공했는데 저장 실패 — 별도 컨텍스트로 대사 로그를 독립 커밋한 뒤
            // 기존 실패 흐름(예외 전파)을 유지한다.
            await TryWriteReconcileLogAsync(order.ID, paymentKey, order.PointAmount, $"ADMIN_CANCEL_PERSIST 실패: {ex.Message}");
            throw;
        }

        return Result.Success();
    }

    /// <summary>동시성 충돌 1회 재시도 — 새 컨텍스트로 리로드 후 취소 반영을 재적용한다. (Phase 1.5)</summary>
    private async Task<Result> RetryCancelPersistAsync(int paymentOrderID, int cancelID, TossPaymentResult result, CancellationToken ct)
    {
        await using var retryDb = dbFactory.CreateDbContext();

        var order = await retryDb.PaymentOrder.FirstAsync(c => c.ID == paymentOrderID, ct);
        if (order.Status == PaymentStatus.Cancelled)
        {
            // 동시 요청이 이미 취소 반영을 끝낸 경우 — 이중회수 금지, idempotent 성공 응답
            return Result.Success();
        }

        var cancel = await retryDb.TossCancel.FirstAsync(c => c.ID == cancelID, ct);
        ApplyCancelResponse(cancel, result);

        var wallet = await retryDb.Wallet.Include(w => w.Balances).Include(w => w.Transactions).AsSplitQuery().FirstAsync(w => w.MemberID == order.MemberID, ct);

        order.MarkCancelled();

        // 리로드된 실제 잔액 기준 회수 — 충돌 사이에 캐시가 사용됐다면 Decrease 예외 → 호출부가 대사 로그를 남긴다
        // (PG 환불은 이미 완료 — 자동 회수 불가, 운영자 수동 대사 대상)
        wallet.DebitChargeCancel(Money.KRW(order.PointAmount), "결제 취소 환불(운영자)", order.OrderID);

        await retryDb.SaveChangesAsync(ct);

        return Result.Success();
    }

    /// <summary>대사 로그 독립 커밋 — best-effort. 로그 실패가 원래 실패 흐름을 가리면 안 된다. (Phase 1.5)</summary>
    private async Task TryWriteReconcileLogAsync(int paymentOrderID, string? paymentKey, int amount, string reason)
    {
        try
        {
            // 호출측 취소와 무관하게 반드시 남아야 하므로 CancellationToken.None
            await using var logDb = dbFactory.CreateDbContext();
            await logDb.PaymentReconcileLog.AddAsync(PaymentReconcileLog.Create(ReconcileKind.AdminCancel, paymentOrderID, paymentKey, amount, reason), CancellationToken.None);
            await logDb.SaveChangesAsync(CancellationToken.None);
        }
        catch
        {
            // best-effort — 원래 예외를 유지한다
        }
    }

    private static void ApplyCancelResponse(TossCancel cancel, TossPaymentResult result)
    {
        var last = result.Cancels.Count > 0 ? result.Cancels[^1] : null;
        cancel.SetResponse(result.Status ?? "", last?.TransactionKey, last?.CanceledAt, result.RawJson);
    }
}