/*************************************************************************
 * ModernUO                                                              *
 * Copyright 2019-2026 - ModernUO Development Team                       *
 * Email: hi@modernuo.com                                                *
 * File: SpawnerControllerGump.cs                                       *
 *                                                                       *
 * This program is free software: you can redistribute it and/or modify  *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation, either version 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * You should have received a copy of the GNU General Public License     *
 * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
 *************************************************************************/

using System;
using Server.Collections;
using Server.Engines.Spawners;
using Server.Network;

namespace Server.Gumps;

public enum SpawnSearchType
{
    Creature = 0,
    Coords,
    Props,
    Name
}

public class SpawnSearch
{
    public SpawnSearchType Type { get; set; } = SpawnSearchType.Creature;
    public string SearchPattern { get; set; } = "";
}

public class SpawnerControllerGump : DynamicGump
{
    // Grid dimensions
    private const int GumpWidth = 1000;
    private const int GumpHeight = 800;
    private const int RowHeight = 45;
    private const int HeaderHeight = 28;
    private const int EntryCount = 5;
    private const int TypeCount = 15;

    // Column spec for the 12-column list
    private const string ColumnSpec = "6* 8* 18* 6* 12* 6* 5* 5* 8* 8* 9* *";
    // Row spec for main grid: search (10%), list (*), footer (100px)
    private const string MainRowSpec = "10* * 100";

    private readonly Mobile _mobile;
    private int _page;
    private readonly SpawnSearch _search;
    private BaseSpawner _copy;
    private BaseSpawner[] _spawners = Array.Empty<BaseSpawner>();
    private int _lineCount;

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

    public static void Configure()
    {
        CommandSystem.Register("SpawnAdmin", AccessLevel.GameMaster, OpenSpawnGump_OnCommand);
    }

    [Usage("Spawn")]
    [Aliases("Spawn")]
    [Description("Opens the spawn administration gump.")]
    public static void OpenSpawnGump_OnCommand(CommandEventArgs e)
    {
        e.Mobile.SendGump(new SpawnerControllerGump(e.Mobile));
    }

    public SpawnerControllerGump(Mobile mobile, int page = 0, BaseSpawner copy = null, SpawnSearch search = null)
        : base(20, 30)
    {
        _mobile = mobile;
        _page = page;
        _copy = copy;
        _search = search ?? new SpawnSearch();

        SearchSpawner();
    }

    protected override void BuildLayout(ref DynamicGumpBuilder builder)
    {
        builder.AddPage();

        // Background
        builder.AddBackground(0, 0, GumpWidth, GumpHeight, 5054);
        builder.AddImageTiled(0, 0, GumpWidth, GumpHeight, 2624);
        builder.AddAlphaRegion(0, 0, GumpWidth, GumpHeight);

        // Calculate main grid: 1 column x 3 rows
        Span<int> mainRowPos = stackalloc int[3];
        Span<int> mainRowHeights = stackalloc int[3];

        Span<GridSizeSpec> mainRowSpecs = stackalloc GridSizeSpec[3];
        GridSizeSpec.ParseAll(MainRowSpec, mainRowSpecs);
        GridCalculator.ComputeTrackSizes(mainRowSpecs, GumpHeight, 0, mainRowPos, mainRowHeights);

        // Calculate list view layout
        Span<int> listColPos = stackalloc int[12];
        Span<int> listColWidths = stackalloc int[12];

        var listView = ListViewLayout.Create(
            0,
            mainRowPos[1],
            GumpWidth,
            mainRowHeights[1] - 7, // marginY adjustment
            _spawners.Length,
            _page,
            RowHeight,
            HeaderHeight,
            ColumnSpec,
            listColPos,
            listColWidths
        );

        _lineCount = listView.ItemsPerPage;

        // Draw borders
        var row1Y = mainRowPos[1];
        var row2Y = mainRowPos[2];
        builder.AddImageTiled(0, row1Y, GumpWidth, 3, 9357);
        builder.AddAlphaRegion(0, row1Y, GumpWidth, 3);
        builder.AddImageTiled(0, row1Y + 21, GumpWidth, 3, 9357);
        builder.AddAlphaRegion(0, row1Y + 21, GumpWidth, 3);

        for (var i = 0; i < listView.ColumnCount - 1; i++)
        {
            var x = listColPos[i] + listColWidths[i] - 8;
            var y = mainRowPos[1] + 3;
            builder.AddImageTiled(x, y, 3, 20, 9355);
            builder.AddAlphaRegion(x, y, 3, 20);
        }

        builder.AddImageTiled(0, row2Y - 11, GumpWidth, 6, 9357);
        builder.AddAlphaRegion(0, row2Y - 11, GumpWidth, 6);
        builder.AddImageTiled(0, row2Y + 55, GumpWidth, 6, 9357);
        builder.AddAlphaRegion(0, row2Y + 55, GumpWidth, 6);

        // Draw search area
        DrawSearch(ref builder, mainRowPos[0], mainRowHeights[0]);

        // Draw column headers
        ReadOnlySpan<string> headers =
        [
            "Copy", "Paste", "Name/Serial", "Map", "Coords",
            "Entry", "Walk", "Home", "Min Delay", "Max Delay",
            "Next Spawn", "Actions"
        ];

        for (var i = 0; i < listView.ColumnCount && i < headers.Length; i++)
        {
            var cell = listView.GetHeaderCell(i, listColPos, listColWidths);
            var offsetX = i >= 4 ? -4 : 0;
            builder.AddHtml(
                cell.X + offsetX,
                cell.Y + 3,
                cell.Width,
                30,
                headers[i],
                GumpTextColors.Gold,
                4,
                align: TextAlignment.Center
            );
        }

        // Draw spawner rows
        const int vCenter = 10;
        for (var i = 0; i < listView.VisibleCount; i++)
        {
            var dataIndex = listView.GetDataIndex(i);
            var spawner = _spawners[dataIndex];
            var rowY = listView.GetRowY(i);

            // Column 0: Copy button
            var col0X = listColPos[0];
            var col0Width = listColWidths[0];
            builder.AddButton(col0X + 15, rowY, 4011, 4012, GetButtonID(2, dataIndex));
            builder.AddHtml(col0X, rowY + 21, col0Width, 30, "copy", GumpTextColors.White, 3, align: TextAlignment.Center);

            // Column 1: Paste buttons
            var col1X = listColPos[1];
            var col1Width = listColWidths[1];
            var col1HCenter = col1X + col1Width / 2;
            builder.AddButton(col1X + 2, rowY, 4029, 4031, GetButtonID(3, dataIndex));
            builder.AddHtml(col1X + 3, rowY + 21, col1Width, 30, "props", GumpTextColors.White, 3);

            builder.AddButton(col1HCenter - 2, rowY, 4029, 4031, GetButtonID(4, dataIndex));
            builder.AddHtml(col1HCenter - 3, rowY + 21, 55, 30, "entry", GumpTextColors.White, 3);

            // Column 2: Name/Serial
            var col2X = listColPos[2];
            var col2Width = listColWidths[2];
            var entryIndex = i * EntryCount;

            builder.AddImageTiled(col2X + 6, rowY + 13, col2Width - 8, 1, 9357);
            builder.AddTextEntry(col2X + 8, rowY - 3, col2Width - 8, 80, GumpHues.White, entryIndex, spawner.Name);
            builder.AddButton(col2X + 8, rowY + 19, 5837, 5838, GetButtonID(6, dataIndex));
            builder.AddHtml(col2X + 54, rowY + 19, col2Width, 30, $"{spawner.Serial}", GumpTextColors.White, 4);

            // Column 3: Map
            var col3X = listColPos[3];
            var col3Width = listColWidths[3];
            builder.AddHtml(
                col3X,
                rowY + vCenter,
                col3Width,
                30,
                $"{spawner.Map}",
                GumpTextColors.White,
                4,
                align: TextAlignment.Center
            );

            // Column 4: Coords with teleport button
            var col4X = listColPos[4];
            var col4Width = listColWidths[4];
            builder.AddButton(col4X + 3, rowY + vCenter, 2062, 2062, GetButtonID(5, dataIndex));
            builder.AddImage(col4X + 3, rowY + vCenter, 2062, 936);
            builder.AddHtml(
                col4X + 12,
                rowY + vCenter,
                col4Width,
                30,
                $"X {spawner.Location.X} Y {spawner.Location.Y}",
                GumpTextColors.White,
                4
            );

            // Column 5: Entry count with button
            var col5X = listColPos[5];
            var col5Width = listColWidths[5];
            builder.AddButton(col5X + 6, rowY + vCenter - 4, 0x2635, 0x2635, GetButtonID(7, dataIndex));
            builder.AddImage(col5X + 6, rowY + vCenter - 7, 0x2635, 827);
            builder.AddHtml(
                col5X,
                rowY + vCenter,
                col5Width,
                30,
                $"{spawner.Entries?.Count ?? 0}",
                GumpTextColors.White,
                4,
                align: TextAlignment.Center
            );

            // Column 6: Walk Range
            var col6X = listColPos[6];
            var col6Width = listColWidths[6];
            builder.AddImageTiled(col6X + 8, rowY + 24, col6Width / 2, 1, 9357);
            builder.AddTextEntry(
                col6X + 12,
                rowY + 8,
                col6Width,
                80,
                GumpHues.White,
                entryIndex + 1,
                $"{spawner.WalkingRange}"
            );

            // Column 7: Home Range
            var col7X = listColPos[7];
            var col7Width = listColWidths[7];
            if (spawner.IsHomeRangeStyle)
            {
                builder.AddImageTiled(col7X + 8, rowY + 24, col7Width / 2, 1, 9357);
                builder.AddTextEntry(col7X + 12, rowY + 8, col7Width, 80, GumpHues.White, entryIndex + 2, $"{spawner.HomeRange}");
            }
            else
            {
                builder.AddHtml(col7X - 6, rowY + 8, col7Width, 30, "Custom", GumpTextColors.Yellow, 4, align: TextAlignment.Center);
            }

            // Column 8: Min Delay
            var col8X = listColPos[8];
            var col8Width = listColWidths[8];
            builder.AddImageTiled(col8X + 6, rowY + 24, col8Width - 20, 1, 9357);
            builder.AddTextEntry(col8X + 8, rowY + 8, col8Width, 80, GumpHues.White, entryIndex + 3, $"{spawner.MinDelay}");

            // Column 9: Max Delay
            var col9X = listColPos[9];
            var col9Width = listColWidths[9];
            builder.AddImageTiled(col9X + 6, rowY + 24, col9Width - 20, 1, 9357);
            builder.AddTextEntry(col9X + 8, rowY + 8, col9Width, 80, GumpHues.White, entryIndex + 4, $"{spawner.MaxDelay}");

            // Column 10: Next Spawn
            var col10X = listColPos[10];
            var col10Width = listColWidths[10];
            builder.AddHtml(
                col10X,
                rowY + vCenter,
                col10Width,
                30,
                $@"{spawner.NextSpawn:hh\:mm\:ss}",
                GumpTextColors.White,
                4,
                align: TextAlignment.Center
            );

            // Column 11: Actions
            var col11X = listColPos[11];
            builder.AddButton(col11X, rowY, 4023, 4025, GetButtonID(8, dataIndex));
            builder.AddHtml(col11X + 4, rowY + 21, 55, 30, "save", GumpTextColors.White, 3);

            builder.AddButton(col11X + RowHeight, rowY, 4017, 4018, GetButtonID(9, dataIndex));
            builder.AddHtml(col11X + RowHeight, rowY + 21, 55, 30, "delete", GumpTextColors.White, 3);

            // Row separator
            builder.AddImageTiled(0, rowY + RowHeight, GumpWidth, 1, 9357);
            builder.AddAlphaRegion(0, rowY + RowHeight, GumpWidth, 1);
        }

        // Draw footer
        const int col0HCenter = GumpWidth / 2;
        var row2VCenter = row2Y + mainRowHeights[2] / 2;

        if (listView.CanGoNext)
        {
            builder.AddButton(col0HCenter + 60, row2VCenter + 16, 4005, 4006, GetButtonID(10, 0));
        }

        if (listView.CanGoBack)
        {
            builder.AddButton(col0HCenter - 60, row2VCenter + 16, 4014, 4015, GetButtonID(11, 0));
        }

        builder.AddButton(15, row2Y, 4029, 4031, GetButtonID(1, 5));
        builder.AddHtml(55, row2Y + 4, GumpWidth, 20, $"Paste props for {_spawners.Length} spawners", GumpTextColors.Orange, 4);

        builder.AddButton(15, row2Y + 28, 4029, 4031, GetButtonID(1, 6));
        builder.AddHtml(55, row2Y + 32, GumpWidth, 20, $"Paste entry for {_spawners.Length} spawners", GumpTextColors.Orange, 4);

        builder.AddButton(275, row2Y, 4029, 4031, GetButtonID(1, 7));
        builder.AddHtml(315, row2Y + 4, GumpWidth, 20, "Paste copy to the ground", GumpTextColors.Yellow, 4);

        builder.AddHtml(
            16,
            row2VCenter + 17,
            GumpWidth,
            20,
            $"Pages {listView.CurrentPage + 1}/{listView.TotalPages}",
            GumpTextColors.White,
            4
        );
        builder.AddHtml(120, row2VCenter + 17, GumpWidth, 20, $"Total Spawners {_spawners.Length}", GumpTextColors.White, 4);
    }

    private void DrawSearch(ref DynamicGumpBuilder builder, int row0Y, int searchHeight)
    {
        // Create 2-column subgrid for search area
        Span<int> searchColPos = stackalloc int[2];
        Span<int> searchColWidths = stackalloc int[2];
        GridCalculator.ComputeUniformTrackSizes(2, GumpWidth, 0, searchColPos, searchColWidths);

        var col0X = searchColPos[0];
        var col1X = searchColPos[1];
        var col1HCenter = col1X + searchColWidths[1] / 2;
        var row0VCenter = row0Y + searchHeight / 2;

        const int deltaX = 140;

        // Labels
        builder.AddHtml(col0X, row0Y + 8, searchColWidths[0], 30, "Search type", GumpTextColors.Gold, 4, align: TextAlignment.Center);
        builder.AddHtml(col1X, row0Y + 8, searchColWidths[1], 30, "Search Match", GumpTextColors.Gold, 4, align: TextAlignment.Center);

        // Separators
        builder.AddImageTiled(0, row0Y + 30, GumpWidth, 3, 9357);
        builder.AddAlphaRegion(0, row0Y + 30, GumpWidth, 3);
        builder.AddImageTiled(col1X, row0Y, 3, searchHeight, 9355);
        builder.AddAlphaRegion(col1X, row0Y, 3, searchHeight);

        // Search type buttons
        var creature = _search.Type == SpawnSearchType.Creature ? 9021 : 9020;
        var coords = _search.Type == SpawnSearchType.Coords ? 9021 : 9020;
        var props = _search.Type == SpawnSearchType.Props ? 9021 : 9020;
        var name = _search.Type == SpawnSearchType.Name ? 9021 : 9020;

        builder.AddButton(col0X + 10, row0Y + 45, creature, creature, GetButtonID(1, 0));
        builder.AddHtml(col0X + 15, row0Y + 48, 100, 30, "Creature", GumpTextColors.White, 4, align: TextAlignment.Center);

        builder.AddButton(col0X + 10 + deltaX - 40, row0Y + 45, coords, coords, GetButtonID(1, 1));
        builder.AddHtml(col0X + 40 + deltaX - 40, row0Y + 48, 150, 30, "Range", GumpTextColors.White, 4);

        builder.AddButton(col0X + 10 + deltaX * 2 - 100, row0Y + 45, props, props, GetButtonID(1, 2));
        builder.AddHtml(col0X + 40 + deltaX * 2 - 100, row0Y + 48, 150, 30, "Creature Props", GumpTextColors.White, 4);

        builder.AddButton(col0X + 10 + deltaX * 3 - 100, row0Y + 45, name, name, GetButtonID(1, 3));
        builder.AddHtml(col0X + 40 + deltaX * 3 - 100, row0Y + 48, 150, 30, "Spawner Name", GumpTextColors.White, 4);

        // Search text entry
        builder.AddImageTiled(col1HCenter - 100, row0VCenter + 16, 200, 1, 9357);
        builder.AddTextEntry(col1HCenter - 100, row0VCenter, 200, 20, GumpHues.White, 0xFFFF, _search.SearchPattern);
        builder.AddButton(col1HCenter + 120, row0VCenter, 4023, 4024, GetButtonID(1, 4));

        // Search type description
        var description = (int)_search.Type switch
        {
            0 => "Search by creature name",
            1 => "Search by range (number)",
            2 => "Search by entry property field",
            3 => "Search by spawner name",
            _ => ""
        };
        builder.AddHtml(col1X, row0VCenter + 20, searchColWidths[1], 30, description, GumpTextColors.White, 4, align: TextAlignment.Center);
    }

    private void SearchSpawner()
    {
        if (_search.SearchPattern.Length < 1)
        {
            return;
        }

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

        if (_search.Type != SpawnSearchType.Coords || !int.TryParse(_search.SearchPattern, out var range))
        {
            range = -1;
        }

        foreach (var item in World.Items.Values)
        {
            if (item is not BaseSpawner spawner)
            {
                continue;
            }

            var enqueue = _search.Type switch
            {
                SpawnSearchType.Creature => SearchSpawnerCreatures(spawner, _search.SearchPattern),
                SpawnSearchType.Coords   => _mobile.InRange(spawner.Location, range),
                SpawnSearchType.Props    => SearchSpawnerProperties(spawner, _search.SearchPattern),
                SpawnSearchType.Name     => spawner.Name?.InsensitiveContains(_search.SearchPattern) == true,
                _                        => false
            };

            if (enqueue)
            {
                queue.Enqueue(spawner);
            }
        }

        _spawners = queue.ToArray();
    }

    private static bool SearchSpawnerCreatures(BaseSpawner spawner, string searchPattern)
    {
        foreach (var entry in spawner.Entries)
        {
            if (entry.SpawnedName?.InsensitiveContains(searchPattern) == true)
            {
                return true;
            }
        }

        return false;
    }

    private static bool SearchSpawnerProperties(BaseSpawner spawner, string searchPattern)
    {
        for (var i = 0; i < spawner.Entries.Count; i++)
        {
            var entry = spawner.Entries[i];
            if (entry.Properties?.InsensitiveContains(searchPattern) == true)
            {
                return true;
            }
        }

        return false;
    }

    public static void CopyProperty(BaseSpawner spawner, BaseSpawner target)
    {
        target.Name = spawner.Name;
        target.MinDelay = spawner.MinDelay;
        target.MaxDelay = spawner.MaxDelay;
        target.WalkingRange = spawner.WalkingRange;
        target.SpawnBounds = spawner.SpawnBounds;
        target.SpawnLocationIsHome = spawner.SpawnLocationIsHome;
        target.Group = spawner.Group;
        target.Count = spawner.Count;
    }

    public static void CopyEntry(BaseSpawner spawner, BaseSpawner target)
    {
        if (spawner.Entries?.Count > 0)
        {
            target.Entries?.Clear();

            for (var i = 0; i < spawner.Entries.Count; i++)
            {
                var item = spawner.Entries[i];
                var targetEntry = target.AddEntry(item.SpawnedName, item.SpawnedProbability, item.SpawnedMaxCount);
                targetEntry.Properties = item.Properties;
                targetEntry.Parameters = item.Parameters;
            }
        }
    }

    public void FullCopy(BaseSpawner spawner, BaseSpawner target)
    {
        CopyProperty(spawner, target);
        CopyEntry(spawner, target);
    }

    public void Refresh(Mobile mobile, bool reSearch = true)
    {
        if (reSearch)
        {
            SearchSpawner();
        }

        mobile.SendGump(this);
    }

    public override void OnResponse(NetState sender, in RelayInfo info)
    {
        var mobile = sender.Mobile;
        if (info.ButtonID == 0)
        {
            return;
        }

        var buttonID = info.ButtonID - 1;
        var type = buttonID % TypeCount;
        var index = buttonID / TypeCount;

        switch (type)
        {
            case 1:
                {
                    if (index < 4)
                    {
                        _search.Type = (SpawnSearchType)index;
                        var isNumeric = int.TryParse(_search.SearchPattern, out _);
                        if (index == 1 && !isNumeric || index != 1 && isNumeric)
                        {
                            _search.SearchPattern = "";
                        }
                    }
                    else if (index == 4)
                    {
                        var entry = info.GetTextEntry(0xFFFF);
                        if (entry?.Length > 0)
                        {
                            _search.SearchPattern = entry;
                        }
                    }
                    else if (index == 5 && _copy != null && _spawners?.Length > 0)
                    {
                        foreach (var spawner in _spawners)
                        {
                            CopyProperty(_copy, spawner);
                        }
                    }
                    else if (index == 6 && _copy != null && _spawners?.Length > 0)
                    {
                        foreach (var spawner in _spawners)
                        {
                            CopyEntry(_copy, spawner);
                        }
                    }
                    else if (index == 7 && _copy != null)
                    {
                        var newSpawner = new Spawner();
                        FullCopy(_copy, newSpawner);
                        newSpawner.Map = mobile.Map;
                        newSpawner.Location = mobile.Location;
                        newSpawner.Stop();
                        newSpawner.Start();
                        newSpawner.Respawn();
                    }

                    _page = 0;
                    break;
                }

            case 2:
                {
                    if (index < _spawners.Length)
                    {
                        _copy = _spawners[index];
                    }
                    break;
                }

            case 3:
                {
                    if (index < _spawners.Length && _copy != null)
                    {
                        CopyProperty(_copy, _spawners[index]);
                    }
                    break;
                }

            case 4:
                {
                    if (index < _spawners.Length && _copy != null)
                    {
                        CopyEntry(_copy, _spawners[index]);
                    }
                    break;
                }

            case 5:
                {
                    if (index < _spawners.Length)
                    {
                        var spawner = _spawners[index];
                        mobile.Map = spawner.Map;
                        mobile.Location = spawner.Location;
                    }
                    Refresh(mobile, reSearch: false);
                    return;
                }

            case 6:
            case 7:
                {
                    if (index < _spawners.Length)
                    {
                        var spawner = _spawners[index];
                        Refresh(mobile);

                        if (type == 7)
                        {
                            mobile.SendGump(new SpawnerGump(spawner));
                        }
                        else
                        {
                            mobile.SendGump(new PropertiesGump(mobile, spawner));
                        }
                        return;
                    }
                    break;
                }

            case 8:
                {
                    if (index < _spawners.Length)
                    {
                        var spawner = _spawners[index];
                        var entryIndex = index >= _lineCount ? (index - _lineCount * _page) * EntryCount : index * EntryCount;

                        var name = info.GetTextEntry(entryIndex);
                        if (name?.Length > 0)
                        {
                            spawner.Name = name;
                        }

                        if (int.TryParse(info.GetTextEntry(entryIndex + 1), out var walkRange))
                        {
                            spawner.WalkingRange = walkRange;
                        }

                        if (int.TryParse(info.GetTextEntry(entryIndex + 2), out var homeRange))
                        {
                            spawner.HomeRange = homeRange;
                        }

                        if (TimeSpan.TryParse(info.GetTextEntry(entryIndex + 3), out var minDelay))
                        {
                            spawner.MinDelay = minDelay;
                        }

                        if (TimeSpan.TryParse(info.GetTextEntry(entryIndex + 4), out var maxDelay))
                        {
                            spawner.MaxDelay = maxDelay;
                        }
                    }
                    break;
                }

            case 9:
                {
                    if (index < _spawners.Length)
                    {
                        _spawners[index].Delete();
                    }
                    break;
                }

            case 10:
                {
                    _page++;
                    Refresh(mobile, reSearch: false);
                    return;
                }

            case 11:
                {
                    if (_page > 0)
                    {
                        _page--;
                    }
                    Refresh(mobile, reSearch: false);
                    return;
                }
        }

        Refresh(mobile);
    }
}