using System.Text;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace Campus_live_rewrite.api.server
{
    /// <summary>
    /// In-memory index of the UGC custom-avatar-item catalog (Data/APIS/items/UGC.json, ~24k items,
    /// ~87MB), the imported overlay (ImportedUGC.json - the dev locker) and the items players made
    /// here (CreatedUGC.json). Loaded once at startup.
    ///
    /// MEMORY. Each record is kept as its compact UTF-8 JSON (the whole catalog is ~45 MB that
    /// way) plus a small typed header - <see cref="Rec"/> - with the handful of fields the routes
    /// filter and sort on. A <see cref="JObject"/> is only built when a record is actually being
    /// served (a search page, a /bulk lookup, a locker page), and thrown away after. Holding the
    /// catalog as JObjects cost ~640 MB for the raw file alone (measured), and loading it as one
    /// parsed tree put the peak well over a gigabyte; the server sat at 2.3 GB RSS. The file is
    /// also read item by item (JsonTextReader), never as one parsed tree, so the peak is one item.
    ///
    /// Dates are kept as the strings they arrived as (DateParseHandling.None) - the catalog's own
    /// spelling is what the client got before, and ISO strings sort correctly as text.
    /// </summary>
    public static class CustomItemsCache
    {
        /// <summary>One catalog record: its JSON bytes and the fields the server reasons about.</summary>
        public sealed class Rec
        {
            public string Id = "";
            public byte[] Json = Array.Empty<byte>();
            public ulong Creator;
            public int Accessibility;
            public int OutfitType = -1;
            public int? BaseAvatarItemId;
            public bool Featured;
            public string Created = "";
            public int Price;
            public string Name = "";
            public string Description = "";
            /// <summary>Has asset-bundle saves (a modelled item) as opposed to a PNG shirt design.</summary>
            public bool BundleBacked;
            /// <summary>
            /// Exclusive: tagged "adminonly" (Tags[].Value). Never listed in any store / profile and
            /// never sold - only the admin panel's gift gives it. Owners still see and wear it normally.
            /// </summary>
            public bool AdminOnly;

            /// <summary>The record as the client receives it. A fresh object every call.</summary>
            public JObject ToJObject() => BundleHashes.Stamp(ParseRecord(Json));

            public static Rec From(JObject o)
            {
                // Clothing floor (owner rule): a custom item that is for sale costs at least
                // StoreGenerator.DefaultPrice. Applied to the record itself so the price the client
                // displays and the price the buy charges are the same number.
                int rawPrice = (int?)o["Price"] ?? 0;
                if (rawPrice > 0 && rawPrice < StoreGenerator.DefaultPrice) o["Price"] = StoreGenerator.DefaultPrice;
                var r = new Rec
                {
                    Id = (string?)o["CustomAvatarItemId"] ?? "",
                    Creator = (ulong?)o["CreatorAccountId"] ?? 0,
                    Accessibility = (int?)o["Accessibility"] ?? 0,
                    OutfitType = (int?)o["OutfitType"] ?? -1,
                    BaseAvatarItemId = (int?)o["BaseAvatarItemId"],
                    Featured = (bool?)o["IsFeatured"] == true,
                    Created = (string?)o["CreatedAt"] ?? "",
                    Price = (int?)o["Price"] ?? 0,
                    Name = (string?)o["Name"] ?? "",
                    Description = (string?)o["Description"] ?? "",
                    BundleBacked = o["CurrentSaves"] is JArray saves && saves.Count > 0,
                    AdminOnly = o["Tags"] is JArray tags && tags.Any(t => string.Equals((string?)t?["Value"], "adminonly", StringComparison.OrdinalIgnoreCase)),
                };
                r.Json = Encoding.UTF8.GetBytes(o.ToString(Formatting.None));
                return r;
            }
        }

        private static readonly JsonSerializerSettings NoDateParsing = new() { DateParseHandling = DateParseHandling.None };

        public static JObject ParseRecord(byte[] json)
        {
            using var sr = new StreamReader(new MemoryStream(json, writable: false), Encoding.UTF8);
            using var jr = new JsonTextReader(sr) { DateParseHandling = DateParseHandling.None };
            return JObject.Load(jr);
        }

        private static Dictionary<string, Rec> _byId = new(StringComparer.OrdinalIgnoreCase);
        private static List<Rec> _all = new();
        private static Dictionary<ulong, List<Rec>> _byCreator = new();

        // IMPORTED UGC = items whose real .assetbundle/.png assets have been hosted on THIS server
        // (via the admin importer). These are what a dev "owns" in the UGC dev-locker. Kept as a
        // distinct set so devs don't get the whole catalog dumped into their wardrobe.
        private static readonly List<Rec> _imported = new();
        private static readonly HashSet<string> _importedIds = new(StringComparer.OrdinalIgnoreCase);
        // The official first-party items (FirstPartyUGC.json) - the Coach's stock, account 1.
        private static readonly HashSet<string> _firstPartyIds = new(StringComparer.OrdinalIgnoreCase);
        private static readonly object _lock = new();

        public static string ImportedPath =>
            Path.Combine(Environment.CurrentDirectory, "Data", "APIS", "items", "ImportedUGC.json");

        // FIRST-PARTY (Coach) custom items from the reference export, priced from a real Watch
        // storefront - ImportRealStore.py writes it. Loaded over UGC.json like part of the base
        // catalog (its record wins for an id both hold, which is how the prices land); NOT the
        // dev locker, so nobody's wardrobe grows by 2700 items.
        public static string FirstPartyPath =>
            Path.Combine(Environment.CurrentDirectory, "Data", "APIS", "items", "FirstPartyUGC.json");

        // PLAYER-CREATED items (the in-game costume maker, POST /api/customAvatarItems/v1): their own
        // file so a deploy can never clobber them, indexed like the rest but NOT marked imported.
        public static string CreatedPath =>
            Path.Combine(Environment.CurrentDirectory, "Data", "APIS", "items", "CreatedUGC.json");
        private static readonly List<Rec> _created = new();

        // CAMPUSSTUDIO items (recolours published from the CampusStudio app through
        // StudioController): their own file, loaded after FirstPartyUGC.json and treated as
        // first-party (Coach) stock. Written only by the server, so a deploy never clobbers it.
        public static string StudioPath =>
            Path.Combine(Environment.CurrentDirectory, "Data", "APIS", "items", "StudioUGC.json");
        private static readonly List<Rec> _studio = new();

        public static int Count => _all.Count;
        public static int ImportedCount { get { lock (_lock) return _imported.Count; } }

        /// <summary>Every record (catalog + imported + created), as compact records.</summary>
        public static IReadOnlyList<Rec> AllRecs => _all;

        /// <summary>The imported (dev locker) records.</summary>
        public static List<Rec> ImportedRecs { get { lock (_lock) return new List<Rec>(_imported); } }
        public static HashSet<string> ImportedIds { get { lock (_lock) return new HashSet<string>(_importedIds, StringComparer.OrdinalIgnoreCase); } }

        /// <summary>Walk a {"Results":[...]} file one object at a time - never the whole tree.</summary>
        private static IEnumerable<JObject> ReadResults(string path)
        {
            using var sr = new StreamReader(path, Encoding.UTF8);
            using var jr = new JsonTextReader(sr) { DateParseHandling = DateParseHandling.None };
            // Find the Results array, then yield each object in it.
            while (jr.Read())
            {
                if (jr.TokenType == JsonToken.PropertyName && string.Equals((string?)jr.Value, "Results", StringComparison.OrdinalIgnoreCase))
                {
                    if (!jr.Read() || jr.TokenType != JsonToken.StartArray) yield break;
                    while (jr.Read() && jr.TokenType != JsonToken.EndArray)
                    {
                        if (jr.TokenType == JsonToken.StartObject)
                            yield return JObject.Load(jr);
                    }
                    yield break;
                }
            }
        }

        public static void Load()
        {
            _droppedItems = 0; _droppedSaves = 0;
            try
            {
                string ugc = Path.Combine(Environment.CurrentDirectory, "Data", "APIS", "items", "UGC.json");
                string legacy = Path.Combine(Environment.CurrentDirectory, "Data", "APIS", "customitems.json");
                string path = File.Exists(ugc) ? ugc : legacy;

                var byId = new Dictionary<string, Rec>(StringComparer.OrdinalIgnoreCase);
                var all = new List<Rec>();

                if (File.Exists(path))
                {
                    foreach (var o in ReadResults(path))
                    {
                        string? id = (string?)o["CustomAvatarItemId"];
                        if (string.IsNullOrEmpty(id)) continue;
                        if (!PassesCutoff(o)) continue;
                        SanitizeForClient(o);
                        var rec = Rec.From(o);
                        if (byId.TryGetValue(id, out var existing)) all.Remove(existing);
                        byId[id] = rec;
                        all.Add(rec);
                        // NOT indexed by creator: the catalog's CreatorAccountId values are the ORIGINAL
                        // RecNet creators' ids, which are not accounts here. Only CreatedUGC (made on
                        // this server) maps to local accounts; see AddOrUpdate.
                    }
                    Console.WriteLine($"[ugc] loaded {all.Count} custom avatar items from {Path.GetFileName(path)}");
                }
                else Console.WriteLine("[ugc] no UGC.json / customitems.json found - base custom items empty");

                _byId = byId; _all = all; _byCreator = new Dictionary<ulong, List<Rec>>();
                lock (_lock) { _imported.Clear(); _importedIds.Clear(); }

                // Merge the imported overlay LAST so its records win (they carry hosted-asset refs).
                if (File.Exists(ImportedPath))
                {
                    try
                    {
                        int n = 0;
                        foreach (var o in ReadResults(ImportedPath)) { AddOrUpdate(o, persist: false); n++; }
                        Console.WriteLine($"[ugc] merged {n} imported UGC item(s) from ImportedUGC.json (dev locker)");
                    }
                    catch (Exception iex) { Console.WriteLine($"[ugc] ImportedUGC.json load failed: {iex.Message}"); }
                }

                // First-party items LAST: the same 2830 Coach items the dev locker was imported
                // from, now carrying the real store's price (ImportRealStore.py). A record that is
                // already in the locker stays in it - only the record is swapped.
                if (File.Exists(FirstPartyPath))
                {
                    try
                    {
                        int added = 0, replaced = 0;
                        lock (_lock) _firstPartyIds.Clear();
                        foreach (var o in ReadResults(FirstPartyPath))
                        {
                            string? id = (string?)o["CustomAvatarItemId"];
                            if (string.IsNullOrEmpty(id)) continue;
                            if (!PassesCutoff(o)) continue;
                            SanitizeForClient(o);
                            var rec = Rec.From(o);
                            lock (_lock)
                            {
                                if (_byId.TryGetValue(id, out var existing))
                                {
                                    _all.Remove(existing);
                                    if (_imported.Remove(existing)) _imported.Add(rec);
                                    replaced++;
                                }
                                else added++;
                                _byId[id] = rec;
                                _all.Add(rec);
                                _firstPartyIds.Add(id);
                            }
                        }
                        Console.WriteLine($"[ugc] FirstPartyUGC.json: {added} first-party item(s) added, {replaced} replaced (priced)");
                    }
                    catch (Exception fex) { Console.WriteLine($"[ugc] FirstPartyUGC.json load failed: {fex.Message}"); }
                }

                lock (_lock) _studio.Clear();
                if (File.Exists(StudioPath))
                {
                    try
                    {
                        int n = 0;
                        foreach (var o in ReadResults(StudioPath)) if (AddStudio(o, persist: false) != null) n++;
                        Console.WriteLine($"[ugc] StudioUGC.json: {n} CampusStudio item(s)");
                    }
                    catch (Exception sex) { Console.WriteLine($"[ugc] StudioUGC.json load failed: {sex.Message}"); }
                }

                lock (_lock) _created.Clear();
                if (File.Exists(CreatedPath))
                {
                    try
                    {
                        int n = 0;
                        foreach (var o in ReadResults(CreatedPath))
                        {
                            var rec = AddOrUpdate(o, persist: false, markImported: false);
                            if (rec != null) { lock (_lock) _created.Add(rec); n++; }
                        }
                        Console.WriteLine($"[ugc] loaded {n} player-created item(s) from CreatedUGC.json");
                    }
                    catch (Exception cex) { Console.WriteLine($"[ugc] CreatedUGC.json load failed: {cex.Message}"); }
                }
                if (ConfigCampus.CustomItemCreatedCutoffUtc != null)
                    Console.WriteLine($"[ugc] cutoff {ConfigCampus.CustomItemCreatedCutoffUtc:u}: dropped {_droppedItems} item(s) and {_droppedSaves} newer save(s) the clients can't read; {_all.Count} item(s) served");

                long bytes = 0; foreach (var r in _all) bytes += r.Json.Length;
                Console.WriteLine($"[ugc] catalog held as {bytes / (1024 * 1024)} MB of compact JSON ({_all.Count} record(s))");
                GC.Collect();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[ugc] load failed: {ex.Message}");
            }
        }

        /// <summary>
        /// Upsert one custom item into every index and mark it IMPORTED (dev-locker eligible).
        /// Thread-safe; used both at Load (persist:false) and live from the admin importer
        /// (persist:true appends it to ImportedUGC.json so it survives a restart). Returns the
        /// stored record, or null when the item was refused by the cutoff.
        /// </summary>
        public static Rec? AddOrUpdate(JObject item, bool persist = true, bool markImported = true)
        {
            string? id = (string?)item["CustomAvatarItemId"];
            if (string.IsNullOrEmpty(id)) return null;
            if (markImported && !PassesCutoff(item)) return null;   // a player's own creation is always current
            SanitizeForClient(item);
            var rec = Rec.From(item);

            lock (_lock)
            {
                if (_byId.TryGetValue(id, out var existing))
                {
                    _all.Remove(existing);
                    if (_byCreator.TryGetValue(existing.Creator, out var oldList)) oldList.Remove(existing);
                    _imported.Remove(existing);
                    _created.Remove(existing);
                }
                _byId[id] = rec;
                _all.Add(rec);
                if (rec.Creator != 0 && !markImported)   // imported catalog records keep their RecNet creator id; only local creations are attributed
                {
                    if (!_byCreator.TryGetValue(rec.Creator, out var list)) _byCreator[rec.Creator] = list = new List<Rec>();
                    list.Add(rec);
                }
                if (markImported)
                {
                    _importedIds.Add(id);
                    _imported.Add(rec);
                }
            }

            if (persist && markImported) PersistImported();
            return rec;
        }

        /// <summary>
        /// Upsert a CampusStudio item: indexed exactly like a first-party item (so the store, the
        /// dev locker and gifting all see it) and persisted to StudioUGC.json. Live - no restart.
        /// </summary>
        public static Rec? AddStudio(JObject item, bool persist = true)
        {
            string? id = (string?)item["CustomAvatarItemId"];
            if (string.IsNullOrEmpty(id)) return null;
            if (!PassesCutoff(item)) return null;
            SanitizeForClient(item);
            var rec = Rec.From(item);
            lock (_lock)
            {
                if (_byId.TryGetValue(id, out var existing))
                {
                    _all.Remove(existing);
                    if (_imported.Remove(existing)) _imported.Add(rec);
                }
                _byId[id] = rec;
                _all.Add(rec);
                _firstPartyIds.Add(id);
                _studio.RemoveAll(x => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase));
                _studio.Add(rec);
            }
            if (persist) PersistStudio();
            return rec;
        }

        /// <summary>
        /// Delete a CampusStudio item from every index and from StudioUGC.json (live - no restart). Only items that
        /// were published through Studio are in that list; anything else answers null. Returns the removed record.
        /// </summary>
        public static JObject? RemoveStudio(string? id)
        {
            if (string.IsNullOrEmpty(id)) return null;
            Rec? rec;
            lock (_lock)
            {
                if (!_studio.Any(x => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase))) return null;
                if (!_byId.TryGetValue(id!, out rec)) return null;
                _byId.Remove(id!);
                _all.Remove(rec);
                _firstPartyIds.Remove(id!);
                _studio.RemoveAll(x => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase));
                if (_byCreator.TryGetValue(rec.Creator, out var list)) list.Remove(rec);
                _importedIds.Remove(id!);
                _imported.Remove(rec);
                _created.Remove(rec);
            }
            PersistStudio();
            return rec.ToJObject();
        }

        /// <summary>Does any catalog record's JSON still contain this text (a bundle or thumbnail file name)?</summary>
        public static bool AnyRecordMentions(string needle)
        {
            var nb = Encoding.UTF8.GetBytes(needle);
            lock (_lock) foreach (var r in _all) if (r.Json.AsSpan().IndexOf(nb) >= 0) return true;
            return false;
        }

        public static bool IsStudio(string? id)
        {
            if (string.IsNullOrEmpty(id)) return false;
            lock (_lock) return _studio.Any(x => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase));
        }

        private static void PersistStudio()
        {
            try
            {
                List<Rec> list;
                lock (_lock) list = new List<Rec>(_studio);
                WriteResults(StudioPath, list);
            }
            catch (Exception ex) { Console.WriteLine($"[ugc] persist studio failed: {ex.Message}"); }
        }

        /// <summary>First-party (Coach + CampusStudio) modelled items, admin-only included - the CampusStudio library.</summary>
        public static List<Rec> StudioLibraryRecs()
        {
            List<Rec> all; HashSet<string> ids;
            lock (_lock) { all = new List<Rec>(_all); ids = new HashSet<string>(_firstPartyIds, StringComparer.OrdinalIgnoreCase); }
            return all.Where(r => ids.Contains(r.Id) && r.BundleBacked).OrderBy(r => r.Name, StringComparer.OrdinalIgnoreCase).ToList();
        }

        /// <summary>Register a player-created item (costume maker) and persist it to CreatedUGC.json.</summary>
        public static void AddCreated(JObject item)
        {
            var rec = AddOrUpdate(item, persist: false, markImported: false);
            if (rec == null) return;
            lock (_lock)
            {
                _created.RemoveAll(x => string.Equals(x.Id, rec.Id, StringComparison.OrdinalIgnoreCase));
                _created.Add(rec);
            }
            PersistCreated();
        }

        /// <summary>Store an edited created item (PUT) and re-persist. The record is replaced, not patched in place.</summary>
        public static void CreatedChanged(JObject item) => AddCreated(item);

        /// <summary>Remove an item from every index (DELETE). Returns the record, or null.</summary>
        public static JObject? Remove(string? id)
        {
            if (string.IsNullOrEmpty(id)) return null;
            Rec? rec;
            lock (_lock)
            {
                if (!_byId.TryGetValue(id!, out rec)) return null;
                _byId.Remove(id!);
                _all.Remove(rec);
                if (_byCreator.TryGetValue(rec.Creator, out var list)) list.Remove(rec);
                _importedIds.Remove(id!);
                _imported.Remove(rec);
                _created.Remove(rec);
            }
            PersistCreated();
            return rec.ToJObject();
        }

        // {"Results":[<record bytes>,...],"TotalResults":N}, streamed - no tree is built to write it.
        private static void WriteResults(string path, List<Rec> recs)
        {
            Directory.CreateDirectory(Path.GetDirectoryName(path)!);
            string tmp = path + ".tmp";
            using (var fs = new FileStream(tmp, FileMode.Create, FileAccess.Write, FileShare.None))
            {
                var head = Encoding.UTF8.GetBytes("{\"Results\":[");
                fs.Write(head, 0, head.Length);
                for (int i = 0; i < recs.Count; i++)
                {
                    if (i > 0) fs.WriteByte((byte)',');
                    fs.Write(recs[i].Json, 0, recs[i].Json.Length);
                }
                var tail = Encoding.UTF8.GetBytes($"],\"TotalResults\":{recs.Count}}}");
                fs.Write(tail, 0, tail.Length);
            }
            File.Move(tmp, path, overwrite: true);
        }

        private static void PersistCreated()
        {
            try
            {
                List<Rec> list;
                lock (_lock) list = new List<Rec>(_created);
                WriteResults(CreatedPath, list);
            }
            catch (Exception ex) { Console.WriteLine($"[ugc] persist created failed: {ex.Message}"); }
        }

        /// <summary>Write the imported overlay to disk once (use after a batch of AddOrUpdate(persist:false)).</summary>
        public static void FlushImported() => PersistImported();

        private static void PersistImported()
        {
            try
            {
                List<Rec> list;
                lock (_lock) list = new List<Rec>(_imported);
                WriteResults(ImportedPath, list);
            }
            catch (Exception ex) { Console.WriteLine($"[ugc] persist imported failed: {ex.Message}"); }
        }

        // Keys of a save's AdditionalConfiguration envelope the 2021.3 client (PC + Quest
        // 20250718.01) can read: {"v":1,"d":{...}}. Newer exports add top-level keys ("ls":1 on
        // every 2024+ save); the client's SerializedAvatarItemData converter reads v and d and then
        // expects the object to END, so an extra key throws "The converter read too much or not
        // enough. Path: $ ... BytePositionInLine: 53" inside ApplyDownloadableAvatarItem and the
        // item never gets as far as its bundle. Unknown keys INSIDE d are only warned about
        // ("unhandled property ... (et)"), so d is passed through untouched.
        private static readonly HashSet<string> ConfigEnvelopeKeys = new(StringComparer.Ordinal) { "v", "d" };

        private static int _droppedItems, _droppedSaves;

        /// <summary>
        /// Apply ConfigCampus.CustomItemCreatedCutoffUtc: false when the ITEM was created after the
        /// cutoff (caller skips it). Saves created after the cutoff are removed from the record; an
        /// item left with no saves at all is dropped too (nothing renderable would remain).
        /// </summary>
        private static bool PassesCutoff(JObject item)
        {
            var cutoff = ConfigCampus.CustomItemCreatedCutoffUtc;
            if (cutoff == null) return true;
            if (After(item["CreatedAt"], cutoff.Value)) { _droppedItems++; return false; }
            if (item["CurrentSaves"] is JArray saves && saves.Count > 0)
            {
                var late = saves.Where(s => After(s["CreatedAt"], cutoff.Value)).ToList();
                foreach (var s in late) { s.Remove(); _droppedSaves++; }
                if (saves.Count == 0) { _droppedItems++; return false; }
            }
            return true;
        }

        private static bool After(JToken? createdAt, DateTime cutoffUtc)
        {
            string? s = (string?)createdAt;
            return !string.IsNullOrEmpty(s)
                && DateTime.TryParse(s, System.Globalization.CultureInfo.InvariantCulture,
                                     System.Globalization.DateTimeStyles.AdjustToUniversal | System.Globalization.DateTimeStyles.AssumeUniversal, out var dt)
                && dt > cutoffUtc;
        }

        // Keys the client's converter accepts INSIDE d.d (the per-slot attach/render block). This is
        // every key the 2024-era catalogs use; a key it doesn't know is first warned about ("Found
        // an unhandled property when parsing SerializedAvatarItemData | propertyName(et)") and then
        // the SAME "read too much or not enough" exception follows - and because the client applies
        // the whole owned list in one pass, one bad item (a sword exported in 2025-08 carrying
        // "et") aborts registration of every item after it, which surfaces as bundles that download
        // but "can't load". Unknown nested keys are stripped and logged.
        private static readonly HashSet<string> ConfigNestedKnownKeys = new(StringComparer.Ordinal)
            { "ap", "fp", "af", "uu", "hh", "fr", "uv", "c", "r", "ho", "hp", "l", "dc", "p", "hr", "ha", "hs", "t" };
        private static int _strippedNested;

        /// <summary>Strip the parts of an item record the clients' converters can't parse (see ConfigEnvelopeKeys).</summary>
        public static void SanitizeForClient(JObject item)
        {
            if (item["CurrentSaves"] is not JArray saves) return;
            foreach (var t in saves)
            {
                if (t is not JObject save) continue;
                string? ac = (string?)save["AdditionalConfiguration"];
                if (string.IsNullOrWhiteSpace(ac)) continue;
                try
                {
                    var cfg = JObject.Parse(ac);
                    bool changed = false;
                    var extra = cfg.Properties().Where(pr => !ConfigEnvelopeKeys.Contains(pr.Name)).ToList();
                    foreach (var pr in extra) { pr.Remove(); changed = true; }
                    if (cfg["d"] is JObject d && d["d"] is JObject nested)
                    {
                        var unknown = nested.Properties().Where(pr => !ConfigNestedKnownKeys.Contains(pr.Name)).ToList();
                        foreach (var pr in unknown)
                        {
                            if (_strippedNested++ < 20)
                                Console.WriteLine($"[ugc] '{(string?)item["Name"]}' ({(string?)item["CustomAvatarItemId"]}): stripped unknown config key d.d.{pr.Name} (client can't parse it)");
                            pr.Remove(); changed = true;
                        }
                    }
                    if (!changed) continue;
                    save["AdditionalConfiguration"] = cfg.ToString(Formatting.None);
                }
                catch { /* not JSON - leave it for the client to reject */ }
            }
        }

        /// <summary>
        /// A custom item the client renders from an ASSET BUNDLE (CurrentSaves carry UnityAsset
        /// files), as opposed to a custom SHIRT - a PNG design (DesignFilename) drawn onto a stock
        /// base item, which the client paints itself and needs no bundle for.
        ///
        /// The two are what the store search's tabs are: the CLOTHING tab asks for the modelled
        /// outfit types (0, 2, 3, 10, 20, 100-103, 200, 300, 301) and the CUSTOM CLOTHING tab asks
        /// for 105, the shirt designs. Every bundle-backed item in the catalog was built for a
        /// newer Unity than this client and comes up "Can't load item", so while
        /// ConfigCampus.HiddenItemsStorefronts is on they are kept out of the store (see
        /// StoreListable) - the Clothing tab goes empty, and the Custom Clothing tab keeps the
        /// shirts, which do render.
        /// </summary>
        public static bool IsBundleBacked(Rec r) => r.BundleBacked;

        /// <summary>Whether the store (search, featured, hot) may list this item right now.</summary>
        public static bool StoreListable(Rec r) =>
            !r.AdminOnly && (!ConfigCampus.HiddenItemsStorefronts || !r.BundleBacked)
            || (!r.AdminOnly && ConfigCampus.ServeFirstPartyClothing && IsFirstParty(r));

        /// <summary>An official first-party item (FirstPartyUGC.json) - the Coach's stock.</summary>
        public static bool IsFirstParty(Rec r) { lock (_lock) return _firstPartyIds.Contains(r.Id); }

        /// <summary>The Coach's stock (account 1): every published first-party item, newest first.</summary>
        /// <summary>Published, modelled custom items whose name contains q (admin gift search).</summary>
        public static List<Rec> SearchRecs(string q, int cap)
        {
            if (string.IsNullOrWhiteSpace(q)) return new List<Rec>();
            List<Rec> all; lock (_lock) all = _all.ToList();
            return all.Where(r => r.Accessibility != 0 && r.BundleBacked && r.Name.Contains(q, StringComparison.OrdinalIgnoreCase))
                      .OrderBy(r => r.Name.Length).ThenBy(r => r.Name).Take(cap).ToList();
        }

        public static List<Rec> FirstPartyRecs()
        {
            HashSet<string> ids; lock (_lock) ids = new HashSet<string>(_firstPartyIds, StringComparer.OrdinalIgnoreCase);
            return _all.Where(r => ids.Contains(r.Id) && r.Accessibility != 0 && !r.AdminOnly)
                       .OrderByDescending(r => r.Created).ThenBy(r => r.Id).ToList();
        }

        // ---- the developer locker (UGC half) --------------------------------------------------
        private static List<Rec>? _devLocker;
        private static DateTime _devLockerAt;
        private static int _devLockerSource = -1;
        private static readonly object _devLockerLock = new();

        /// <summary>
        /// Every custom item a developer owns: every first-party (Coach) item and every published
        /// player-made / imported item - modelled ones whose bundles we don't host included (they
        /// show but can't load). Rebuilt every 10 minutes (or when the item count changes).
        /// </summary>
        public static List<Rec> DevLockerRecs()
        {
            lock (_devLockerLock)
            {
                int count; lock (_lock) count = _all.Count;
                if (_devLocker != null && count == _devLockerSource && DateTime.UtcNow - _devLockerAt < TimeSpan.FromMinutes(10))
                    return new List<Rec>(_devLocker);

                List<Rec> all; HashSet<string> firstParty;
                lock (_lock) { all = new List<Rec>(_all); firstParty = new HashSet<string>(_firstPartyIds, StringComparer.OrdinalIgnoreCase); }
                var sw = System.Diagnostics.Stopwatch.StartNew();
                var locker = new List<Rec>();
                int skipped = 0;
                // EVERY published item (owner's call 2026-09-26: "every single item") - including
                // imported modelled items whose bundles we don't host; `skipped` only counts those
                // for the log. Other players' unpublished drafts stay private.
                foreach (var r in all)
                {
                    if (firstParty.Contains(r.Id)) { locker.Add(r); continue; }
                    if (r.Accessibility == 0) continue;                 // someone's unpublished draft
                    if (r.BundleBacked && !BundlesHeld(r)) skipped++;
                    locker.Add(r);
                }
                // First-party first (the Coach's stock), then the rest newest first.
                locker = locker.OrderByDescending(r => firstParty.Contains(r.Id)).ThenByDescending(r => r.Created).ToList();
                Console.WriteLine($"[ugc] dev locker: {locker.Count} custom item(s) ({skipped} of them modelled items without hosted bundles) in {sw.ElapsedMilliseconds} ms");
                _devLocker = locker; _devLockerAt = DateTime.UtcNow; _devLockerSource = count;
                return new List<Rec>(locker);
            }
        }

        /// <summary>Does this server hold every bundle this item's saves name?</summary>
        private static bool BundlesHeld(Rec r)
        {
            try
            {
                var saves = ParseRecord(r.Json)["CurrentSaves"] as JArray;
                if (saves == null || saves.Count == 0) return true;
                foreach (var s in saves)
                    foreach (var k in new[] { "UnityAsset", "UnityAsset2" })
                    {
                        var n = (string?)s[k];
                        if (!string.IsNullOrWhiteSpace(n) && BundleHashes.Resolve(n) == null) return false;
                    }
                return true;
            }
            catch { return false; }
        }

        /// <summary>The Coach's account - who first-party items are filed under (reference COACH_ACCOUNT_ID).</summary>
        public const ulong CoachAccountId = 1;

        /// <summary>All imported UGC (the dev-locker set), materialised. Prefer ImportedRecs + paging.</summary>
        public static List<JObject> Imported => ImportedRecs.Select(r => r.ToJObject()).ToList();
        public static bool IsImported(string? id) { if (string.IsNullOrEmpty(id)) return false; lock (_lock) return _importedIds.Contains(id!); }

        /// <summary>Resolve specific ids (the outfit-build /bulk lookup). Order/duplicates follow input.</summary>
        public static List<JObject> GetByIds(IEnumerable<string?> ids)
        {
            // Every id resolves that exists - bundle-backed ones included. Withholding those here
            // (tried 2026-09-22, to keep the client off the CAI bundle path) emptied the locker
            // and the store: the client re-resolves its whole cached custom-item set through this
            // call at login (~5,000 ids in batches of 500) and does not cope with misses.
            var res = new List<JObject>();
            foreach (var id in ids)
                if (!string.IsNullOrEmpty(id) && _byId.TryGetValue(id!, out var r)) res.Add(r.ToJObject());
            return res;
        }

        public static JObject? Get(string? id) =>
            !string.IsNullOrEmpty(id) && _byId.TryGetValue(id!, out var r) ? r.ToJObject() : null;

        public static Rec? GetRec(string? id) =>
            !string.IsNullOrEmpty(id) && _byId.TryGetValue(id!, out var r) ? r : null;

        public static List<Rec> ByCreatorRecs(ulong creatorAccountId)
        {
            lock (_lock) return _byCreator.TryGetValue(creatorAccountId, out var l) ? new List<Rec>(l) : new List<Rec>();
        }

        public static List<JObject> ByCreator(ulong creatorAccountId) =>
            ByCreatorRecs(creatorAccountId).Where(r => !r.AdminOnly).Select(r => r.ToJObject()).ToList();   // profile lists: exclusives stay hidden
    }
}