using System;
using System.Collections.Concurrent;
using System.Collections.Generic;

namespace AcDream.Core.Items;

/// <summary>
/// Live item-state mirror — the client-side view of every item the
/// server has spawned for this session. Owns <see cref="ItemInstance"/>
/// records, tracks which container holds each item, and fires events so
/// UI panels (inventory, paperdoll, hotbars) can redraw on change.
///
/// <para>
/// Retail semantics (r06):
/// <list type="bullet">
///   <item><description>
///     Every item is a <see cref="ItemInstance"/> with a unique
///     <c>ObjectId</c>. CreateObject seeds it when the server tells us
///     the item exists (in our inventory, on the ground, in a
///     vendor's list, etc).
///   </description></item>
///   <item><description>
///     Moves happen via <see cref="GameEventType"/>-carrying messages:
///     <c>WieldObject</c>, <c>InventoryPutObjInContainer</c>,
///     <c>InventoryPutObjectIn3D</c>, <c>ViewContents</c>,
///     <c>CloseGroundContainer</c>.
///   </description></item>
///   <item><description>
///     <c>InventoryServerSaveFailed</c> reverts a speculative local
///     state change (e.g. when a drag-drop was rejected server-side).
///   </description></item>
/// </list>
/// </para>
///
/// <para>
/// Thread safety: designed for single-threaded use from the render
/// thread; the event delegates run synchronously on the caller's
/// thread. A <see cref="ConcurrentDictionary{TKey,TValue}"/> backs the
/// map so plugin code can look up items from any thread without
/// corrupting state.
/// </para>
/// </summary>
public sealed class ItemRepository
{
    private readonly ConcurrentDictionary<uint, ItemInstance> _items = new();
    private readonly ConcurrentDictionary<uint, Container> _containers = new();

    /// <summary>Fires when an item is first added to the session.</summary>
    public event Action<ItemInstance>? ItemAdded;

    /// <summary>
    /// Fires when an item's container / slot changes (moved between
    /// packs, equipped, unequipped, dropped on ground). Old and new
    /// container ids are 0 if origin or destination is "world" / "nowhere".
    /// </summary>
    public event Action<ItemInstance, uint, uint>? ItemMoved;

    /// <summary>Fires when an item is removed from the session.</summary>
    public event Action<ItemInstance>? ItemRemoved;

    /// <summary>Fires when an item's properties are updated (typically after Appraise).</summary>
    public event Action<ItemInstance>? ItemPropertiesUpdated;

    /// <summary>PropertyInt.UiEffects (ACE enum value 18) — the icon effect bitfield;
    /// the typed mirror <see cref="UpdateIntProperty"/> maintains on
    /// <see cref="ItemInstance.Effects"/>.</summary>
    public const uint UiEffectsPropertyId = 18u;

    public int ItemCount => _items.Count;
    public int ContainerCount => _containers.Count;

    public IEnumerable<ItemInstance> Items => _items.Values;
    public IEnumerable<Container> Containers => _containers.Values;

    /// <summary>
    /// Look up an item by its server-assigned <c>ObjectId</c>.
    /// </summary>
    public ItemInstance? GetItem(uint objectId) =>
        _items.TryGetValue(objectId, out var item) ? item : null;

    /// <summary>
    /// Look up a container by object id, creating a lightweight stub if
    /// the id doesn't match any known container (defensive — avoids losing
    /// references when the server announces a move into a container it
    /// hasn't described yet).
    /// </summary>
    public Container? GetContainer(uint objectId) =>
        _containers.TryGetValue(objectId, out var c) ? c : null;

    /// <summary>
    /// Register / refresh an item in the repository. Called on
    /// CreateObject for item-typed weenies and on IdentifyObjectResponse
    /// to fill in detail properties.
    /// </summary>
    public void AddOrUpdate(ItemInstance item)
    {
        ArgumentNullException.ThrowIfNull(item);
        bool existed = _items.ContainsKey(item.ObjectId);
        _items[item.ObjectId] = item;
        if (!existed) ItemAdded?.Invoke(item);
        else ItemPropertiesUpdated?.Invoke(item);
    }

    /// <summary>
    /// Register a container. Idempotent.
    /// </summary>
    public void AddContainer(Container container)
    {
        ArgumentNullException.ThrowIfNull(container);
        _containers[container.ObjectId] = container;
    }

    /// <summary>
    /// Handle a server-driven move — called from
    /// InventoryPutObjInContainer (0x0022) and WieldObject (0x0023)
    /// handlers. Updates ContainerId / ContainerSlot / CurrentlyEquippedLocation
    /// and fires ItemMoved.
    /// </summary>
    public bool MoveItem(uint itemId, uint newContainerId, int newSlot = -1,
        EquipMask newEquipLocation = EquipMask.None)
    {
        if (!_items.TryGetValue(itemId, out var item)) return false;

        uint oldContainer = item.ContainerId;
        item.ContainerId = newContainerId;
        item.ContainerSlot = newSlot;
        item.CurrentlyEquippedLocation = newEquipLocation;

        ItemMoved?.Invoke(item, oldContainer, newContainerId);
        return true;
    }

    /// <summary>
    /// Handle a server-driven remove (destroyed item, dropped into 3D
    /// space, stolen, etc).
    /// </summary>
    public bool Remove(uint itemId)
    {
        if (!_items.TryRemove(itemId, out var item)) return false;
        ItemRemoved?.Invoke(item);
        return true;
    }

    /// <summary>
    /// Enrich an already-known item (a stub created from PlayerDescription) with the
    /// fuller data carried by its CreateObject (icon, name, type). Returns false if the
    /// item isn't tracked yet — phase 1 enriches existing items only; full
    /// CreateObject ingestion of newly-acquired items is the inventory phase.
    /// Raises ItemPropertiesUpdated whenever the item is found (matching the
    /// UpdateProperties convention — it fires on found regardless of whether a field
    /// actually changed) so bound widgets (the toolbar) re-render.
    /// <para>
    /// D.5.1 (2026-06-17): also accepts <paramref name="iconOverlayId"/> and
    /// <paramref name="iconUnderlayId"/> from the extended WeenieHeader tail. Both
    /// default to 0 (not sent by server). IconComposer.GetIcon already composites
    /// underlay/base/overlay in the correct retail layer order and early-returns on 0.
    /// </para>
    /// </summary>
    public bool EnrichItem(uint objectId, uint iconId, string name, ItemType type,
        uint iconOverlayId = 0, uint iconUnderlayId = 0, uint effects = 0)
    {
        if (!_items.TryGetValue(objectId, out var item)) return false;
        if (iconId != 0) item.IconId = iconId;
        if (!string.IsNullOrEmpty(name)) item.Name = name;
        if (type != default) item.Type = type;
        if (iconOverlayId != 0) item.IconOverlayId = iconOverlayId;
        if (iconUnderlayId != 0) item.IconUnderlayId = iconUnderlayId;
        // D.5.2: 0 is a meaningful "no effect" state (e.g. a caster out of mana),
        // so assign unconditionally — re-composition reflects the CURRENT state.
        item.Effects = effects;
        ItemPropertiesUpdated?.Invoke(item);
        return true;
    }

    /// <summary>
    /// Apply a <see cref="PropertyBundle"/> patch (e.g. from an
    /// <c>IdentifyObjectResponse</c>) to an existing item. Individual
    /// keys in the incoming bundle overwrite existing values; keys not
    /// present are left untouched.
    /// </summary>
    public bool UpdateProperties(uint itemId, PropertyBundle incoming)
    {
        if (!_items.TryGetValue(itemId, out var item)) return false;
        foreach (var kv in incoming.Ints)     item.Properties.Ints[kv.Key] = kv.Value;
        foreach (var kv in incoming.Int64s)   item.Properties.Int64s[kv.Key] = kv.Value;
        foreach (var kv in incoming.Bools)    item.Properties.Bools[kv.Key] = kv.Value;
        foreach (var kv in incoming.Floats)   item.Properties.Floats[kv.Key] = kv.Value;
        foreach (var kv in incoming.Strings)  item.Properties.Strings[kv.Key] = kv.Value;
        foreach (var kv in incoming.DataIds)  item.Properties.DataIds[kv.Key] = kv.Value;
        foreach (var kv in incoming.InstanceIds) item.Properties.InstanceIds[kv.Key] = kv.Value;
        ItemPropertiesUpdated?.Invoke(item);
        return true;
    }

    /// <summary>
    /// Apply a single PropertyInt update (from PublicUpdatePropertyInt 0x02CE) to an
    /// item: store it in the bundle and, for known typed ints, mirror to the typed
    /// field. Today: UiEffects (18) → <see cref="ItemInstance.Effects"/>. Fires
    /// ItemPropertiesUpdated so bound widgets re-composite. Extensible hook for future
    /// typed PropertyInts (StackSize, Structure, …). False if the item is unknown.
    /// </summary>
    public bool UpdateIntProperty(uint itemId, uint propertyId, int value)
    {
        if (!_items.TryGetValue(itemId, out var item)) return false;
        item.Properties.Ints[propertyId] = value;
        if (propertyId == UiEffectsPropertyId) item.Effects = (uint)value;
        ItemPropertiesUpdated?.Invoke(item);
        return true;
    }

    /// <summary>
    /// Flush the repository — typically called on logoff or teleport
    /// that drops the session's item state.
    /// </summary>
    public void Clear()
    {
        _items.Clear();
        _containers.Clear();
    }
}