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;

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