using Dalamud.Game.ClientState.Objects.Enums;
using Dalamud.Game.ClientState.Objects.Types;
using Dalamud.Plugin.Services;
using LightlessSync.API.Data;
using LightlessSync.Interop.Ipc;
using LightlessSync.PlayerData.Factories;
using LightlessSync.PlayerData.Pairs;
using LightlessSync.Services;
using LightlessSync.Services.ActorTracking;
using Microsoft.Extensions.Logging;
using DalamudObjectKind = Dalamud.Game.ClientState.Objects.Enums.ObjectKind;
using ObjectKind = LightlessSync.API.Data.Enum.ObjectKind;

namespace LightlessSync.PlayerData.Handlers;

internal sealed class OwnedObjectHandler
{
    // Debug information for owned object resolution
    internal readonly record struct OwnedResolveDebug(
    DateTime? ResolvedAtUtc,
    nint Address,
    ushort? ObjectIndex,
    string Stage,
    string? FailureReason)
    {
        public string? AddressHex => Address == nint.Zero ? null : $"0x{Address:X}";
        public static OwnedResolveDebug Empty => new(null, nint.Zero, null, string.Empty, null);
    }

    private OwnedResolveDebug _minionResolveDebug = OwnedResolveDebug.Empty;
    public OwnedResolveDebug MinionResolveDebug => _minionResolveDebug;

    // Dependencies
    private readonly ILogger _logger;
    private readonly DalamudUtilService _dalamudUtil;
    private readonly GameObjectHandlerFactory _handlerFactory;
    private readonly IpcManager _ipc;
    private readonly ActorObjectService _actorObjectService;
    private readonly IObjectTable _objectTable;

    // Timeouts for fully loaded checks
    private const int _fullyLoadedTimeoutMsPlayer = 30000;
    private const int _fullyLoadedTimeoutMsOther = 5000;

    public OwnedObjectHandler(
        ILogger logger,
        DalamudUtilService dalamudUtil,
        GameObjectHandlerFactory handlerFactory,
        IpcManager ipc,
        ActorObjectService actorObjectService,
        IObjectTable objectTable)
    {
        _logger = logger;
        _dalamudUtil = dalamudUtil;
        _handlerFactory = handlerFactory;
        _ipc = ipc;
        _actorObjectService = actorObjectService;
        _objectTable = objectTable;
    }

    /// <summary>
    /// Applies the specified changes to the owned object of the given kind.
    /// </summary>
    /// <param name="applicationId">Application ID of the Character Object</param>
    /// <param name="kind">Object Kind of the given object</param>
    /// <param name="changes">Changes of the object</param>
    /// <param name="data">Data of the object</param>
    /// <param name="playerHandler">Owner of the object</param>
    /// <param name="penumbraCollection">Collection if needed</param>
    /// <param name="customizeIds">Customizing identications for the object</param>
    /// <param name="token">Cancellation Token</param>
    /// <returns>Successfully applied or not</returns>
    public async Task<bool> ApplyAsync(
        Guid applicationId,
        ObjectKind kind,
        HashSet<PlayerChanges> changes,
        CharacterData data,
        GameObjectHandler playerHandler,
        Guid penumbraCollection,
        Dictionary<ObjectKind, Guid?> customizeIds,
        CancellationToken token)
    {
        // Validate player handler
        if (playerHandler.Address == nint.Zero)
            return false;

        // Create handler for owned object
        var handler = await CreateHandlerAsync(kind, playerHandler, token).ConfigureAwait(false);
        if (handler is null || handler.Address == nint.Zero)
            return false;

        try
        {
            token.ThrowIfCancellationRequested();

            // Determine if we have file replacements for this kind
            bool hasFileReplacements =
                kind != ObjectKind.Player
                && data.FileReplacements.TryGetValue(kind, out var repls)
                && repls is { Count: > 0 };

            // Determine if we should assign a Penumbra collection
            bool shouldAssignCollection =
                kind != ObjectKind.Player
                && hasFileReplacements
                && penumbraCollection != Guid.Empty
                && _ipc.Penumbra.APIAvailable;

            // Determine if only IPC-only changes are being made for player
            bool isPlayerIpcOnly =
                kind == ObjectKind.Player
                && changes.Count > 0
                && changes.All(c => c is PlayerChanges.Honorific
                                  or PlayerChanges.Moodles
                                  or PlayerChanges.PetNames
                                  or PlayerChanges.Heels);

            // Wait for drawing to complete 
            await handler.IsBeingDrawnRunOnFrameworkAsync().ConfigureAwait(false);

            // Determine timeouts
            var drawTimeoutMs = handler.ObjectKind == ObjectKind.Player ? 30000 : 5000;
            var fullyLoadedTimeoutMs = handler.ObjectKind == ObjectKind.Player ? _fullyLoadedTimeoutMsPlayer : _fullyLoadedTimeoutMsOther;

            // Wait for drawing to complete
            await _dalamudUtil
                .WaitWhileCharacterIsDrawing(_logger, handler, applicationId, drawTimeoutMs, token)
                .ConfigureAwait(false);

            if (handler.Address != nint.Zero)
            {
                // Wait for fully loaded
                var loaded = await _actorObjectService
                    .WaitForFullyLoadedAsync(handler.Address, token, fullyLoadedTimeoutMs)
                    .ConfigureAwait(false);

                if (!loaded)
                {
                    _logger.LogTrace("[{appId}] {kind}: not fully loaded in time, skipping for now", applicationId, kind);
                    return false;
                }
            }

            token.ThrowIfCancellationRequested();

            // Assign Penumbra collection if needed
            if (shouldAssignCollection)
            {
                // Get object index
                var objIndex = await _dalamudUtil
                    .RunOnFrameworkThread(() => handler.GetGameObject()?.ObjectIndex)
                    .ConfigureAwait(false);

                if (!objIndex.HasValue)
                {
                    _logger.LogTrace("[{appId}] {kind}: ObjectIndex not available yet, cannot assign collection", applicationId, kind);
                    return false;
                }

                // Assign collection
                await _ipc.Penumbra
                    .AssignTemporaryCollectionAsync(_logger, penumbraCollection, objIndex.Value)
                    .ConfigureAwait(false);
            }

            var tasks = new List<Task>();

            // Apply each change
            foreach (var change in changes.OrderBy(c => (int)c))
            {
                token.ThrowIfCancellationRequested();

                // Handle each change type
                switch (change)
                {
                    case PlayerChanges.Customize:
                        if (data.CustomizePlusData.TryGetValue(kind, out var customizeData) && !string.IsNullOrEmpty(customizeData))
                            tasks.Add(ApplyCustomizeAsync(handler.Address, customizeData, kind, customizeIds));
                        else if (customizeIds.TryGetValue(kind, out var existingId))
                            tasks.Add(RevertCustomizeAsync(existingId, kind, customizeIds));
                        break;
                        
                    case PlayerChanges.Glamourer:
                        if (data.GlamourerData.TryGetValue(kind, out var glamourerData) && !string.IsNullOrEmpty(glamourerData))
                            tasks.Add(_ipc.Glamourer.ApplyAllAsync(_logger, handler, glamourerData, applicationId, token));
                        break;

                    case PlayerChanges.Heels:
                        if (kind == ObjectKind.Player && !string.IsNullOrEmpty(data.HeelsData))
                            tasks.Add(_ipc.Heels.SetOffsetForPlayerAsync(handler.Address, data.HeelsData));
                        break;

                    case PlayerChanges.Honorific:
                        if (kind == ObjectKind.Player && !string.IsNullOrEmpty(data.HonorificData))
                            tasks.Add(_ipc.Honorific.SetTitleAsync(handler.Address, data.HonorificData));
                        break;

                    case PlayerChanges.Moodles:
                        if (kind == ObjectKind.Player && !string.IsNullOrEmpty(data.MoodlesData))
                            tasks.Add(_ipc.Moodles.SetStatusAsync(handler.Address, data.MoodlesData));
                        break;

                    case PlayerChanges.PetNames:
                        if (kind == ObjectKind.Player && !string.IsNullOrEmpty(data.PetNamesData))
                            tasks.Add(_ipc.PetNames.SetPlayerData(handler.Address, data.PetNamesData));
                        break;

                    case PlayerChanges.ModFiles:
                    case PlayerChanges.ModManip:
                    case PlayerChanges.ForcedRedraw:
                    default:
                        break;
                }
            }

            // Await all tasks for change applications
            if (tasks.Count > 0)
                await Task.WhenAll(tasks).ConfigureAwait(false);

            token.ThrowIfCancellationRequested();

            // Determine if redraw is needed
            bool needsRedraw =
                _ipc.Penumbra.APIAvailable
                && (
                    shouldAssignCollection
                    || changes.Contains(PlayerChanges.ForcedRedraw)
                    || changes.Contains(PlayerChanges.ModFiles)
                    || changes.Contains(PlayerChanges.ModManip)
                    || changes.Contains(PlayerChanges.Glamourer)
                    || changes.Contains(PlayerChanges.Customize)
                );

            // Skip redraw for player if only IPC-only changes were made
            if (isPlayerIpcOnly)
                needsRedraw = false;

            // Perform redraw if needed
            if (needsRedraw && _ipc.Penumbra.APIAvailable)
            {
                _logger.LogWarning(
                    "[{appId}] {kind}: Redrawing ownedTarget={isOwned} (needsRedraw={needsRedraw})",
                    applicationId, kind, kind != ObjectKind.Player, needsRedraw);

                await _ipc.Penumbra
                    .RedrawAsync(_logger, handler, applicationId, token)
                    .ConfigureAwait(false);
            }

            return true;
        }
        finally
        {
            if (!ReferenceEquals(handler, playerHandler))
                handler.Dispose();
        }
    }

    /// <summary>
    /// Creates a GameObjectHandler for the owned object of the specified kind.
    /// </summary>
    /// <param name="kind">Object kind of the handler</param>
    /// <param name="playerHandler">Owner of the given object</param>
    /// <param name="token">Cancellation Token</param>
    /// <returns>Handler for the GameObject with the handler</returns>
    private async Task<GameObjectHandler?> CreateHandlerAsync(ObjectKind kind, GameObjectHandler playerHandler, CancellationToken token)
    {
        token.ThrowIfCancellationRequested();

        // Debug info setter
        void SetMinionDebug(string stage, string? failure, nint addr = default, ushort? objIndex = null)
        {
            if (kind != ObjectKind.MinionOrMount)
                return;

            _minionResolveDebug = new OwnedResolveDebug(
                DateTime.UtcNow,
                addr,
                objIndex,
                stage,
                failure);
        }

        // Direct return for player
        if (kind == ObjectKind.Player)
            return playerHandler;

        // First, try direct retrieval via Dalamud API
        var playerPtr = playerHandler.Address;
        if (playerPtr == nint.Zero)
        {
            SetMinionDebug("player_ptr_zero", "playerHandler.Address == 0");
            return null;
        }

        // Try direct retrieval
        nint ownedPtr = kind switch
        {
            ObjectKind.Companion => await _dalamudUtil.GetCompanionAsync(playerPtr).ConfigureAwait(false),
            ObjectKind.MinionOrMount => await _dalamudUtil.GetMinionOrMountAsync(playerPtr).ConfigureAwait(false),
            ObjectKind.Pet => await _dalamudUtil.GetPetAsync(playerPtr).ConfigureAwait(false),
            _ => nint.Zero
        };

        // If that fails, scan the object table for owned objects
        var stage = ownedPtr != nint.Zero ? "direct" : "direct_miss";

        // Owner ID based scan
        if (ownedPtr == nint.Zero)
        {
            token.ThrowIfCancellationRequested();

            // Get owner entity ID
            var ownerEntityId = playerHandler.EntityId;
            if (ownerEntityId == 0 || ownerEntityId == uint.MaxValue)
            {
                // Read unsafe
                ownerEntityId = await _dalamudUtil
                    .RunOnFrameworkThread(() => ReadEntityIdSafe(playerHandler))
                    .ConfigureAwait(false);
            }

            if (ownerEntityId != 0 && ownerEntityId != uint.MaxValue)
            {
                // Scan for owned object
                ownedPtr = await _dalamudUtil
                    .RunOnFrameworkThread(() => FindOwnedByOwnerIdSafe(kind, ownerEntityId))
                    .ConfigureAwait(false);

                stage = ownedPtr != nint.Zero ? "owner_scan" : "owner_scan_miss";
            }
            else
            {
                stage = "owner_id_unavailable";
            }
        }

        if (ownedPtr == nint.Zero)
        {
            SetMinionDebug(stage, "ownedPtr == 0");
            return null;
        }

        token.ThrowIfCancellationRequested();

        // Create handler
        var handler = await _handlerFactory.Create(kind, () => ownedPtr, isWatched: false).ConfigureAwait(false);
        if (handler is null || handler.Address == nint.Zero)
        {
            SetMinionDebug(stage, "handlerFactory returned null/zero", ownedPtr);
            return null;
        }

        // Get object index for debug
        ushort? objIndex = await _dalamudUtil.RunOnFrameworkThread(() => handler.GetGameObject()?.ObjectIndex)
            .ConfigureAwait(false);

        SetMinionDebug(stage, failure: null, handler.Address, objIndex);
        return handler;
    }

    /// <summary>
    /// Entity ID reader with safety checks.
    /// </summary>
    /// <param name="playerHandler">Handler of the Object</param>
    /// <returns>Entity Id</returns>
    private static uint ReadEntityIdSafe(GameObjectHandler playerHandler) => playerHandler.GetGameObject()?.EntityId ?? 0;

    /// <summary>
    /// Finds an owned object by scanning the object table for the specified owner entity ID.
    /// </summary>
    /// <param name="kind">Object kind to find of owned object</param>
    /// <param name="ownerEntityId">Owner Id</param>
    /// <returns>Object Id</returns>
    private nint FindOwnedByOwnerIdSafe(ObjectKind kind, uint ownerEntityId)
    {
        // Validate owner ID
        if (ownerEntityId == 0 || ownerEntityId == uint.MaxValue)
            return nint.Zero;

        // Scan object table
        foreach (var obj in _objectTable)
        {
            // Validate object
            if (obj is null || obj.Address == nint.Zero)
                continue;

            // Check owner ID match
            if (obj.OwnerId != ownerEntityId)
                continue;

            // Check kind match
            if (!IsOwnedKindMatch(obj, kind))
                continue;

            return obj.Address;
        }

        return nint.Zero;
    }

    /// <summary>
    /// Determines if the given object matches the specified owned kind.
    /// </summary>
    /// <param name="obj">Game Object</param>
    /// <param name="kind">Object Kind</param>
    /// <returns></returns>
    private static bool IsOwnedKindMatch(IGameObject obj, ObjectKind kind) => kind switch
    {
        // Match minion or mount
        ObjectKind.MinionOrMount =>
            obj.ObjectKind is DalamudObjectKind.MountType
                        or DalamudObjectKind.Companion,

        // Match pet
        ObjectKind.Pet =>
            obj.ObjectKind == DalamudObjectKind.BattleNpc
            && obj is IBattleNpc bnPet
            && bnPet.BattleNpcKind == BattleNpcSubKind.Pet,

        // Match companion
        ObjectKind.Companion =>
            obj.ObjectKind == DalamudObjectKind.BattleNpc
            && obj is IBattleNpc bnBuddy
            && bnBuddy.BattleNpcKind == BattleNpcSubKind.Chocobo,

        _ => false
    };

    /// <summary>
    /// Applies Customize Plus data to the specified object.
    /// </summary>
    /// <param name="address">Object Address</param>
    /// <param name="customizeData">Data of the Customize+ that has to be applied</param>
    /// <param name="kind">Object Kind</param>
    /// <param name="customizeIds">Customize+ Ids</param>
    /// <returns>Task</returns>
    private async Task ApplyCustomizeAsync(nint address, string customizeData, ObjectKind kind, Dictionary<ObjectKind, Guid?> customizeIds)
    {
        customizeIds[kind] = await _ipc.CustomizePlus.SetBodyScaleAsync(address, customizeData).ConfigureAwait(false);
    }

    /// <summary>
    /// Reverts Customize Plus changes for the specified object.
    /// </summary>
    /// <param name="customizeId">Customize+ Id</param>
    /// <param name="kind">Object Id</param>
    /// <param name="customizeIds">List of Customize+ ids</param>
    /// <returns></returns>
    private async Task RevertCustomizeAsync(Guid? customizeId, ObjectKind kind, Dictionary<ObjectKind, Guid?> customizeIds)
    {
        if (!customizeId.HasValue)
            return;

        await _ipc.CustomizePlus.RevertByIdAsync(customizeId.Value).ConfigureAwait(false);
        customizeIds.Remove(kind);
    }
}