using System;
using Server.Collections;
using Server.Gumps;
using Server.Network;

namespace Server.Engines.Spawners;

public class SpawnerGump : Gump
{
    private readonly BaseSpawner _spawner;
    private SpawnerEntry _entry;
    private int _page;

    public SpawnerGump(BaseSpawner spawner, SpawnerEntry focusentry = null, int page = 0) : base(50, 50)
    {
        _spawner = spawner;
        _entry = focusentry;
        _page = page;

        AddPage(0);

        AddBackground(0, 0, 369, 400 + (_entry != null ? 44 : 0), 5054);
        AddAlphaRegion(0, 0, 369, 400 + (_entry != null ? 44 : 0));

        AddHtml(263, 1, 250, 20, "<BASEFONT COLOR=#F4F4F4>#</BASEFONT>");
        AddHtml(294, 1, 250, 20, "<BASEFONT COLOR=#F4F4F4>Max</BASEFONT>");
        AddHtml(334, 1, 250, 20, "<BASEFONT COLOR=#F4F4F4>Prb</BASEFONT>");

        // AddLabel( 95, 1, 0, "Creatures List" );

        var offset = 0;

        for (var i = 0; i < 13; i++)
        {
            var textIndex = i * 5;
            var entryIndex = _page * 13 + i;

            SpawnerEntry entry = null;

            if (entryIndex < spawner.Entries.Count)
            {
                entry = _spawner.Entries[entryIndex];
            }

            if (entry == null || _entry != entry)
            {
                AddButton(
                    28,
                    22 * i + 21 + offset,
                    entry != null ? 0xFBA : 0xFA5,
                    entry != null ? 0xFBC : 0xFA7,
                    GetButtonID(2, i * 2)
                ); // Expand
            }
            else
            {
                AddButton(
                    28,
                    22 * i + 21 + offset,
                    0xFBB,
                    0xFBC,
                    GetButtonID(2, i * 2)
                ); // Unexpand
            }

            AddButton(61, 22 * i + 21 + offset, 0xFA2, 0xFA4, GetButtonID(2, 1 + i * 2)); // Delete

            if (entry != null)
            {
                if (entry.Disabled)
                {
                    AddButton(9, 22 * i + 24 + offset, 0x82C, 0x82C, GetButtonID(3, i)); // Locked, press to unlock
                }
                else
                {
                    AddButton(7, 22 * i + 24 + offset, 0x2C88, 0x2C89, GetButtonID(3, i)); // Unlocked, press to lock
                }
            }

            // Locked entries render on a grey tile as labels instead of text entries, so they can't be edited
            var locked = entry?.Disabled == true;
            var fieldTile = locked ? 0x23F4 : 0xBBC;

            AddImageTiled(94, 22 * i + 20 + offset, 161, 23, 0xA40); // creature text box
            AddImageTiled(95, 22 * i + 21 + offset, 159, 21, fieldTile); // creature text box

            AddImageTiled(258, 22 * i + 20 + offset, 35, 23, 0xA40); // count html label
            AddImageTiled(259, 22 * i + 21 + offset, 33, 21, 0xE14); // count html label

            AddImageTiled(290, 22 * i + 20 + offset, 35, 23, 0xA40); // maxcount text box
            AddImageTiled(291, 22 * i + 21 + offset, 33, 21, fieldTile); // maxcount text box

            AddImageTiled(328, 22 * i + 20 + offset, 35, 23, 0xA40); // probability text box
            AddImageTiled(329, 22 * i + 21 + offset, 33, 21, fieldTile); // probability text box

            string name;
            string probability;
            string maxCount;
            var flags = EntryFlags.None;

            if (entry != null)
            {
                name = entry.SpawnedName;
                probability = entry.SpawnedProbability.ToString();
                maxCount = entry.SpawnedMaxCount.ToString();
                flags = entry.Valid;

                var count = spawner.CountSpawns(entry);

                AddHtml(258, 22 * i + 20 + offset + 1, 35, 15, $"<BASEFONT COLOR={GetCountColor(count, entry.SpawnedMaxCount)}><div align=RIGHT>{count}<BASEFONT COLOR=#F4F4F4>/</BASEFONT></div></BASEFONT>");
            }
            else
            {
                name = "";
                probability = "";
                maxCount = "";
            }

            var nameHue = (flags & EntryFlags.InvalidType) != 0 ? 33 : 0;

            if (locked)
            {
                AddLabelCropped(98, 22 * i + 21 + offset, 156, 21, nameHue, name);     // creature
                AddLabelCropped(293, 22 * i + 21 + offset, 30, 21, 0, maxCount);       // max count
                AddLabelCropped(331, 22 * i + 21 + offset, 30, 21, 0, probability);    // probability
            }
            else
            {
                AddTextEntry(98, 22 * i + 21 + offset, 156, 21, nameHue, textIndex, name);         // creature
                AddTextEntry(293, 22 * i + 21 + offset, 30, 21, 0, textIndex + 1, maxCount);    // max count
                AddTextEntry(331, 22 * i + 21 + offset, 30, 21, 0, textIndex + 2, probability); // probability
            }

            if (entry != null && _entry == entry)
            {
                AddLabel(5, 22 * i + 42, 0x384, "Params");
                AddImageTiled(55, 22 * i + 42, 276, 23, 0xA40); // Parameters
                AddImageTiled(56, 22 * i + 43, 274, 21, fieldTile); // Parameters

                AddLabel(5, 22 * i + 64, 0x384, "Props");
                AddImageTiled(55, 22 * i + 64, 276, 23, 0xA40); // Properties
                AddImageTiled(56, 22 * i + 65, 274, 21, fieldTile); // Properties

                var paramsHue = (flags & EntryFlags.InvalidParams) != 0 ? 33 : 0;
                var propsHue = (flags & EntryFlags.InvalidProps) != 0 ? 33 : 0;

                if (locked)
                {
                    AddLabelCropped(59, 22 * i + 42, 271, 21, paramsHue, entry.Parameters); // parameters
                    AddLabelCropped(59, 22 * i + 62, 271, 21, propsHue, entry.Properties);  // properties
                }
                else
                {
                    AddTextEntry(59, 22 * i + 42, 271, 21, paramsHue, textIndex + 3, entry.Parameters); // parameters
                    AddTextEntry(59, 22 * i + 62, 271, 21, propsHue, textIndex + 4, entry.Properties);  // properties
                }

                offset += 44;
            }
        }

        if (spawner.Running)
        {
            AddButton(5, 312 + offset, 0x2A4E, 0x2A3A, GetButtonID(1, 6));
            AddLabel(38, 317 + offset, 0x384, "On");
        }
        else
        {
            AddButton(5, 312 + offset, 0x2A62, 0x2A3A, GetButtonID(1, 7));
            AddLabel(38, 317 + offset, 0x384, "Off");
        }

        var totalSpawned = 0;
        var totalMax = 0;
        var totalWeight = 0;

        for (var i = 0; i < _spawner.Entries.Count; i++)
        {
            var spawnerEntry = _spawner.Entries[i];
            totalSpawned += spawner.CountSpawns(spawnerEntry);

            if (!spawnerEntry.Disabled)
            {
                totalMax += spawnerEntry.SpawnedMaxCount;
                totalWeight += spawnerEntry.SpawnedProbability;
            }
        }

        AddHtml(258, 308 + offset, 35, 20, Html.Center($"{totalSpawned}", 0xF4F4F4));
        AddHtml(290, 308 + offset, 35, 20, Html.Center($"{totalMax}", 0xF4F4F4));
        AddHtml(328, 308 + offset, 35, 20, Html.Center($"{totalWeight}", 0xF4F4F4));

        AddHtml(5, 1, 161, 20, $"<BASEFONT COLOR=#FFEA00>{spawner.Name}</BASEFONT><BASEFONT COLOR={GetCountColor(totalSpawned, spawner.Count)}> ({totalSpawned}/{spawner.Count})</BASEFONT>");

        AddButton(5, 347 + offset, 0xFAB, 0xFAD, GetButtonID(1, 2));
        AddLabel(38, 347 + offset, 0x384, "Props");

        AddButton(5, 369 + offset, 0xFAE, 0xFAF, GetButtonID(1, 8));
        AddLabel(38, 369 + offset, 0x384, "Goto");

        AddButton(90, 325 + offset, 0xFA2, 0xFA3, GetButtonID(1, 9));
        AddLabel(123, 325 + offset, 0x384, "Reset");

        AddButton(90, 347 + offset, 0xFB4, 0xFB6, GetButtonID(1, 3));
        AddLabel(123, 347 + offset, 0x384, "Bring Home");

        AddButton(90, 369 + offset, 0xFA8, 0xFAA, GetButtonID(1, 4));
        AddLabel(123, 369 + offset, 0x384, "Total Respawn");

        AddButton(283, 347 + offset, 0xFB7, 0xFB9, GetButtonID(1, 5));
        AddLabel(316, 347 + offset, 0x384, "Save");

        AddButton(283, 369 + offset, 0xFB1, 0xFB3, 0);
        AddLabel(316, 369 + offset, 0x384, "Cancel");

        if (_page > 0)
        {
            AddButton(223, 308 + offset, 0x15E3, 0x15E7, GetButtonID(1, 0));
        }
        else
        {
            AddImage(223, 308 + offset, 0x25EA);
        }

        if ((_page + 1) * 13 <= _spawner.Entries.Count)
        {
            AddButton(240, 308 + offset, 0x15E1, 0x15E5, GetButtonID(1, 1));
        }
        else
        {
            AddImage(240, 308 + offset, 0x25E6);
        }
    }

    public int GetButtonID(int type, int index) => 1 + index * 10 + type;

    private static string GetCountColor(int count, int maxCount) =>
        ((double) count / maxCount) switch
        {
            <= 0.25 => "#DE3163", // red
            <= 0.50 => "#FF7F50", // orange
            <= 0.75 => "#DFFF00", // yellow
            <= 1    => "#00FF00", // green
            _       => "#F4F4F4"  // white
        };

    public void CreateArray(RelayInfo info, Mobile from, BaseSpawner spawner)
    {
        var ocount = spawner.Entries.Count;

        using var queue = PooledRefQueue<SpawnerEntry>.Create();

        for (var i = 0; i < 13; i++)
        {
            var index = i * 5;
            var entryindex = _page * 13 + i;

            var typeEntry = info.GetTextEntry(index);
            var maxSpawns = info.GetTextEntry(index + 1);
            var probability = info.GetTextEntry(index + 2);
            var customParams = info.GetTextEntry(index + 3);
            var customPrompts = info.GetTextEntry(index + 4);

            if (typeEntry == null)
            {
                continue;
            }

            var str = typeEntry.Trim().ToLower();

            if (str.Length > 0)
            {
                var type = AssemblyHandler.FindTypeByName(str);

                if (type == null)
                {
                    from.SendMessage($"{str} is not a valid type name for entry #{i}.");
                    return;
                }

                SpawnerEntry entry;

                if (entryindex < ocount)
                {
                    entry = spawner.Entries[entryindex];
                    entry.SpawnedName = str;

                    if (maxSpawns != null)
                    {
                        entry.SpawnedMaxCount = Utility.ToInt32(maxSpawns.AsSpan().Trim());
                    }

                    if (probability != null)
                    {
                        entry.SpawnedProbability = Utility.ToInt32(probability.AsSpan().Trim());
                    }
                }
                else
                {
                    var maxcount = maxSpawns != null ? Utility.ToInt32(maxSpawns.AsSpan().Trim()) : 1;
                    var probcount = probability != null ? Utility.ToInt32(probability.AsSpan().Trim()) : 100;

                    entry = spawner.AddEntry(str, probcount, maxcount);
                }

                if (customParams != null)
                {
                    entry.Parameters = customParams.Trim();
                }

                if (customPrompts != null)
                {
                    entry.Properties = customPrompts.Trim();
                }
            }
            else if (entryindex < ocount && spawner.Entries[entryindex] != null)
            {
                queue.Enqueue(spawner.Entries[entryindex]);
            }
        }

        while (queue.Count > 0)
        {
            spawner.RemoveEntry(queue.Dequeue());
        }

        if (ocount == 0 && spawner.Entries.Count > 0)
        {
            spawner.Start();
        }
    }

    public override void OnResponse(NetState state, in RelayInfo info)
    {
        if (_spawner.Deleted)
        {
            return;
        }

        var val = info.ButtonID - 1;

        if (val < 0)
        {
            return;
        }

        var type = val % 10;
        var index = val / 10;

        switch (type)
        {
            case 0: // Cancel
                {
                    return;
                }
            case 1:
                {
                    switch (index)
                    {
                        case 0:
                            {
                                if (_spawner.Entries != null && _page > 0)
                                {
                                    _page--;
                                    _entry = null;
                                }

                                break;
                            }
                        case 1:
                            {
                                if ((_page + 1) * 13 <= _spawner.Entries?.Count)
                                {
                                    _page++;
                                    _entry = null;
                                }

                                break;
                            }
                        case 2: // Props
                            {
                                state.Mobile.SendGump(new PropertiesGump(state.Mobile, _spawner));
                                break;
                            }
                        case 3: // Bring Home
                            {
                                _spawner.BringToHome();
                                break;
                            }
                        case 4: // Complete respawn
                            {
                                _spawner.Respawn();
                                break;
                            }
                        case 5: // Save
                            {
                                CreateArray(info, state.Mobile, _spawner);
                                break;
                            }
                        case 6: // On button
                            {
                                _spawner.Running = false;

                                break;
                            }
                        case 7: // Off button
                            {
                                _spawner.Running = true;
                                break;
                            }
                        case 8: // Goto
                            {
                                state.Mobile.MoveToWorld(_spawner.Location, _spawner.Map);
                                break;
                            }
                        case 9: // Reset
                            {
                                _spawner.Reset();
                                break;
                            }
                    }

                    break;
                }
            case 2:
                {
                    var entryIndex = index / 2 + _page * 13;
                    var buttonType = index % 2;

                    if (entryIndex >= 0 && entryIndex < _spawner.Entries.Count)
                    {
                        var entry = _spawner.Entries[entryIndex];
                        if (buttonType == 0) // Spawn creature
                        {
                            _entry = _entry != entry ? entry : null;
                        }
                        else // Remove creatures
                        {
                            _spawner.RemoveSpawn(entryIndex);
                        }
                    }

                    CreateArray(info, state.Mobile, _spawner);
                    break;
                }
            case 3: // Enable/disable entry
                {
                    var entryIndex = index + _page * 13;
                    if (entryIndex >= 0 && entryIndex < _spawner.Entries.Count)
                    {
                        var entry = _spawner.Entries[entryIndex];
                        entry.Disabled = !entry.Disabled;
                    }

                    CreateArray(info, state.Mobile, _spawner);
                    break;
                }
        }

        if (_entry != null && HasEntry(_spawner, _entry))
        {
            state.Mobile.SendGump(new SpawnerGump(_spawner, _entry, _page));
        }
        else
        {
            state.Mobile.SendGump(new SpawnerGump(_spawner, null, _page));
        }
    }

    private static bool HasEntry(BaseSpawner spawner, SpawnerEntry entry)
    {
        var entries = spawner.Entries;

        for (var i = 0; i < entries.Count; i++)
        {
            if (entries[i] == entry)
            {
                return true;
            }
        }

        return false;
    }
}