using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using Vanadium.Auth;
using Vanadium.Classes.DBs;
using static Vanadium.Classes.DBs.DBClasses.RoomConsumablesDBClasses;

namespace Vanadium.Controllers
{
    [ApiController]
    public class RoomConsumablesController : ControllerBase
    {
        private static class Status
        {
            public const int Success = 0;
            public const int RoomConsumableNotFound = 4;
            public const int PlayerDoesntHavePermission = 7;
            public const int MaxConsumablesInRoom = 13;
            public const int RoomIdMissing = 15;
            public const int PriceOrCurrencyMissing = 17;
            public const int CurrencyNotFound = 18;
            public const int PriceTooLowTokens = 21;
            public const int PriceTooHighTokens = 22;
            public const int NameTooShort = 23;
            public const int NameTooLong = 24;
            public const int DescriptionTooLong = 27;
            public const int ConcurrencyCodeMismatch = 32;
            public const int PlayerDoesNotOwnConsumable = 33;
            public const int PurchaseFailed = 35;
            public const int RoomNotFound = 36;
            public const int RequestedPriceDoesNotMatch = 38;
            public const int RequestedCurrencyDoesNotMatch = 39;
            public const int ConsumableCannotBePurchasedWithRoomCurrency = 40;
            public const int ConsumableCannotBePurchasedWithTokens = 41;
        }

        private static class TokenOp
        {
            public const int OK = 0;
            public const int NotEnoughCredit = 2;
            public const int RequestedPriceDoesNotMatch = 6;
        }

        private static class CurrencyOp
        {
            public const int Success = 0;
            public const int NotEnoughCredit = 1;
        }

        private const int TokenCurrencyType = 2;
        private const int MaxConsumablesPerRoom = 50;

        [HttpGet("/econ/roomInventory/room/{roomId:long}")]
        [HttpGet("/api/roomconsumables/v1/roomConsumable/room/{roomId:long}")]
        public IActionResult ListForRoom(long roomId) =>
            Ok(RoomConsumablesDB.GetConsumablesForRoom(roomId).Select(ToDescWire).ToList());

        [HttpGet("/econ/roomInventory/room/{roomId:long}/player")]
        [HttpGet("/api/roomconsumables/v1/roomConsumable/room/{roomId:long}/me")]
        public IActionResult MineForRoom(long roomId)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null) return Unauthorized("");

            var rows = RoomConsumablesDB.GetInventoryForRoom(id.Value, roomId);
            return Ok(rows.Select(r => ToInventoryWire(r.Ownership, r.Item)).ToList());
        }

        [HttpGet("/api/roomconsumables/v1/roomConsumable/{roomConsumableId:guid}")]
        public IActionResult GetOne(Guid roomConsumableId)
        {
            var item = RoomConsumablesDB.GetConsumable(roomConsumableId);
            return item == null ? NotFound("") : Ok(ToDescWire(item));
        }

        [HttpGet("/api/roomconsumables/v1/roomConsumable/{roomConsumableId:guid}/isOwned")]
        public IActionResult IsOwned(Guid roomConsumableId)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null) return Unauthorized("");

            var item = RoomConsumablesDB.GetConsumable(roomConsumableId);
            if (item == null) return Content("false", "application/json");

            return Content(RoomConsumablesDB.IsOwnedByOthers(item) ? "true" : "false", "application/json");
        }

        [HttpPost("/api/roomconsumables/v1/roomConsumable")]
        [HttpPut("/api/roomconsumables/v1/roomConsumable")]
        public async Task<IActionResult> CreateOrUpdate()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null) return Unauthorized("");

            var body = await ReadBodyAsync();
            var name = (ReadString(body, "Name") ?? "").Trim();
            var description = (ReadString(body, "Description") ?? "").Trim();
            var imageName = (ReadString(body, "ImageName") ?? "").Trim();
            var (price, currencyId, hasPrice) = ReadPriceAndCurrency(body);

            var publicId = ReadGuid(body, "RoomConsumableId");
            var existing = publicId is Guid pid && pid != Guid.Empty
                ? RoomConsumablesDB.GetConsumable(pid)
                : null;

            if (existing == null)
            {
                var roomId = ReadLong(body, "RoomId");
                if (roomId is not long rid || rid <= 0) return Ok(EditResponse(Status.RoomIdMissing));
                if (RoomDB.GetRoom(rid) == null) return Ok(EditResponse(Status.RoomNotFound));
                if (!RoomDB.UserCanEditRoom(rid, id.Value))
                    return Ok(EditResponse(Status.PlayerDoesntHavePermission));

                if (ValidateFields(name, description, hasPrice, price) is int fieldError)
                    return Ok(EditResponse(fieldError));
                if (RoomConsumablesDB.CountConsumablesInRoom(rid) >= MaxConsumablesPerRoom)
                    return Ok(EditResponse(Status.MaxConsumablesInRoom));

                var created = RoomConsumablesDB.CreateConsumable(
                    rid, id.Value, name, description, imageName, price, currencyId);
                return Ok(EditResponse(Status.Success, created));
            }

            if (!RoomDB.UserCanEditRoom(existing.RoomId, id.Value))
                return Ok(EditResponse(Status.PlayerDoesntHavePermission, existing));

            if (ValidateFields(name, description, hasPrice, price) is int updateError)
                return Ok(EditResponse(updateError, existing));

            RoomConsumablesDB.UpdateConsumable(existing, name, description, imageName, price, currencyId);
            return Ok(EditResponse(Status.Success, existing));
        }

        [HttpDelete("/api/roomconsumables/v1/roomConsumable/{roomConsumableId:guid}")]
        [HttpPost("/api/roomconsumables/v1/roomConsumable/{roomConsumableId:guid}")]
        public IActionResult Delete(Guid roomConsumableId)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null) return Unauthorized("");

            var item = RoomConsumablesDB.GetConsumable(roomConsumableId);
            if (item == null) return StatusBody(Status.RoomConsumableNotFound);

            if (!RoomDB.UserCanEditRoom(item.RoomId, id.Value))
                return StatusBody(Status.PlayerDoesntHavePermission);

            RoomConsumablesDB.DeleteConsumable(roomConsumableId);
            return StatusBody(Status.Success);
        }

        [HttpPut("/api/roomconsumables/v1/roomconsumable/{roomConsumableId:guid}/purchase/tokens")]
        [HttpPost("/api/roomconsumables/v1/roomconsumable/{roomConsumableId:guid}/purchase/tokens")]
        public async Task<IActionResult> PurchaseTokens(Guid roomConsumableId)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null) return Unauthorized("");

            var item = RoomConsumablesDB.GetConsumable(roomConsumableId);
            if (item == null) return Ok(CurrencyTokenResponse(null, Status.RoomConsumableNotFound, 0));

            var body = await ReadBodyAsync();
            var (price, _, hasPrice) = ReadPriceAndCurrency(body, "ExpectedPriceAndCurrency");
            var newCode = ReadConcurrency(body).NewCode;
            var balance = StorefrontsDB.GetBalance(id.Value, TokenCurrencyType);

            if (item.CurrencyId != null)
                return Ok(CurrencyTokenResponse(null, Status.ConsumableCannotBePurchasedWithTokens, balance));
            if (!hasPrice || price != item.Price)
                return Ok(CurrencyTokenResponse(
                    TokenOp.RequestedPriceDoesNotMatch, Status.RequestedPriceDoesNotMatch, balance));
            if (balance < item.Price)
                return Ok(CurrencyTokenResponse(TokenOp.NotEnoughCredit, Status.PurchaseFailed, balance));

            var newBalance = balance;
            if (item.Price > 0)
            {
                var deducted = StorefrontsDB.DeductCurrency(id.Value, TokenCurrencyType, item.Price);
                if (deducted == null)
                    return Ok(CurrencyTokenResponse(TokenOp.NotEnoughCredit, Status.PurchaseFailed, balance));
                newBalance = deducted.Balance;

                if (item.CreatorPlayerId != id.Value)
                    StorefrontsDB.AddCurrency(item.CreatorPlayerId, TokenCurrencyType, item.Price);
            }

            var own = RoomConsumablesDB.AddToInventory(id.Value, item.RoomConsumableId, newCode);
            return Ok(CurrencyTokenResponse(TokenOp.OK, Status.Success, newBalance, ToInventoryWire(own, item)));
        }

        [HttpPut("/api/roomconsumables/v1/roomconsumable/{roomConsumableId:guid}/purchase/currency")]
        [HttpPost("/api/roomconsumables/v1/roomconsumable/{roomConsumableId:guid}/purchase/currency")]
        public async Task<IActionResult> PurchaseCurrency(Guid roomConsumableId)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null) return Unauthorized("");

            var item = RoomConsumablesDB.GetConsumable(roomConsumableId);
            if (item == null)
                return Ok(CurrencyResponse(null, Status.RoomConsumableNotFound, id.Value, Guid.Empty, 0));
            if (item.CurrencyId is not Guid currencyId)
                return Ok(CurrencyResponse(
                    null, Status.ConsumableCannotBePurchasedWithRoomCurrency, id.Value, Guid.Empty, 0));

            var body = await ReadBodyAsync();
            var (price, requestedCurrency, hasPrice) = ReadPriceAndCurrency(body, "ExpectedPriceAndCurrency");
            var newCode = ReadConcurrency(body).NewCode;
            var balance = RoomConsumablesDB.GetCurrencyBalance(id.Value, currencyId);

            if (!hasPrice || price != item.Price)
                return Ok(CurrencyResponse(
                    null, Status.RequestedPriceDoesNotMatch, id.Value, currencyId, balance));
            if (requestedCurrency is Guid reqCur && reqCur != currencyId)
                return Ok(CurrencyResponse(
                    null, Status.RequestedCurrencyDoesNotMatch, id.Value, currencyId, balance));
            if (balance < item.Price)
                return Ok(CurrencyResponse(
                    CurrencyOp.NotEnoughCredit, Status.PurchaseFailed, id.Value, currencyId, balance));

            var newBalance = balance;
            if (item.Price > 0)
            {
                var deducted = RoomConsumablesDB.DeductCurrencyBalance(id.Value, currencyId, item.Price);
                if (deducted is not int remaining)
                    return Ok(CurrencyResponse(
                        CurrencyOp.NotEnoughCredit, Status.PurchaseFailed, id.Value, currencyId, balance));
                newBalance = remaining;
            }

            var own = RoomConsumablesDB.AddToInventory(id.Value, item.RoomConsumableId, newCode);
            return Ok(CurrencyResponse(CurrencyOp.Success, Status.Success, id.Value, currencyId,
                newBalance, ToInventoryWire(own, item)));
        }

        [HttpPut("/api/roomconsumables/v1/roomConsumable/{roomConsumableId:guid}/consume")]
        [HttpPost("/api/roomconsumables/v1/roomConsumable/{roomConsumableId:guid}/consume")]
        public async Task<IActionResult> Consume(Guid roomConsumableId)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null) return Unauthorized("");

            var item = RoomConsumablesDB.GetConsumable(roomConsumableId);
            if (item == null)
                return Ok(new { Status = Status.RoomConsumableNotFound, InventoryItem = (object?)null });

            var own = RoomConsumablesDB.GetOwnership(id.Value, item.RoomConsumableId);
            if (own == null || own.Count <= 0)
                return Ok(new
                {
                    Status = Status.PlayerDoesNotOwnConsumable,
                    InventoryItem = own == null ? null : ToInventoryWire(own, item)
                });

            var (currentCode, newCode) = ReadConcurrency(await ReadBodyAsync());
            if (currentCode is Guid current && current != own.ConcurrencyCode)
                return Ok(new { Status = Status.ConcurrencyCodeMismatch, InventoryItem = ToInventoryWire(own, item) });

            RoomConsumablesDB.ConsumeOne(own, newCode);
            return Ok(new { Status = Status.Success, InventoryItem = ToInventoryWire(own, item) });
        }

        private static int? ValidateFields(string name, string description, bool hasPrice, int price)
        {
            if (name.Length == 0) return Status.NameTooShort;
            if (name.Length > 128) return Status.NameTooLong;
            if (description.Length > 1024) return Status.DescriptionTooLong;
            if (!hasPrice) return Status.PriceOrCurrencyMissing;
            if (price < 0) return Status.PriceTooLowTokens;
            if (price > 1_000_000) return Status.PriceTooHighTokens;
            return null;
        }

        private IActionResult StatusBody(int status) => Content(status.ToString(), "application/json");

        private static object EditResponse(int status, RoomConsumable? item = null) => new
        {
            Status = status,
            Consumable = item == null ? null : ToDescWire(item)
        };

        private static object CurrencyTokenResponse(
            int? balanceUpdateResult, int status, int balance, object? inventoryItem = null) => new
        {
            OperationResult = new { Status = status, InventoryItem = inventoryItem },
            BalanceUpdateResult = balanceUpdateResult,
            TokenBalanceResponse = new
            {
                CurrencyType = TokenCurrencyType,
                Balance = balance,
                Platform = 0
            }
        };

        private static object CurrencyResponse(
            int? balanceUpdateResult, int status, long playerId, Guid currencyId, int balance,
            object? inventoryItem = null) => new
        {
            OperationResult = new { Status = status, InventoryItem = inventoryItem },
            BalanceUpdateResult = balanceUpdateResult,
            CurrencyBalanceResponse = new
            {
                AccountId = (int)playerId,
                CurrencyId = currencyId,
                Balance = balance,
                ModifiedAt = DateTime.UtcNow
            }
        };

        private static object ToDescWire(RoomConsumable c) => new
        {
            RoomConsumableId = c.RoomConsumableId,
            c.RoomId,
            c.Name,
            Description = c.Description ?? "",
            ImageName = c.ImageName ?? "",
            c.Price,
            PurchaseCurrencyId = c.CurrencyId,
            ModifiedAt = DateTime.SpecifyKind(c.ModifiedAt, DateTimeKind.Utc)
        };

        private static object ToInventoryWire(RoomConsumableOwnership own, RoomConsumable item) => new
        {
            RoomConsumableId = item.RoomConsumableId,
            AccountId = (int)own.PlayerId,
            Count = Math.Max(0, own.Count),
            own.ConcurrencyCode,
            ModifiedAt = DateTime.SpecifyKind(own.ModifiedAt, DateTimeKind.Utc),
            Consumable = ToDescWire(item)
        };

        private async Task<Dictionary<string, JsonElement>> ReadBodyAsync()
        {
            var fields = new Dictionary<string, JsonElement>(StringComparer.OrdinalIgnoreCase);
            if (Request.ContentLength is 0) return fields;

            try
            {
                using var doc = await JsonDocument.ParseAsync(Request.Body);
                if (doc.RootElement.ValueKind != JsonValueKind.Object) return fields;

                foreach (var prop in doc.RootElement.EnumerateObject())
                {
                    fields[prop.Name] = prop.Value.Clone();
                    if (prop.Value.ValueKind == JsonValueKind.Object)
                        foreach (var inner in prop.Value.EnumerateObject())
                            fields.TryAdd(inner.Name, inner.Value.Clone());
                }
            }
            catch (JsonException)
            {
            }

            return fields;
        }

        private static string? ReadString(Dictionary<string, JsonElement> fields, string name) =>
            fields.TryGetValue(name, out var v) && v.ValueKind == JsonValueKind.String ? v.GetString() : null;

        private static long? ReadLong(Dictionary<string, JsonElement> fields, string name)
        {
            if (!fields.TryGetValue(name, out var v)) return null;
            return v.ValueKind switch
            {
                JsonValueKind.Number when v.TryGetInt64(out var n) => n,
                JsonValueKind.String when long.TryParse(v.GetString(), out var n) => n,
                _ => null
            };
        }

        private static Guid? ReadGuid(Dictionary<string, JsonElement> fields, string name) =>
            fields.TryGetValue(name, out var v) && v.ValueKind == JsonValueKind.String
            && Guid.TryParse(v.GetString(), out var guid)
                ? guid
                : null;

        /// <summary>Read { Price, CurrencyId } from the body, whether it arrives nested under
        /// <paramref name="wrapper"/> / PriceAndCurrency or flattened at the root.</summary>
        private static (int Price, Guid? CurrencyId, bool HasPrice) ReadPriceAndCurrency(
            Dictionary<string, JsonElement> fields, string wrapper = "PriceAndCurrency")
        {
            var scope = fields;
            if (fields.TryGetValue(wrapper, out var nested) && nested.ValueKind == JsonValueKind.Object)
            {
                scope = new Dictionary<string, JsonElement>(StringComparer.OrdinalIgnoreCase);
                foreach (var prop in nested.EnumerateObject()) scope[prop.Name] = prop.Value;
            }

            var price = ReadLong(scope, "Price");
            return ((int)(price ?? 0), ReadGuid(scope, "CurrencyId"), price != null);
        }

        private static (Guid? CurrentCode, Guid? NewCode) ReadConcurrency(Dictionary<string, JsonElement> fields)
        {
            var scope = fields;
            if (fields.TryGetValue("ConcurrencyCodes", out var nested) && nested.ValueKind == JsonValueKind.Object)
            {
                scope = new Dictionary<string, JsonElement>(StringComparer.OrdinalIgnoreCase);
                foreach (var prop in nested.EnumerateObject()) scope[prop.Name] = prop.Value;
            }

            return (ReadGuid(scope, "CurrentConcurrencyCode"), ReadGuid(scope, "NewConcurrencyCode"));
        }
    }
}