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

namespace Application.Features.Api.MyPage.ChargeLogs;

internal sealed class Handler(IAppDbContext db) : IQueryHandler<Query, Result<Response>>
{
    // 적립: 보상/후원받음/상점채널보상/잠금해제/Adjusted(+)
    private static readonly HashSet<WalletTransactionType> EarnTypes = new()
    {
        WalletTransactionType.RewardEarned,
        WalletTransactionType.DonationIn,
        WalletTransactionType.OrderChannelReward,
        WalletTransactionType.Unlock,
        WalletTransactionType.Adjusted
    };

    // 사용: 일반사용/후원보냄/상점결제/출금/상점채널보상차감 — Lock 은 제외
    private static readonly HashSet<WalletTransactionType> SpendTypes = new()
    {
        WalletTransactionType.Spend,
        WalletTransactionType.DonationOut,
        WalletTransactionType.OrderPay,
        WalletTransactionType.WithdrawalStoreRevenue,
        WalletTransactionType.OrderRefundChannelReward,
        WalletTransactionType.Adjusted
    };

    // 환불
    private static readonly HashSet<WalletTransactionType> RefundTypes = new()
    {
        WalletTransactionType.Refund,
        WalletTransactionType.OrderRefund
    };

    // 전체: Lock 만 제외한 모든 TxType
    private static readonly HashSet<WalletTransactionType> AllTypes = new()
    {
        WalletTransactionType.Charge,
        WalletTransactionType.DonationIn,
        WalletTransactionType.DonationOut,
        WalletTransactionType.RewardEarned,
        WalletTransactionType.Spend,
        WalletTransactionType.Refund,
        WalletTransactionType.Unlock,
        WalletTransactionType.Adjusted,
        WalletTransactionType.OrderPay,
        WalletTransactionType.OrderRefund,
        WalletTransactionType.OrderChannelReward,
        WalletTransactionType.OrderRefundChannelReward,
        WalletTransactionType.WithdrawalStoreRevenue
    };

    public async Task<Result<Response>> Handle(Query request, CancellationToken ct)
    {
        var page = request.Page < 1 ? 1 : request.Page;
        var perPage = request.PerPage is < 1 or > 50 ? 20 : request.PerPage;

        var now = DateTime.UtcNow;
        var startDate = request.Type switch
        {
            SearchDateType.Week => now.AddDays(-7),
            SearchDateType.Month => now.AddMonths(-1),
            SearchDateType.QuarterYear => now.AddMonths(-3),
            SearchDateType.HalfYear => now.AddMonths(-6),
            _ => now.Date
        };

        if (request.Category == WalletLogCategory.Charge)
        {
            return await HandleChargeAsync(request, page, perPage, startDate, ct);
        }

        return await HandleWalletAsync(request, page, perPage, startDate, ct);
    }

    // 충전 카테고리 (기존 PaymentOrder 기반)
    private async Task<Result<Response>> HandleChargeAsync(Query request, int page, int perPage, DateTime startDate, CancellationToken ct)
    {
        var query = db.PaymentOrder.AsNoTracking().Where(o => o.MemberID == request.MemberID && o.Status == PaymentStatus.Paid && o.PaidAt >= startDate).OrderByDescending(o => o.PaidAt);
        var total = await query.CountAsync(ct);

        var list = await query
            .Skip((page - 1) * perPage)
            .Take(perPage)
            .Select(o => new ChargeLogItem(
                o.ID,
                WalletLogCategory.Charge,
                o.OrderID,
                o.Amount,
                o.PointAmount,
                o.VatAmount,
                o.PaymentMethod.ToString(),
                o.Status.ToString(),
                null,
                null,
                null,
                null,
                null,
                o.CreatedAt,
                o.PaidAt
            ))
            .ToListAsync(ct);

        return Result.Success(new Response(list, total, page, perPage));
    }

    // 전체/적립/사용/환불 카테고리 (WalletTransaction 기반)
    private async Task<Result<Response>> HandleWalletAsync(Query request, int page, int perPage, DateTime startDate, CancellationToken ct)
    {
        var wallet = await db.Wallet.AsNoTracking().FirstOrDefaultAsync(w => w.MemberID == request.MemberID, ct);
        if (wallet is null)
        {
            return Result.Success(new Response([], 0, page, perPage));
        }

        var (typeSet, adjustedDirection) = ResolveTypeFilter(request.Category);

        var query = db.WalletTransaction.AsNoTracking()
            .Where(t => t.WalletKey == wallet.WalletKey && t.CreatedAt >= startDate && typeSet.Contains(t.TxType));

        // Adjusted 는 양방향 — Reason prefix 로 earn/spend 구분
        if (adjustedDirection == "earn")
        {
            query = query.Where(t => t.TxType != WalletTransactionType.Adjusted || !t.Reason.StartsWith("ADJUST_OUT:"));
        }
        else if (adjustedDirection == "spend")
        {
            query = query.Where(t => t.TxType != WalletTransactionType.Adjusted || t.Reason.StartsWith("ADJUST_OUT:"));
        }

        var ordered = query.OrderByDescending(t => t.ID);
        var total = await ordered.CountAsync(ct);

        var list = await ordered
            .Skip((page - 1) * perPage)
            .Take(perPage)
            .Select(t => new ChargeLogItem(
                t.ID,
                request.Category,
                null,
                (long)t.Amount.Value,
                null,
                null,
                null,
                null,
                t.TxType.ToString(),
                t.BalanceType.ToString(),
                t.Reason,
                t.RefID,
                (long)t.BalanceAfter.Value,
                t.CreatedAt,
                null
            ))
            .ToListAsync(ct);

        return Result.Success(new Response(list, total, page, perPage));
    }

    private static (HashSet<WalletTransactionType> Types, string? AdjustedDirection) ResolveTypeFilter(string category)
    {
        return category switch
        {
            WalletLogCategory.Earn   => (EarnTypes, "earn"),
            WalletLogCategory.Spend  => (SpendTypes, "spend"),
            WalletLogCategory.Refund => (RefundTypes, null),
            _                        => (AllTypes, null) // All
        };
    }
}