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;
using Microsoft.EntityFrameworkCore;

namespace Application.Features.Api.Payment.Toss.Confirm;

internal sealed class Handler(
    IAppDbContext db,
    ITossPaymentService tossPay,
    IAppDbContextFactory dbFactory
) : ICommandHandler<Command, Response>
{
    public async Task<Response> Handle(Command r, CancellationToken ct)
    {
        // 주문 조회
        var order = await db.PaymentOrder.FirstOrDefaultAsync(c => c.OrderID == r.OrderID, ct);
        if (order is null)
        {
            return new Response(false, "", 0, "주문을 찾을 수 없습니다.", null);
        }

        // 이미 결제 완료된 주문인 경우 중복 승인 방지 (idempotent 응답)
        if (order.Status == PaymentStatus.Paid && order.MemberID == r.MemberID)
        {
            return new Response(true, order.Status.ToString(), order.PointAmount, "이미 충전이 완료된 주문입니다.", order.PaidAt);
        }

        // 회원 검증 — 불일치 시 주문 상태를 건드리지 않는다 (남의 주문 오염 공격 차단)
        if (order.MemberID != r.MemberID)
        {
            return new Response(false, order.Status.ToString(), 0, "주문 정보가 일치하지 않습니다.", null);
        }

        // 금액 검증 — 클라이언트 전달 amount 와 서버 저장 주문 금액 불일치 시 즉시 실패 (변조 차단, PG 호출 전)
        if (r.Amount != order.Amount)
        {
            await db.TossLog.AddAsync(TossLog.Create(r.MemberID, TossLogType.Failed, "AMOUNT_MISMATCH", $"금액 불일치: 요청={r.Amount}, 주문={order.Amount}", r.PaymentKey, r.OrderID), ct);
            await db.SaveChangesAsync(ct);

            return new Response(false, order.Status.ToString(), 0, "결제 금액이 주문 금액과 일치하지 않습니다.", null);
        }

        // 승인 가능 상태 가드 — Failed/Cancelled 재진입 차단, NeedsReconciliation 은 재확인(재승인) 경로 허용 (Phase 1.5)
        if (order.Status is not PaymentStatus.Pending and not PaymentStatus.WaitingDeposit and not PaymentStatus.NeedsReconciliation)
        {
            return new Response(false, order.Status.ToString(), 0, "승인할 수 없는 주문 상태입니다.", null);
        }

        // 승인 요청 기록 저장 — TossConfirm 은 PaymentKey/OrderID unique 라 주문당 1행.
        // 재확인(NeedsReconciliation, 또는 저장 실패 후 재시도)이면 기존 행을 재사용해 인덱스 충돌을 피한다. (Phase 1.5)
        var confirm = await db.TossConfirm.FirstOrDefaultAsync(c => c.PaymentOrderID == order.ID, ct);
        if (confirm is null)
        {
            confirm = TossConfirm.CreateRequest(r.MemberID, order.ID, r.PaymentKey, r.OrderID, order.Amount);
            await db.TossConfirm.AddAsync(confirm, ct);
        }
        else
        {
            confirm.PrepareRetry(r.PaymentKey);
        }

        await db.SaveChangesAsync(ct);

        // 토스 승인 API 호출 — 서버 저장 금액 사용 (클라이언트 amount 는 검증용으로만)
        TossPaymentResult result;
        try
        {
            result = await tossPay.ConfirmAsync(r.PaymentKey, r.OrderID, order.Amount, ct);
        }
        catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
        {
            // 통신 불명(타임아웃 등) — 토스가 실제 승인했을 수 있어 Failed 로 단정하지 않고 대사 대상으로 표시. (Phase 1.5)
            // 호출측 취소와 무관하게 상태가 반드시 남아야 하므로 CancellationToken.None 으로 저장한다.
            confirm.SetError("EXCEPTION", ex.Message);
            order.MarkNeedsReconciliation("승인 통신 불명(타임아웃)");

            await db.TossLog.AddAsync(TossLog.Create(r.MemberID, TossLogType.Error, "EXCEPTION", ex.Message, r.PaymentKey, r.OrderID), CancellationToken.None);
            await db.SaveChangesAsync(CancellationToken.None);

            // 자동 대사 배치가 참조할 수 있게 대사 로그 독립 커밋
            await TryWriteReconcileLogAsync(order.ID, r.PaymentKey, order.PointAmount, $"CONFIRM 통신 불명: {ex.Message}");

            return new Response(false, order.Status.ToString(), 0, "결제 승인 확인이 지연되고 있습니다. 잠시 후 다시 시도해주세요.", null);
        }
        catch (Exception ex)
        {
            // 통신 이외의 예외(설정 오류 등)는 Failed — Pending 방치를 막는다
            confirm.SetError("EXCEPTION", ex.Message);
            order.MarkFailed("승인 처리 오류");

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

            return new Response(false, order.Status.ToString(), 0, "결제 처리 중 오류가 발생했습니다.", null);
        }

        if (!result.Success)
        {
            // 토스의 명시적 거절 응답 {code, message} — 불명이 아니므로 Failed
            confirm.SetError(result.Code ?? "FAIL", result.Message ?? "승인 실패");
            order.MarkFailed(result.Message ?? "승인 실패");

            await db.TossLog.AddAsync(TossLog.Create(r.MemberID, TossLogType.Failed, result.Code ?? "FAIL", result.Message ?? "승인 실패", r.PaymentKey, r.OrderID), ct);
            await db.SaveChangesAsync(ct);

            return new Response(false, order.Status.ToString(), 0, result.Message ?? "결제 승인에 실패했습니다.", null);
        }

        // 가상계좌 — 승인 응답 status=WAITING_FOR_DEPOSIT 는 입금 대기. 이 시점에 지갑 적립 금지,
        // DEPOSIT_CALLBACK 웹훅 후 조회 API 로 DONE 확인 후 적립한다.
        if (result.Status == "WAITING_FOR_DEPOSIT")
        {
            ApplyConfirmResponse(confirm, result);
            order.MarkWaitingDeposit(result.VirtualAccountNumber ?? "", result.VirtualAccountBankCode ?? "", result.VirtualAccountHolder ?? "", result.VirtualAccountDueDate ?? DateTime.UtcNow.AddDays(7));

            await db.SaveChangesAsync(ct);

            return new Response(true, order.Status.ToString(), 0, "가상계좌가 발급되었습니다. 입금 확인 후 충전됩니다.", null);
        }

        if (result.Status != "DONE")
        {
            // HTTP 성공인데 DONE/WAITING_FOR_DEPOSIT 이 아닌 상태 — 단정하지 않고 대사 대상 (보수적)
            ApplyConfirmResponse(confirm, result);
            order.MarkNeedsReconciliation($"승인 응답 상태 불명: {result.Status}");

            await db.SaveChangesAsync(ct);
            await TryWriteReconcileLogAsync(order.ID, r.PaymentKey, order.PointAmount, $"CONFIRM 응답 상태 불명: {result.Status}");

            return new Response(false, order.Status.ToString(), 0, "결제 상태 확인이 필요합니다. 잠시 후 다시 확인해주세요.", null);
        }

        // 응답 저장
        ApplyConfirmResponse(confirm, result);

        // 지갑에 캐시 충전 — 지갑이 없으면 생성해 승인 결과 유실을 막는다 (PG 는 이미 승인됨)
        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)
        {
            wallet = Wallet.Create(order.MemberID);
            await db.Wallet.AddAsync(wallet, ct);
        }

        wallet.CreditPgCharge(Money.KRW(order.PointAmount), "캐시 충전 (Toss)", order.OrderID);

        // 주문 상태 갱신 — 지갑 적립(CreditPgCharge)과 단일 SaveChanges 로 원자 커밋 (실패 시 부분 반영 없음)
        order.MarkPaid(r.PaymentKey);

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

        return new Response(true, order.Status.ToString(), order.PointAmount, "충전이 완료되었습니다.", order.PaidAt);
    }

    /// <summary>동시성 충돌 1회 재시도 — 새 컨텍스트로 리로드 후 승인 반영을 재적용한다. (Phase 1.5)</summary>
    private async Task<Response> RetryConfirmPersistAsync(int paymentOrderID, int confirmID, string paymentKey, 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.Paid)
        {
            // 동시 요청이 이미 승인 반영을 끝낸 경우 — 이중적립 금지, idempotent 성공 응답
            return new Response(true, order.Status.ToString(), order.PointAmount, "이미 충전이 완료된 주문입니다.", order.PaidAt);
        }

        var confirm = await retryDb.TossConfirm.FirstAsync(c => c.ID == confirmID, ct);
        ApplyConfirmResponse(confirm, result);

        var wallet = await retryDb.Wallet.Include(w => w.Balances).Include(w => w.Transactions).AsSplitQuery().FirstOrDefaultAsync(w => w.MemberID == order.MemberID, ct);
        if (wallet is null)
        {
            wallet = Wallet.Create(order.MemberID);
            await retryDb.Wallet.AddAsync(wallet, ct);
        }

        wallet.CreditPgCharge(Money.KRW(order.PointAmount), "캐시 충전 (Toss)", order.OrderID);
        order.MarkPaid(paymentKey);

        await retryDb.SaveChangesAsync(ct);

        return new Response(true, order.Status.ToString(), order.PointAmount, "충전이 완료되었습니다.", order.PaidAt);
    }

    /// <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.Confirm, paymentOrderID, paymentKey, amount, reason), CancellationToken.None);
            await logDb.SaveChangesAsync(CancellationToken.None);
        }
        catch
        {
            // best-effort — 원래 예외를 유지한다
        }
    }

    private static void ApplyConfirmResponse(TossConfirm confirm, TossPaymentResult result)
    {
        confirm.SetResponse(result.Status ?? "", result.Method, result.TotalAmount, result.ApprovedAt, result.ReceiptUrl, result.RawJson);
    }
}