using Campus_live_rewrite.api.server.Classes;

namespace Campus_live_rewrite.api.server
{
    /// <summary>
    /// Reads the gift-drop store catalogs in Data/APIS/GiftDropStores/{StorefrontType}.json.
    ///
    /// Ported from the 2023 Campus server (D:\Puck\Campus-Server), whose StoreController had
    /// a working purchase flow. The comments here record what that server learned the hard
    /// way - they are not guesses.
    /// </summary>
    public static class StoreCatalog
    {
        public static string StoreDirectory =>
            Path.Combine(Environment.CurrentDirectory, "Data", "APIS", "GiftDropStores");

        /// <summary>One purchasable item, flattened out of a store file.</summary>
        public class GiftDropInfo
        {
            public int Cost;
            public int Currency = (int)CurrencyType.RecCenterTokens;  // currency the buyer pays in
            public int SubscriberCost = -1;      // from SubscriberPrices; -1 = none listed
            public int SubscriberCurrency = -1;
            public string Reward = "";           // GiftDrop.AvatarItemDesc, RAW (see PendingGiftBox)
            public string Name = "";
            public int Rarity;
            public int GiftDropId;
            public string ConsumableItemDesc = "";
            public int ItemCount = 1;            // GiftDrop.ItemCount - how many of a consumable one purchase gives
            public int AvatarItemType;
            public int GdCurrencyType;           // GiftDrop.CurrencyType
            public int GdCurrency;               // GiftDrop.Currency
            public string EquipmentPrefabName = "";
            public string EquipmentModificationGuid = "";
            /// <summary>A custom (downloadable) avatar item the row sells - GiftDrop.CustomAvatarItemId.</summary>
            public string CustomAvatarItemId = "";
            public string ThumbnailImageName = "";
            public int EquipmentItemId;
            public int AvatarItemId;
            public string StoreFile = "";
            public int PurchasableItemId;
            public int StorefrontType;

            /// <summary>Does the row put an AVATAR item in the box (legacy descriptor or custom item)?</summary>
            public bool IsAvatarItem => !string.IsNullOrWhiteSpace(Reward) || !string.IsNullOrWhiteSpace(CustomAvatarItemId);
        }

        /// <summary>
        /// AvatarItemType as the box / package must carry it: the type for an avatar item, JSON NULL
        /// for anything else. The client decides what a package holds by NULL checks - a skin or a
        /// consumable sent with AvatarItemType 0 is read as an avatar item with nothing to load
        /// ("Can't load item. It's saved in your Dorm mirror."). Every real storefront row of a skin
        /// or consumable carries null here (Watch_EnumValue_3.json), so this is the wire's rule.
        /// </summary>
        public static int? AvatarTypeFor(GiftDropInfo i) => i.IsAvatarItem ? i.AvatarItemType : (int?)null;
        /// <summary>The descriptor for the package: as written when there is one, else null (same reason).</summary>
        public static string? AvatarDescFor(GiftDropInfo i) => string.IsNullOrWhiteSpace(i.Reward) ? null : i.Reward;

        /// <summary>The catalog file backing a storefront id, or "" if it has none.</summary>
        public static string StoreFileForId(int id)
        {
            string specific = Path.Combine(StoreDirectory, $"{id}.json");
            return File.Exists(specific) ? specific : "";
        }

        public static string StorefrontName(int id) =>
            Enum.IsDefined(typeof(StorefrontType), id)
                ? ((StorefrontType)id).ToString()
                : $"Unknown({id})";

        /// <summary>
        /// Look up an item by PurchasableItemId.
        ///
        /// PurchasableItemIds are only unique WITHIN a storefront, not across them - id 487 is
        /// "Drum Major Hat (Yellow)" on the Watch store and "RECS Shirt (Green)" on Laser Tag,
        /// and the Isle/Crescendo catalogs collide on 971/972. So search the storefront the
        /// client said it was buying from FIRST, and only scan the rest when that store has no
        /// such id (or the client did not say which store).
        /// </summary>
        public static GiftDropInfo? FindStoreItem(int purchasableItemId, int storefrontType = -1)
        {
            // A catalog id (10000+) is a GENERATED Watch-store row - it exists in no file. The
            // same object the store was served from prices the purchase, which is the reference's
            // whole point: one table, both sides, or "Price has changed" on every buy.
            // Admin edits (Stores tab, StoreEdits) come first: an added row exists nowhere else,
            // and an edited one carries the price the store page now shows.
            if (storefrontType >= 0)
            {
                var own = StoreEdits.RowFor(storefrontType, purchasableItemId);
                if (own != null) return ParseRow(own, purchasableItemId, storefrontType);
                if (StoreEdits.IsRemoved(storefrontType, purchasableItemId)) return null;
            }
            else
            {
                var any = StoreEdits.RowsAnywhere(purchasableItemId);
                if (any.Count > 0) return ParseRow(any[0].row, purchasableItemId, any[0].store);
            }
            var gen = StoreGenerator.FindGenerated(purchasableItemId);
            if (gen != null)
                return StoreEdits.IsRemoved(StoreGenerator.WatchStorefront, purchasableItemId) ? null : gen;
            return FindStoreItemInFiles(purchasableItemId, storefrontType);
        }

        private static GiftDropInfo? FindStoreItemInFiles(int purchasableItemId, int storefrontType = -1)
        {
            if (!Directory.Exists(StoreDirectory)) return null;

            var files = new List<string>();
            if (storefrontType >= 0)
            {
                string preferred = StoreFileForId(storefrontType);
                if (!string.IsNullOrEmpty(preferred)) files.Add(preferred);
            }
            foreach (var f in Directory.GetFiles(StoreDirectory, "*.json"))
                if (!files.Contains(f)) files.Add(f);

            foreach (var file in files)
            {
                try
                {
                    using var doc = System.Text.Json.JsonDocument.Parse(File.ReadAllText(file));
                    if (!doc.RootElement.TryGetProperty("StoreItems", out var items)) continue;

                    foreach (var it in items.EnumerateArray())
                    {
                        if (!it.TryGetProperty("PurchasableItemId", out var pid)
                            || pid.ValueKind != System.Text.Json.JsonValueKind.Number
                            || pid.GetInt32() != purchasableItemId) continue;

                        return ParseRow(it, purchasableItemId, Path.GetFileName(file), StorefrontTypeFromFile(file));
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"[store] could not read {Path.GetFileName(file)}: {ex.Message}");
                }
            }

            return null;
        }

        /// <summary>One store row (the client's StoreItem shape) as the purchase paths price it.</summary>
        private static GiftDropInfo ParseRow(System.Text.Json.JsonElement it, int purchasableItemId, string storeFile, int storefront)
        {
            var info = new GiftDropInfo();

            if (it.TryGetProperty("Prices", out var prices)
                && prices.ValueKind == System.Text.Json.JsonValueKind.Array
                && prices.GetArrayLength() > 0)
            {
                var p0 = prices[0];
                if (p0.TryGetProperty("Price", out var pr) && pr.ValueKind == System.Text.Json.JsonValueKind.Number)
                    info.Cost = pr.GetInt32();
                if (p0.TryGetProperty("CurrencyType", out var cc) && cc.ValueKind == System.Text.Json.JsonValueKind.Number)
                    info.Currency = cc.GetInt32();
            }

            // Rec Room+ price. The client shows this to a subscriber and sends it back
            // as RequestedPrice. Ignoring it means RR+ members (everyone here) silently
            // overpay on every purchase.
            if (it.TryGetProperty("SubscriberPrices", out var sp)
                && sp.ValueKind == System.Text.Json.JsonValueKind.Array
                && sp.GetArrayLength() > 0)
            {
                var s0 = sp[0];
                if (s0.TryGetProperty("Price", out var spr) && spr.ValueKind == System.Text.Json.JsonValueKind.Number)
                    info.SubscriberCost = spr.GetInt32();
                if (s0.TryGetProperty("CurrencyType", out var scc) && scc.ValueKind == System.Text.Json.JsonValueKind.Number)
                    info.SubscriberCurrency = scc.GetInt32();
            }

            if (it.TryGetProperty("GiftDrop", out var gd))
            {
                string S(string k) => gd.TryGetProperty(k, out var v)
                    && v.ValueKind == System.Text.Json.JsonValueKind.String ? v.GetString() ?? "" : "";
                int I(string k) => gd.TryGetProperty(k, out var v)
                    && v.ValueKind == System.Text.Json.JsonValueKind.Number ? v.GetInt32() : 0;

                info.Reward = S("AvatarItemDesc");
                info.Name = S("FriendlyName");
                info.Rarity = I("Rarity");
                info.GiftDropId = I("GiftDropId");
                info.ConsumableItemDesc = S("ConsumableItemDesc");
                info.ItemCount = Math.Max(1, I("ItemCount"));
                info.AvatarItemType = I("AvatarItemType");
                info.GdCurrencyType = I("CurrencyType");
                info.GdCurrency = I("Currency");
                info.EquipmentPrefabName = S("EquipmentPrefabName");
                // UUID form, always - the client's equipment catalog is UUIDs and a
                // short-guid box could not resolve its skin (see PlayerDB.EquipmentSkinKey).
                info.EquipmentModificationGuid = Classes.ItemGuids.NormalizeGuid(S("EquipmentModificationGuid")) ?? S("EquipmentModificationGuid");
                info.CustomAvatarItemId = S("CustomAvatarItemId");
                info.ThumbnailImageName = S("ThumbnailImageName");
                info.EquipmentItemId = I("EquipmentItemId");
                info.AvatarItemId = I("AvatarItemId");
            }

            info.StoreFile = storeFile;
            info.PurchasableItemId = purchasableItemId;
            info.StorefrontType = storefront;

            // Hair dye is free (ConfigCampus.FreeHairDyes). Zeroed HERE, on the one
            // object every purchase path prices from - buyItem and bulkpurchase both
            // take their cost off this - so the store page and the till can never
            // disagree about what a colour costs.
            if (HairGrants.IsHairDye(info.Name))
            {
                info.Cost = 0;
                info.SubscriberCost = 0;
            }
            return info;
        }

        /// <summary>An admin-edited row (StoreEdits) as the purchase paths price it.</summary>
        private static GiftDropInfo ParseRow(Newtonsoft.Json.Linq.JObject row, int purchasableItemId, int storefront)
        {
            using var doc = System.Text.Json.JsonDocument.Parse(row.ToString(Newtonsoft.Json.Formatting.None));
            return ParseRow(doc.RootElement, purchasableItemId, "store-edits", storefront);
        }

        // The storefront id is the file's basename ("100.json" -> 100).
        private static int StorefrontTypeFromFile(string file)
            => int.TryParse(Path.GetFileNameWithoutExtension(file), out var t) ? t : -1;

        /// <summary>
        /// Search every storefront for items whose FriendlyName or descriptor contains the query,
        /// newest storefronts first, capped at <paramref name="max"/>. Used by the admin gift page
        /// to pick an item to give. Returns fully-resolved GiftDropInfo (with PurchasableItemId /
        /// StorefrontType) so the giver can re-look-up and hand out the exact box content.
        /// </summary>
        public static List<GiftDropInfo> SearchItems(string query, int max = 40)
        {
            var results = new List<GiftDropInfo>();
            if (!Directory.Exists(StoreDirectory) || string.IsNullOrWhiteSpace(query)) return results;
            string q = query.Trim().ToLowerInvariant();

            foreach (var file in Directory.GetFiles(StoreDirectory, "*.json"))
            {
                try
                {
                    using var doc = System.Text.Json.JsonDocument.Parse(File.ReadAllText(file));
                    if (!doc.RootElement.TryGetProperty("StoreItems", out var items)) continue;
                    int storefront = StorefrontTypeFromFile(file);

                    foreach (var it in items.EnumerateArray())
                    {
                        if (!it.TryGetProperty("PurchasableItemId", out var pid)
                            || pid.ValueKind != System.Text.Json.JsonValueKind.Number) continue;
                        if (!it.TryGetProperty("GiftDrop", out var gd)) continue;

                        string S(string k) => gd.TryGetProperty(k, out var v)
                            && v.ValueKind == System.Text.Json.JsonValueKind.String ? v.GetString() ?? "" : "";
                        int I(string k) => gd.TryGetProperty(k, out var v)
                            && v.ValueKind == System.Text.Json.JsonValueKind.Number ? v.GetInt32() : 0;

                        string name = S("FriendlyName");
                        string desc = S("AvatarItemDesc");
                        if (!name.ToLowerInvariant().Contains(q) && !desc.ToLowerInvariant().Contains(q))
                            continue;

                        results.Add(new GiftDropInfo
                        {
                            PurchasableItemId = pid.GetInt32(),
                            StorefrontType = storefront,
                            Name = name,
                            Reward = desc,
                            Rarity = I("Rarity"),
                            GiftDropId = I("GiftDropId"),
                            ConsumableItemDesc = S("ConsumableItemDesc"),
                            ItemCount = Math.Max(1, I("ItemCount")),
                            AvatarItemType = I("AvatarItemType"),
                            EquipmentPrefabName = S("EquipmentPrefabName"),
                            EquipmentModificationGuid = Classes.ItemGuids.NormalizeGuid(S("EquipmentModificationGuid")) ?? S("EquipmentModificationGuid"),
                            CustomAvatarItemId = S("CustomAvatarItemId"),
                            ThumbnailImageName = S("ThumbnailImageName"),
                            StoreFile = Path.GetFileName(file)
                        });

                        if (results.Count >= max) return results;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"[store] search could not read {Path.GetFileName(file)}: {ex.Message}");
                }
            }
            return results;
        }

        // The RR+ discount the CLIENT applies. Measured by the 2023 server from what the client
        // sends as RequestedPrice: 3000 -> 2700, 2500 -> 2250, 1500 -> 1350 - all exactly 10%.
        //
        // It is NOT the store file's SubscriberDiscountPercent: the Watch store sets that to 0
        // and its SubscriberPrices equal the full price, yet the client still asks to pay 10%
        // less. The rate lives in the client, and 10 is the observed value.
        public const int RRPlusDiscountPercent = 10;

        /// <summary>
        /// What an RR+ member actually pays: the better of the store's explicit SubscriberPrice
        /// and the flat RR+ discount. Never more than the base price.
        /// Everyone on this server is a subscriber - UpdateAndGetSubscription always reports active.
        /// </summary>
        public static int SubscriberPriceFor(GiftDropInfo item)
        {
            int best = item.Cost;

            if (item.SubscriberCost >= 0
                && (item.SubscriberCurrency < 0 || item.SubscriberCurrency == item.Currency)
                && item.SubscriberCost < best)
                best = item.SubscriberCost;

            int pct = (int)Math.Floor(item.Cost * (100 - RRPlusDiscountPercent) / 100.0);
            if (pct < best) best = pct;

            return Math.Max(0, best);
        }

        // Gift id for the purchase-reveal payload and the stored box. Was a process counter from
        // 5000 that restarted on every deploy, so every player's first purchase after a restart
        // was box 5001 - the collision PlayerDB.NextGiftPackageId explains. int32, see
        // PendingGiftBox.NumericId.
        public static int NextPurchaseGiftId() => Campus_live_rewrite.api.dbs.PlayerDB.NextGiftPackageId();

        /// <summary>Only items sold for Rec Center Tokens can be gifted (never a room-currency / ticket item).</summary>
        public static bool PricedInTokens(Newtonsoft.Json.Linq.JObject row)
        {
            var prices = row["Prices"] as Newtonsoft.Json.Linq.JArray;
            if (prices == null || prices.Count == 0) return false;
            return prices.Any(p => ((int?)p["CurrencyType"] ?? 0) == (int)Classes.CurrencyType.RecCenterTokens);
        }

        // A file storefront with CanBeGifted set on every row (the captures never carried it, so
        // the store's gift button never showed). Cached per file + mtime.
        private static readonly Dictionary<string, (long ticks, string json)> _giftable = new();
        public static string? StoreJsonGiftable(string path, string? baseJson = null)
        {
            try
            {
                long ticks = File.GetLastWriteTimeUtc(path).Ticks;
                string key = path + (baseJson != null ? "#free" : "");
                lock (_giftable)
                {
                    if (_giftable.TryGetValue(key, out var hit) && hit.ticks == ticks) return hit.json;
                }
                var root = Newtonsoft.Json.Linq.JObject.Parse(baseJson ?? File.ReadAllText(path));
                foreach (var it in root["StoreItems"] as Newtonsoft.Json.Linq.JArray ?? new Newtonsoft.Json.Linq.JArray())
                    if (it is Newtonsoft.Json.Linq.JObject o) { StoreGenerator.ShapeRow(o); o["CanBeGifted"] = PricedInTokens(o); }
                string json = root.ToString(Newtonsoft.Json.Formatting.None);
                lock (_giftable) _giftable[key] = (ticks, json);
                return json;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[store] could not mark {Path.GetFileName(path)} giftable: {ex.Message}");
                return null;
            }
        }
    }
}