using Microsoft.EntityFrameworkCore.Storage;
using Microsoft.Extensions.Logging;
using SVSim.Database.Enums;
using SVSim.Database.Models;
using SVSim.Database.Models.Config;

namespace SVSim.Database.Services.Inventory;

internal sealed class InventoryTransaction : IInventoryTransaction
{
    private readonly SVSimDbContext _db;
    private readonly IDbContextTransaction _dbTx;
    private readonly ILogger _log;
    private readonly FreeplayConfig _freeplay;
    private bool _committed;

    public Viewer Viewer { get; }
    public bool IsFreeplay => _freeplay.Enabled;

    private readonly List<InventoryOp> _ops = new();

    internal abstract record InventoryOp;
    internal sealed record SpendOp(SpendCurrency Currency, long Cost, long PostState) : InventoryOp;
    internal sealed record GrantOp(UserGoodsType Type, long DetailId, int Num, int PostStateOrCount, bool IsCascade) : InventoryOp;

    public InventoryTransaction(
        SVSimDbContext db,
        IDbContextTransaction dbTx,
        Viewer viewer,
        FreeplayConfig freeplay,
        ILogger log)
    {
        _db = db;
        _dbTx = dbTx;
        Viewer = viewer;
        _freeplay = freeplay;
        _log = log;
    }

    // Implementations land in later tasks. Throw NotImplementedException to keep the build green.
    public Task<SpendResult> TrySpendAsync(SpendCurrency currency, long cost, CancellationToken ct = default)
        => throw new NotImplementedException();

    public Task<SpendResult> TryDebitAsync(UserGoodsType type, long detailId, int num, CancellationToken ct = default)
        => throw new NotImplementedException();

    public async Task<IReadOnlyList<GrantedReward>> GrantAsync(UserGoodsType type, long detailId, int num, CancellationToken ct = default)
    {
        ThrowIfCommitted();

        switch (type)
        {
            case UserGoodsType.Rupy:
                Viewer.Currency.Rupees += (ulong)num;
                var rupy = checked((int)Viewer.Currency.Rupees);
                _ops.Add(new GrantOp(type, detailId, num, rupy, false));
                return Single(type, detailId, rupy);

            case UserGoodsType.Crystal:
                Viewer.Currency.Crystals += (ulong)num;
                var crystal = checked((int)Viewer.Currency.Crystals);
                _ops.Add(new GrantOp(type, detailId, num, crystal, false));
                return Single(type, detailId, crystal);

            case UserGoodsType.RedEther:
                Viewer.Currency.RedEther += (ulong)num;
                var red = checked((int)Viewer.Currency.RedEther);
                _ops.Add(new GrantOp(type, detailId, num, red, false));
                return Single(type, detailId, red);

            case UserGoodsType.SpotCardPoint:
                Viewer.Currency.SpotPoints += (ulong)num;
                var spot = checked((int)Viewer.Currency.SpotPoints);
                _ops.Add(new GrantOp(type, detailId, num, spot, false));
                return Single(type, detailId, spot);

            default:
                throw new NotImplementedException(
                    $"UserGoodsType {type} grant lands in a subsequent task");
        }
    }

    public Task<int> BackfillCardCosmeticsAsync(CancellationToken ct = default)
        => throw new NotImplementedException();

    public long EffectiveBalance(SpendCurrency currency) => throw new NotImplementedException();
    public bool OwnsCard(long cardId) => throw new NotImplementedException();
    public bool OwnsCosmetic(CosmeticType type, int id) => throw new NotImplementedException();

    public Task<InventoryCommitResult> CommitAsync(CancellationToken ct = default)
        => throw new NotImplementedException();

    private static IReadOnlyList<GrantedReward> Single(UserGoodsType type, long id, int num)
        => new[] { new GrantedReward((int)type, id, num) };

    private void ThrowIfCommitted()
    {
        if (_committed)
            throw new InvalidOperationException("Inventory transaction already committed");
    }

    public async ValueTask DisposeAsync()
    {
        if (!_committed)
        {
            await _dbTx.RollbackAsync();
            _db.ChangeTracker.Clear();
        }
        await _dbTx.DisposeAsync();
    }
}