using Domain.Entities.Common.ValueObject;
using Domain.Entities.Payments.ValueObject;
using Domain.Entities.Wallets;
using Domain.Entities.Wallets.ValueObject;
using Microsoft.EntityFrameworkCore;
using ConfirmCommand = Application.Features.Api.Payment.Confirm.Command;
using ConfirmHandler = Application.Features.Api.Payment.Confirm.Handler;

namespace Application.Tests;

[TestClass]
public sealed class PaymentConfirmHandlerTests
{
    [TestMethod]
    public async Task Success_CreditsPgCharged_And_MarksPaid()
    {
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var wallet = Wallet.Create(memberID);
        await db.Wallet.AddAsync(wallet);
        var order = await TestDb.CreateOrderAsync(db, memberID, 10000);
        var fake = new FakeDanalPayService();
        var handler = new ConfirmHandler(db, fake, FakeAppDbContextFactory.Instance);

        var resp = await handler.Handle(new ConfirmCommand(order.OrderID, "TX-1", "CARD", memberID), default);

        Assert.IsTrue(resp.Success);
        Assert.AreEqual(10000, resp.PointAmount);

        using var verify = TestDb.Create();
        var savedOrder = await verify.PaymentOrder.SingleAsync(o => o.OrderID == order.OrderID);
        Assert.AreEqual(PaymentStatus.Paid, savedOrder.Status);
        Assert.AreEqual("TX-1", savedOrder.TransactionID);

        var savedWallet = await verify.Wallet.Include(w => w.Balances).Include(w => w.Transactions).AsSplitQuery().SingleAsync(w => w.MemberID == memberID);
        Assert.AreEqual(10000m, savedWallet.Balances.Single(b => b.Type == WalletBalanceType.PgCharged).Amount.Value);
        Assert.IsTrue(savedWallet.Transactions.Any(t => t.TxType == WalletTransactionType.Charge && t.Amount.Value == 10000m && t.RefID == order.OrderID));
    }

    [TestMethod]
    public async Task WalletMissing_CreatesWallet_And_PersistsPaid()
    {
        // P0 #1 재현: PG 승인 성공 후 지갑이 없으면 MarkPaid 가 저장되지 않고 유실됐다.
        // 기대 행위: 지갑을 생성해 충전을 반영하고 주문을 Paid 로 저장한다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var order = await TestDb.CreateOrderAsync(db, memberID, 5000);
        var fake = new FakeDanalPayService();
        var handler = new ConfirmHandler(db, fake, FakeAppDbContextFactory.Instance);

        var resp = await handler.Handle(new ConfirmCommand(order.OrderID, "TX-2", "CARD", memberID), default);

        Assert.IsTrue(resp.Success, $"승인 성공이 반영되어야 한다: {resp.Message}");

        using var verify = TestDb.Create();
        var savedOrder = await verify.PaymentOrder.SingleAsync(o => o.OrderID == order.OrderID);
        Assert.AreEqual(PaymentStatus.Paid, savedOrder.Status, "PG 승인 성공이 DB에 기록되어야 한다");

        var savedWallet = await verify.Wallet.Include(w => w.Balances).AsSplitQuery().SingleOrDefaultAsync(w => w.MemberID == memberID);
        Assert.IsNotNull(savedWallet, "지갑이 자동 생성되어야 한다");
        Assert.AreEqual(5000m, savedWallet.Balances.Single(b => b.Type == WalletBalanceType.PgCharged).Amount.Value);
    }

    [TestMethod]
    public async Task PgCommException_MarksNeedsReconciliation()
    {
        // P0 #2 + Phase 1.5 계약 변경: PG 통신 불명 예외(HttpRequestException/TaskCanceledException)는
        // 다날이 실제 승인했을 수 있어 Failed 로 단정하지 않고 NeedsReconciliation 으로 표시한다.
        // (기존 "통신예외 → Failed" 테스트를 갱신 — Pending 방치가 없어야 한다는 원 취지는 유지)
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var wallet = Wallet.Create(memberID);
        await db.Wallet.AddAsync(wallet);
        var order = await TestDb.CreateOrderAsync(db, memberID);
        var fake = new FakeDanalPayService { ConfirmException = new HttpRequestException("network error") };
        var handler = new ConfirmHandler(db, fake, FakeAppDbContextFactory.Instance);

        var resp = await handler.Handle(new ConfirmCommand(order.OrderID, "TX-3", "CARD", memberID), default);

        Assert.IsFalse(resp.Success);

        using var verify = TestDb.Create();
        var savedOrder = await verify.PaymentOrder.SingleAsync(o => o.OrderID == order.OrderID);
        Assert.AreEqual(PaymentStatus.NeedsReconciliation, savedOrder.Status, "PG 통신 불명은 대사 대상(NeedsReconciliation)으로 기록되어야 한다");

        var savedWallet = await verify.Wallet.Include(w => w.Balances).AsSplitQuery().SingleAsync(w => w.MemberID == memberID);
        Assert.AreEqual(0m, savedWallet.Balances.Single(b => b.Type == WalletBalanceType.PgCharged).Amount.Value, "승인 확정 전에는 충전되지 않는다");
    }

    [TestMethod]
    public async Task PgNonCommException_MarksOrderFailed()
    {
        // 통신 불명이 아닌 예외(설정 오류 등)는 기존대로 Failed — Pending 방치를 막는다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var wallet = Wallet.Create(memberID);
        await db.Wallet.AddAsync(wallet);
        var order = await TestDb.CreateOrderAsync(db, memberID);
        var fake = new FakeDanalPayService { ConfirmException = new InvalidOperationException("danal config error") };
        var handler = new ConfirmHandler(db, fake, FakeAppDbContextFactory.Instance);

        var resp = await handler.Handle(new ConfirmCommand(order.OrderID, "TX-3N", "CARD", memberID), default);

        Assert.IsFalse(resp.Success);

        using var verify = TestDb.Create();
        var savedOrder = await verify.PaymentOrder.SingleAsync(o => o.OrderID == order.OrderID);
        Assert.AreEqual(PaymentStatus.Failed, savedOrder.Status, "통신 불명 이외의 예외는 주문 Failed 로 기록되어야 한다");
    }

    [TestMethod]
    public async Task NeedsReconciliation_ReConfirm_Succeeds_ReusingConfirmRow()
    {
        // Phase 1.5: 통신 불명(NeedsReconciliation) 주문은 재승인이 허용되어야 하고,
        // DanalConfirm 은 TransactionID/OrderID unique 라 기존 요청 행을 재사용해야 한다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var wallet = Wallet.Create(memberID);
        await db.Wallet.AddAsync(wallet);
        var order = await TestDb.CreateOrderAsync(db, memberID, 10000);
        var failFake = new FakeDanalPayService { ConfirmException = new TaskCanceledException("timeout") };
        var handler = new ConfirmHandler(db, failFake, FakeAppDbContextFactory.Instance);

        var first = await handler.Handle(new ConfirmCommand(order.OrderID, "TX-RECON-A", "CARD", memberID), default);
        Assert.IsFalse(first.Success);

        using (var mid = TestDb.Create())
        {
            var midOrder = await mid.PaymentOrder.SingleAsync(o => o.OrderID == order.OrderID);
            Assert.AreEqual(PaymentStatus.NeedsReconciliation, midOrder.Status);
        }

        using var db2 = TestDb.Create();
        var handler2 = new ConfirmHandler(db2, new FakeDanalPayService(), FakeAppDbContextFactory.Instance);
        var second = await handler2.Handle(new ConfirmCommand(order.OrderID, "TX-RECON-B", "CARD", memberID), default);

        Assert.IsTrue(second.Success, $"NeedsReconciliation 재승인은 성공해야 한다: {second.Message}");

        using var verify = TestDb.Create();
        var savedOrder = await verify.PaymentOrder.SingleAsync(o => o.OrderID == order.OrderID);
        Assert.AreEqual(PaymentStatus.Paid, savedOrder.Status);
        Assert.AreEqual("TX-RECON-B", savedOrder.TransactionID);

        var confirms = await verify.DanalConfirm.Where(c => c.OrderID == order.OrderID).ToListAsync();
        Assert.AreEqual(1, confirms.Count, "재승인은 기존 DanalConfirm 행을 재사용해야 한다 (unique 인덱스 충돌 금지)");
        Assert.AreEqual("TX-RECON-B", confirms[0].TransactionID);

        var savedWallet = await verify.Wallet.Include(w => w.Balances).Include(w => w.Transactions).AsSplitQuery().SingleAsync(w => w.MemberID == memberID);
        Assert.AreEqual(10000m, savedWallet.Balances.Single(b => b.Type == WalletBalanceType.PgCharged).Amount.Value);
        Assert.AreEqual(1, savedWallet.Transactions.Count(t => t.TxType == WalletTransactionType.Charge && t.RefID == order.OrderID), "충전 원장은 정확히 1건이어야 한다");
    }

    [TestMethod]
    public async Task ConcurrencyConflict_RetriesOnce_WithoutDoubleCredit()
    {
        // Phase 1.5: PG 승인 성공 후 WalletBalance rowversion 충돌 시 새 컨텍스트로 1회 재적용 —
        // 승인금 유실 없이 성공하고, 원장 이중적립이 없어야 한다.
        int memberID;
        string orderID;
        using (var setup = TestDb.Create())
        {
            memberID = await TestDb.CreateMemberAsync(setup);
            await setup.Wallet.AddAsync(Wallet.Create(memberID));
            var order = await TestDb.CreateOrderAsync(setup, memberID, 10000);
            orderID = order.OrderID;
        }

        using var db = TestDb.Create();
        // 핸들러 컨텍스트에 지갑/잔액을 미리 추적시켜 stale rowversion 상태를 만든다
        _ = await db.Wallet.Include(w => w.Balances).AsSplitQuery().SingleAsync(w => w.MemberID == memberID);

        // 다른 컨텍스트가 동시 충전 → DB rowversion 전진 (핸들러의 최종 저장이 충돌하게 된다)
        using (var other = TestDb.Create())
        {
            var concurrent = await other.Wallet.Include(w => w.Balances).AsSplitQuery().SingleAsync(w => w.MemberID == memberID);
            concurrent.CreditPgCharge(Money.KRW(3000), "동시 충전", "CONCURRENT");
            await other.SaveChangesAsync(default);
        }

        var fake = new FakeDanalPayService();
        var handler = new ConfirmHandler(db, fake, FakeAppDbContextFactory.Instance);

        var resp = await handler.Handle(new ConfirmCommand(orderID, "TX-CONC", "CARD", memberID), default);

        Assert.IsTrue(resp.Success, $"동시성 충돌은 1회 재시도로 복구되어야 한다: {resp.Message}");
        Assert.AreEqual(1, fake.ConfirmCallCount, "재시도는 저장만 다시 한다 — PG 재호출 금지");

        using var verify = TestDb.Create();
        var savedOrder = await verify.PaymentOrder.SingleAsync(o => o.OrderID == orderID);
        Assert.AreEqual(PaymentStatus.Paid, savedOrder.Status);

        var savedWallet = await verify.Wallet.Include(w => w.Balances).Include(w => w.Transactions).AsSplitQuery().SingleAsync(w => w.MemberID == memberID);
        Assert.AreEqual(13000m, savedWallet.Balances.Single(b => b.Type == WalletBalanceType.PgCharged).Amount.Value, "동시 충전(3000)과 승인 충전(10000)이 모두 반영되어야 한다");
        Assert.AreEqual(1, savedWallet.Transactions.Count(t => t.TxType == WalletTransactionType.Charge && t.RefID == orderID), "원장 이중적립 금지");
    }

    [TestMethod]
    public async Task AlreadyPaid_IsIdempotent_WithoutPgCall()
    {
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var order = await TestDb.CreateOrderAsync(db, memberID, 7000, paid: true);
        var fake = new FakeDanalPayService();
        var handler = new ConfirmHandler(db, fake, FakeAppDbContextFactory.Instance);

        var resp = await handler.Handle(new ConfirmCommand(order.OrderID, "TX-RETRY", "CARD", memberID), default);

        Assert.IsTrue(resp.Success);
        Assert.AreEqual(7000, resp.PointAmount);
        Assert.AreEqual(0, fake.ConfirmCallCount, "이미 완료된 주문은 PG 를 재호출하지 않는다");
    }

    [TestMethod]
    public async Task FailedOrder_ReConfirm_IsRejected_WithoutPgCall_And_NoCrash()
    {
        // 리뷰 #1/#9 재현: Failed 주문이 재진입하면 PG 재호출 후 MarkPaid 가 예외를 던져 승인금이 유실됐다.
        // 기대 행위: 진입 가드가 PG 호출 전에 거절하고, 예외 없이 실패 응답.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var wallet = Wallet.Create(memberID);
        await db.Wallet.AddAsync(wallet);
        var order = await TestDb.CreateOrderAsync(db, memberID);
        order.MarkFailed("이전 승인 실패");
        await db.SaveChangesAsync(default);
        var fake = new FakeDanalPayService();
        var handler = new ConfirmHandler(db, fake, FakeAppDbContextFactory.Instance);

        var resp = await handler.Handle(new ConfirmCommand(order.OrderID, "TX-RE", "CARD", memberID), default);

        Assert.IsFalse(resp.Success);
        Assert.AreEqual(0, fake.ConfirmCallCount, "종료된 주문은 PG 를 재호출하지 않는다");

        using var verify = TestDb.Create();
        var savedOrder = await verify.PaymentOrder.SingleAsync(o => o.OrderID == order.OrderID);
        Assert.AreEqual(PaymentStatus.Failed, savedOrder.Status);
    }

    [TestMethod]
    public async Task MemberMismatch_DoesNotPoisonVictimOrder()
    {
        // 리뷰 #1 공격벡터 재현: 회원 불일치 분기가 피해자의 Pending 주문을 Failed 로 저장해
        // 이후 정상 승인을 MarkPaid 크래시로 유도할 수 있었다.
        // 기대 행위: 불일치는 주문 상태를 건드리지 않고, 피해자의 정상 승인이 뒤이어 성공한다.
        using var db = TestDb.Create();
        var victimID = await TestDb.CreateMemberAsync(db);
        var attackerID = await TestDb.CreateMemberAsync(db);
        var wallet = Wallet.Create(victimID);
        await db.Wallet.AddAsync(wallet);
        var order = await TestDb.CreateOrderAsync(db, victimID, 9000);
        var fake = new FakeDanalPayService();
        var handler = new ConfirmHandler(db, fake, FakeAppDbContextFactory.Instance);

        var attack = await handler.Handle(new ConfirmCommand(order.OrderID, "TX-ATK", "CARD", attackerID), default);
        Assert.IsFalse(attack.Success, "타인의 주문 승인은 거절되어야 한다");

        using (var mid = TestDb.Create())
        {
            var afterAttack = await mid.PaymentOrder.SingleAsync(o => o.OrderID == order.OrderID);
            Assert.AreEqual(PaymentStatus.Pending, afterAttack.Status, "불일치는 피해자 주문을 오염시키지 않아야 한다");
        }

        using var db2 = TestDb.Create();
        var handler2 = new ConfirmHandler(db2, new FakeDanalPayService(), FakeAppDbContextFactory.Instance);
        var legit = await handler2.Handle(new ConfirmCommand(order.OrderID, "TX-OK", "CARD", victimID), default);
        Assert.IsTrue(legit.Success, "피해자의 정상 승인은 크래시 없이 성공해야 한다");
    }

    [TestMethod]
    public async Task PgDeclines_MarksOrderFailed()
    {
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var wallet = Wallet.Create(memberID);
        await db.Wallet.AddAsync(wallet);
        var order = await TestDb.CreateOrderAsync(db, memberID);
        var fake = new FakeDanalPayService { ConfirmResult = FakeDanalPayService.FailConfirm() };
        var handler = new ConfirmHandler(db, fake, FakeAppDbContextFactory.Instance);

        var resp = await handler.Handle(new ConfirmCommand(order.OrderID, "TX-4", "CARD", memberID), default);

        Assert.IsFalse(resp.Success);

        using var verify = TestDb.Create();
        var savedOrder = await verify.PaymentOrder.SingleAsync(o => o.OrderID == order.OrderID);
        Assert.AreEqual(PaymentStatus.Failed, savedOrder.Status);

        var savedWallet = await verify.Wallet.Include(w => w.Balances).AsSplitQuery().SingleAsync(w => w.MemberID == memberID);
        Assert.AreEqual(0m, savedWallet.Balances.Single(b => b.Type == WalletBalanceType.PgCharged).Amount.Value, "승인 거절 시 충전되지 않는다");
    }
}