using Domain.Entities.Chat;
using Domain.Entities.Common.ValueObject;
using Domain.Entities.Forum.Boards;
using Domain.Entities.Forum.Posts;
using Domain.Entities.Members;
using Domain.Entities.Store;
using Domain.Entities.Store.ValueObject;
using Domain.Entities.Wallets;
using Domain.Entities.Wallets.ValueObject;
using Infrastructure.Persistence;
using Microsoft.EntityFrameworkCore;
using UseCommand = Application.Features.Api.Member.Items.Use.Command;
using UseHandler = Application.Features.Api.Member.Items.Use.Handler;
using ListHandler = Application.Features.Api.Member.Items.List.Handler;
using ListQuery = Application.Features.Api.Member.Items.List.Query;
using PlaceCommand = Application.Features.Api.Store.Orders.Place.Command;
using PlaceHandler = Application.Features.Api.Store.Orders.Place.Handler;

namespace Application.Tests;

/// <summary>
/// P3 소모품 상점(계정 귀속 MemberItem) 검증 — 도메인 규칙 + Use/List/Place 핸들러 + 공용 헬퍼.
/// 운영과 동일한 LocalDB(antooza_test) SQL Server 프로바이더로 EF 동작을 그대로 검증한다.
/// </summary>
[TestClass]
public sealed class MemberItemTests
{
    // ── 시드 헬퍼 ────────────────────────────────────────────────

    /// <summary>소모품 상품(Digital + ItemKind)을 시드하고 Product 를 반환한다.</summary>
    private static async Task<Product> SeedItemProductAsync(AppDbContext db, ItemKind kind, int durationDays = 0, int price = 0)
    {
        var product = Product.Create(
            gameID: null,
            name: $"소모품-{kind}",
            type: ProductType.Digital,
            price: price,
            discountType: DiscountType.None,
            discountValue: 0,
            stock: -1,
            itemKind: kind,
            durationDays: durationDays
        );

        await db.Product.AddAsync(product);
        await db.SaveChangesAsync(default);
        return product;
    }

    /// <summary>회원 소유의 미사용 MemberItem 을 직접 발급하고 반환한다 (구매 경로 우회).</summary>
    private static async Task<MemberItem> SeedMemberItemAsync(AppDbContext db, int memberID, ItemKind kind, int durationDays = 0)
    {
        var product = await SeedItemProductAsync(db, kind, durationDays);
        // OrderItemID FK 제약이 없으므로(회수 연동 스냅샷용) 양수 더미로 충분하다.
        var item = MemberItem.Create(memberID, product.ID, orderItemID: 999999, kind: kind, durationDays: durationDays);
        await db.MemberItem.AddAsync(item);
        await db.SaveChangesAsync(default);
        return item;
    }

    /// <summary>본인 소유 활성/미신고/무댓글 게시글 1건을 시드하고 PostID 를 반환한다.</summary>
    private static async Task<int> SeedPostAsync(AppDbContext db, int memberID, int reports = 0, int comments = 0, bool isDeleted = false)
    {
        var group = new BoardGroup { Code = $"g-{Guid.NewGuid():N}"[..20], Name = "테스트 그룹" };
        await db.BoardGroup.AddAsync(group);
        await db.SaveChangesAsync(default);

        var board = new Board { BoardGroupID = group.ID, Code = $"b-{Guid.NewGuid():N}"[..20], Name = "테스트 게시판", IsActive = true };
        await db.Board.AddAsync(board);
        await db.SaveChangesAsync(default);

        var post = new Post
        {
            BoardID = board.ID,
            MemberID = memberID,
            Subject = "테스트 글",
            Content = "본문",
            Reports = reports,
            Comments = comments,
            IsDeleted = isDeleted
        };
        await db.Post.AddAsync(post);
        await db.SaveChangesAsync(default);
        return post.ID;
    }

    // ── 도메인: MemberItem 라이프사이클 ───────────────────────────

    [TestMethod]
    public void Create_NewItem_IsAvailable_NotUsedNotRevoked()
    {
        // 기대 행위: 신규 발급 아이템은 미사용·미회수 → 사용 가능.
        var item = MemberItem.Create(memberID: 1, productID: 2, orderItemID: 3, kind: ItemKind.NotePass, durationDays: 0);

        Assert.IsTrue(item.IsAvailable, "신규 아이템은 사용 가능해야 한다");
        Assert.IsNull(item.UsedAt);
        Assert.IsNull(item.RevokedAt);
        Assert.AreEqual(ItemKind.NotePass, item.Kind);
    }

    [TestMethod]
    public void MarkUsed_ThenAgain_Throws_AndBlocksRevoke()
    {
        // 기대 행위: MarkUsed 후 재사용은 예외, 사용한 아이템은 더 이상 회수 불가.
        var now = DateTime.UtcNow;
        var item = MemberItem.Create(1, 2, 3, ItemKind.ChatBanLift, 0);

        item.MarkUsed(now);

        Assert.IsFalse(item.IsAvailable, "사용 후에는 사용 불가여야 한다");
        Assert.AreEqual(now, item.UsedAt);
        Assert.ThrowsException<InvalidOperationException>(() => item.MarkUsed(now), "이미 사용한 아이템 재사용은 예외");
        Assert.IsFalse(item.Revoke(now), "사용한 아이템은 회수되지 않아야 한다");
    }

    [TestMethod]
    public void Revoke_UnusedItem_Succeeds_ThenBlocksUse()
    {
        // 기대 행위: 미사용 아이템은 회수 가능하고, 회수 후에는 사용(MarkUsed)이 예외.
        var now = DateTime.UtcNow;
        var item = MemberItem.Create(1, 2, 3, ItemKind.ExpBooster, 7);

        Assert.IsTrue(item.Revoke(now), "미사용 아이템은 회수되어야 한다");
        Assert.IsFalse(item.IsAvailable);
        Assert.AreEqual(now, item.RevokedAt);
        Assert.IsFalse(item.Revoke(now), "이미 회수된 아이템 재회수는 false");
        Assert.ThrowsException<InvalidOperationException>(() => item.MarkUsed(now), "회수된 아이템은 사용 예외");
    }

    [TestMethod]
    public void IsBoostActiveAt_OnlyForUsedExpBooster_WithinWindow()
    {
        // 기대 행위: ExpBooster 는 사용 후 DurationDays 창 이내에서만 활성. 미사용/타종류/만료/회수는 비활성.
        var used = DateTime.UtcNow;
        var booster = MemberItem.Create(1, 2, 3, ItemKind.ExpBooster, durationDays: 3);

        Assert.IsFalse(booster.IsBoostActiveAt(used), "미사용 부스터는 비활성");

        booster.MarkUsed(used);
        Assert.IsTrue(booster.IsBoostActiveAt(used.AddDays(1)), "창 이내는 활성");
        Assert.IsFalse(booster.IsBoostActiveAt(used.AddDays(3).AddSeconds(1)), "창 만료 후는 비활성");

        var notBooster = MemberItem.Create(1, 2, 3, ItemKind.NotePass, durationDays: 3);
        notBooster.MarkUsed(used);
        Assert.IsFalse(notBooster.IsBoostActiveAt(used.AddDays(1)), "부스터가 아니면 항상 비활성");
    }

    // ── Use 핸들러 ───────────────────────────────────────────────

    [TestMethod]
    public async Task Use_ChatBanLift_LiftsActiveBans_AndMarksUsed()
    {
        // 기대 행위: 채팅 밴 해제권 사용 시 본인 활성 제재를 해제하고 아이템을 소모 + 사용 로그를 남긴다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        await db.ChatBan.AddAsync(ChatBan.Create(memberID, null, "전체 제재", null, "admin"));
        await db.ChatBan.AddAsync(ChatBan.Create(memberID, "main", "메인 제재", null, "admin"));
        await db.SaveChangesAsync(default);
        var item = await SeedMemberItemAsync(db, memberID, ItemKind.ChatBanLift);
        var handler = new UseHandler(db);

        var result = await handler.Handle(new UseCommand(memberID, item.ID), default);

        Assert.IsTrue(result.IsSuccess, "밴 해제권 사용은 성공해야 한다");
        Assert.AreEqual(ItemKind.ChatBanLift, result.Value.Kind);

        using var verify = TestDb.Create();
        var now = DateTime.UtcNow;
        Assert.IsFalse(await ChatBanCheckerIsBanned(verify, memberID, "main", now), "제재가 해제되어야 한다");
        Assert.IsFalse(await ChatBanCheckerIsBanned(verify, memberID, "stock:005930", now), "전체 제재도 해제되어야 한다");

        var used = await verify.MemberItem.SingleAsync(i => i.ID == item.ID);
        Assert.IsFalse(used.IsAvailable, "사용 후 소모 상태여야 한다");
        Assert.AreEqual(1, await verify.MemberItemUsageLog.CountAsync(l => l.MemberItemID == item.ID), "사용 로그가 1건 남아야 한다");
    }

    [TestMethod]
    public async Task Use_ChatBanLift_NoActiveBan_Fails_AndItemNotConsumed()
    {
        // 기대 행위: 해제할 활성 제재가 없으면 실패하고 아이템은 소모되지 않는다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var item = await SeedMemberItemAsync(db, memberID, ItemKind.ChatBanLift);
        var handler = new UseHandler(db);

        var result = await handler.Handle(new UseCommand(memberID, item.ID), default);

        Assert.IsFalse(result.IsSuccess, "해제할 제재가 없으면 실패");
        Assert.AreEqual("MemberItem.NoActiveBan", result.Error.Code);

        using var verify = TestDb.Create();
        var stored = await verify.MemberItem.SingleAsync(i => i.ID == item.ID);
        Assert.IsTrue(stored.IsAvailable, "실패 시 아이템은 소모되지 않아야 한다");
    }

    [TestMethod]
    public async Task Use_PostReset_DeletesOnlyCleanPosts_KeepsReportedOrCommented()
    {
        // 기대 행위: 글 초기화권은 신고·댓글 없는 본인 글만 삭제하고, 신고/댓글 있는 글은 남긴다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var cleanPostID = await SeedPostAsync(db, memberID);
        var reportedPostID = await SeedPostAsync(db, memberID, reports: 2);
        var commentedPostID = await SeedPostAsync(db, memberID, comments: 3);
        var item = await SeedMemberItemAsync(db, memberID, ItemKind.PostReset);
        var handler = new UseHandler(db);

        var result = await handler.Handle(new UseCommand(memberID, item.ID), default);

        Assert.IsTrue(result.IsSuccess, "초기화 대상 글이 있으면 성공");

        using var verify = TestDb.Create();
        Assert.IsTrue((await verify.Post.SingleAsync(p => p.ID == cleanPostID)).IsDeleted, "깨끗한 글은 삭제되어야 한다");
        Assert.IsFalse((await verify.Post.SingleAsync(p => p.ID == reportedPostID)).IsDeleted, "신고된 글은 남아야 한다");
        Assert.IsFalse((await verify.Post.SingleAsync(p => p.ID == commentedPostID)).IsDeleted, "댓글 달린 글은 남아야 한다");
    }

    [TestMethod]
    public async Task Use_ExpBooster_MarksUsed_AndActivatesBoost()
    {
        // 기대 행위: 경험치 부스터 사용은 MarkUsed 만으로 활성화되고, 이후 활성 판정이 참이 된다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var item = await SeedMemberItemAsync(db, memberID, ItemKind.ExpBooster, durationDays: 7);
        var handler = new UseHandler(db);

        var result = await handler.Handle(new UseCommand(memberID, item.ID), default);

        Assert.IsTrue(result.IsSuccess, "부스터 사용은 성공해야 한다");

        using var verify = TestDb.Create();
        var used = await verify.MemberItem.SingleAsync(i => i.ID == item.ID);
        Assert.IsNotNull(used.UsedAt, "사용 시각이 기록되어야 한다");
        Assert.IsTrue(used.IsBoostActiveAt(DateTime.UtcNow), "사용 직후 부스터가 활성이어야 한다");
    }

    [TestMethod]
    public async Task Use_NotePass_Rejected_NotDirectlyUsable()
    {
        // 기대 행위: 쪽지권 등은 직접 사용 불가 — 해당 기능 이용 시 자동 소모되므로 Use 는 거절한다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var item = await SeedMemberItemAsync(db, memberID, ItemKind.NotePass);
        var handler = new UseHandler(db);

        var result = await handler.Handle(new UseCommand(memberID, item.ID), default);

        Assert.IsFalse(result.IsSuccess);
        Assert.AreEqual("MemberItem.NotDirectlyUsable", result.Error.Code);

        using var verify = TestDb.Create();
        Assert.IsTrue((await verify.MemberItem.SingleAsync(i => i.ID == item.ID)).IsAvailable, "거절 시 소모되지 않아야 한다");
    }

    [TestMethod]
    public async Task Use_NotOwnedItem_ReturnsNotFound()
    {
        // 기대 행위: 타인 소유 아이템은 소유자 검증에서 NotFound.
        using var db = TestDb.Create();
        var ownerID = await TestDb.CreateMemberAsync(db);
        var otherID = await TestDb.CreateMemberAsync(db);
        var item = await SeedMemberItemAsync(db, ownerID, ItemKind.ChatBanLift);
        var handler = new UseHandler(db);

        var result = await handler.Handle(new UseCommand(otherID, item.ID), default);

        Assert.IsFalse(result.IsSuccess);
        Assert.AreEqual("MemberItem.NotFound", result.Error.Code);
    }

    [TestMethod]
    public async Task Use_AlreadyUsedItem_ReturnsConflict()
    {
        // 기대 행위: 이미 사용한 아이템 재사용은 Conflict(Unavailable).
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var item = await SeedMemberItemAsync(db, memberID, ItemKind.ExpBooster, durationDays: 7);
        var handler = new UseHandler(db);

        var first = await handler.Handle(new UseCommand(memberID, item.ID), default);
        Assert.IsTrue(first.IsSuccess);

        using var db2 = TestDb.Create();
        var handler2 = new UseHandler(db2);
        var second = await handler2.Handle(new UseCommand(memberID, item.ID), default);

        Assert.IsFalse(second.IsSuccess);
        Assert.AreEqual("MemberItem.Unavailable", second.Error.Code);
    }

    // ── MemberItemConsumer 헬퍼 ───────────────────────────────────

    [TestMethod]
    public async Task Consumer_TryConsume_MarksUsed_AndLogs_WithoutSaving()
    {
        // 기대 행위: TryConsume 은 사용 가능한 아이템 1개를 소모하고 로그를 추가한다 (SaveChanges 는 호출측 위임).
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var item = await SeedMemberItemAsync(db, memberID, ItemKind.NotePass);
        var now = DateTime.UtcNow;

        var consumed = await Application.Helpers.MemberItemConsumer.TryConsumeAsync(db, memberID, ItemKind.NotePass, now, "쪽지 초과 발송", default);
        Assert.IsTrue(consumed, "사용 가능한 아이템이 있으면 소모되어야 한다");

        await db.SaveChangesAsync(default);

        using var verify = TestDb.Create();
        Assert.IsFalse((await verify.MemberItem.SingleAsync(i => i.ID == item.ID)).IsAvailable, "소모 후 사용 불가여야 한다");
        Assert.AreEqual(1, await verify.MemberItemUsageLog.CountAsync(l => l.MemberItemID == item.ID), "사용 로그가 남아야 한다");
    }

    [TestMethod]
    public async Task Consumer_HasAvailable_And_TryConsume_NoneAvailable()
    {
        // 기대 행위: 보유가 없으면 HasAvailable=false, TryConsume=false.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);

        Assert.IsFalse(await Application.Helpers.MemberItemConsumer.HasAvailableAsync(db, memberID, ItemKind.NotePass, default), "보유 없음");

        var consumed = await Application.Helpers.MemberItemConsumer.TryConsumeAsync(db, memberID, ItemKind.NotePass, DateTime.UtcNow, null, default);
        Assert.IsFalse(consumed, "보유가 없으면 소모 실패");
    }

    // ── ExpBoostService 헬퍼 ──────────────────────────────────────

    [TestMethod]
    public async Task ExpBoost_Doubles_WhenActiveBoosterExists_ElseUnchanged()
    {
        // 기대 행위: 활성 부스터 보유 시 ApplyAsync 는 baseExp × 2, 미보유 시 baseExp 그대로.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var now = DateTime.UtcNow;

        // 부스터 없음 → 그대로
        Assert.AreEqual(10, await Application.Helpers.ExpBoostService.ApplyAsync(db, memberID, 10, now, default), "부스터 없으면 원본 유지");

        // 활성 부스터 사용
        var item = await SeedMemberItemAsync(db, memberID, ItemKind.ExpBooster, durationDays: 7);
        item.MarkUsed(now);
        await db.SaveChangesAsync(default);

        Assert.AreEqual(20, await Application.Helpers.ExpBoostService.ApplyAsync(db, memberID, 10, now, default), "활성 부스터면 2배");
    }

    [TestMethod]
    public async Task ExpBoost_ExpiredBooster_DoesNotDouble()
    {
        // 기대 행위: 창이 만료된 부스터는 2배를 적용하지 않는다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var item = await SeedMemberItemAsync(db, memberID, ItemKind.ExpBooster, durationDays: 1);
        var usedAt = DateTime.UtcNow.AddDays(-2);
        item.MarkUsed(usedAt);
        await db.SaveChangesAsync(default);

        var applied = await Application.Helpers.ExpBoostService.ApplyAsync(db, memberID, 10, DateTime.UtcNow, default);
        Assert.AreEqual(10, applied, "만료 부스터는 2배 미적용");
    }

    // ── Place 핸들러: 소모품 구매 시 MemberItem 발급 ───────────────

    [TestMethod]
    public async Task Place_ConsumablePurchase_IssuesOneMemberItemPerUnit()
    {
        // 기대 행위: ItemKind 상품(쿠폰 없음, GameID null)을 구매하면 수량만큼 계정 귀속 MemberItem 이 발급된다.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var wallet = Wallet.Create(memberID);
        wallet.CreditPgCharge(Money.KRW(10000), "충전", "SEED");
        await db.Wallet.AddAsync(wallet);
        await db.SaveChangesAsync(default);

        var product = await SeedItemProductAsync(db, ItemKind.ExpBooster, durationDays: 7, price: 1000);
        var handler = new PlaceHandler(db);

        var result = await handler.Handle(
            new PlaceCommand(memberID, ChannelID: null, Items: [new PlaceCommand.Item(product.ID, 3)]),
            default);

        Assert.IsTrue(result.IsSuccess, $"소모품 구매는 성공해야 한다: {(result.IsSuccess ? "" : result.Error.Code)}");
        Assert.IsTrue(result.Value.HasDigital, "소모품은 Digital 로 취급된다");

        using var verify = TestDb.Create();
        var items = await verify.MemberItem.Where(i => i.MemberID == memberID && i.ProductID == product.ID).ToListAsync();
        Assert.AreEqual(3, items.Count, "구매 수량(3)만큼 MemberItem 이 발급되어야 한다");
        Assert.IsTrue(items.All(i => i.Kind == ItemKind.ExpBooster && i.DurationDays == 7 && i.IsAvailable),
            "발급된 아이템은 종류·기간 스냅샷이 올바르고 사용 가능해야 한다");
    }

    // ── List 핸들러 ──────────────────────────────────────────────

    [TestMethod]
    public async Task List_ExcludesUsedByDefault_AndRevokedAlways()
    {
        // 기대 행위: 기본 조회는 미사용만, IncludeUsed=true 면 사용분 포함. 회수분은 항상 제외.
        using var db = TestDb.Create();
        var memberID = await TestDb.CreateMemberAsync(db);
        var now = DateTime.UtcNow;

        var available = await SeedMemberItemAsync(db, memberID, ItemKind.ChatBanLift);

        var used = await SeedMemberItemAsync(db, memberID, ItemKind.ExpBooster, durationDays: 7);
        used.MarkUsed(now);

        var revoked = await SeedMemberItemAsync(db, memberID, ItemKind.NotePass);
        revoked.Revoke(now);
        await db.SaveChangesAsync(default);

        var handler = new ListHandler(db);

        var defaultList = await handler.Handle(new ListQuery(memberID), default);
        Assert.AreEqual(1, defaultList.Total, "기본 조회는 미사용 1건");
        Assert.AreEqual(available.ID, defaultList.List[0].ID);

        var withUsed = await handler.Handle(new ListQuery(memberID, IncludeUsed: true), default);
        Assert.AreEqual(2, withUsed.Total, "IncludeUsed 는 미사용+사용 2건 (회수분 제외)");
        Assert.IsFalse(withUsed.List.Any(r => r.ID == revoked.ID), "회수분은 항상 제외");
    }

    // ── 테스트 로컬 헬퍼 ──────────────────────────────────────────

    private static Task<bool> ChatBanCheckerIsBanned(AppDbContext db, int memberID, string roomKey, DateTime now)
        => Application.Helpers.ChatBanChecker.IsBannedAsync(db, memberID, roomKey, now, default);
}