using System.IO;
using System.Collections;
using Server.Items;
using Server.Mobiles;

namespace Server.Engines.XmlSpawner2;

public class WriteMulti
{
    private class TileEntry
    {
        public int ID;
        public int X;
        public int Y;
        public int Z;

        public TileEntry(int id, int x, int y, int z)
        {
            ID = id;
            X = x;
            Y = y;
            Z = z;
        }
    }

    public static void Initialize()
    {

        CommandSystem.Register("WriteMulti", XmlSpawner.DiskAccessLevel, WriteMulti_OnCommand);
    }

    [Usage("WriteMulti <MultiFile> [zmin zmax][-noitems][-nostatics][-nomultis][-noaddons][-invisible]")]
    [Description("Creates a multi text file from the objects within the targeted area.  The min/max z range can also be specified.")]
    public static void WriteMulti_OnCommand(CommandEventArgs e)
    {
        if (e == null || e.Mobile == null)
        {
            return;
        }

        if (e.Mobile.AccessLevel < XmlSpawner.DiskAccessLevel)
        {
            e.Mobile.SendMessage("You do not have rights to perform this command.");
            return;
        }

        if (e.Arguments != null && e.Arguments.Length < 1)
        {
            e.Mobile.SendMessage($"Usage:  {e.Command} <MultiFile> [zmin zmax][-noitems][-nostatics][-nomultis][-noaddons][-invisible]");
            return;
        }

        string filename = e.Arguments[0];

        int zmin = int.MinValue;
        int zmax = int.MinValue;
        bool includeitems = true;
        bool includestatics = true;
        bool includemultis = true;
        bool includeaddons = true;
        bool includeinvisible = false;

        if (e.Arguments.Length > 1)
        {
            int index = 1;
            while (index < e.Arguments.Length)
            {
                if (e.Arguments[index] == "-noitems")
                {
                    includeitems = false;
                    index++;
                }
                else if (e.Arguments[index] == "-nostatics")
                {
                    includestatics = false;
                    index++;
                }
                else if (e.Arguments[index] == "-nomultis")
                {
                    includemultis = false;
                    index++;
                }
                else if (e.Arguments[index] == "-noaddons")
                {
                    includeaddons = false;
                    index++;
                }
                else if (e.Arguments[index] == "-invisible")
                {
                    includeinvisible = true;
                    index++;
                }
                else
                {
                    try
                    {
                        zmin = int.Parse(e.Arguments[index++]);
                        zmax = int.Parse(e.Arguments[index++]);
                    }
                    catch
                    {
                        e.Mobile.SendMessage($"{e.Command} : Invalid zmin zmax arguments");
                        return;
                    }
                }
            }
        }

        string dirname;
        if (Directory.Exists(XmlSpawner.XmlSpawnDir) && filename != null && !filename.StartsWith("/") && !filename.StartsWith("\\"))
        {
            // put it in the defaults directory if it exists
            dirname = $"{XmlSpawner.XmlSpawnDir}/{filename}";
        }
        else
        {
            // otherwise just put it in the main installation dir
            dirname = filename;
        }

        // check to see if the file already exists and can be written to by the owner
        if (File.Exists(dirname))
        {

            // check the file
            try
            {
                StreamReader op = new StreamReader(dirname, false);
                string line = op.ReadLine();

                op.Close();

                // check the first line
                if (line != null && line.Length > 0)
                {

                    string[] args = line.Split(" ".ToCharArray(), 3);
                    if (args.Length < 3)
                    {
                        e.Mobile.SendMessage($"Cannot overwrite file {dirname} : not owner");
                        return;
                    }

                    if (args[2] != e.Mobile.Name)
                    {
                        e.Mobile.SendMessage($"Cannot overwrite file {dirname} : not owner");
                        return;
                    }
                }
                else
                {
                    e.Mobile.SendMessage($"Cannot overwrite file {dirname} : not owner");
                    return;
                }

            }
            catch
            {
                e.Mobile.SendMessage($"Cannot overwrite file {dirname}");
                return;
            }

        }

        DefineMultiArea(e.Mobile, dirname, zmin, zmax, includeitems, includestatics, includemultis, includeinvisible, includeaddons);
    }

    public static void DefineMultiArea(Mobile m, string dirname, int zmin, int zmax, bool includeitems, bool includestatics,
        bool includemultis, bool includeinvisible, bool includeaddons)
    {
        BoundingBoxPicker.Begin(
            m,
            (map, start, end) => DefineMultiArea_Callback(
                m,
                map,
                start,
                end,
                dirname,
                zmin,
                zmax,
                includeitems,
                includestatics,
                includemultis,
                includeinvisible,
                includeaddons
            )
        );
    }

    private static void DefineMultiArea_Callback(
        Mobile from,
        Map map,
        Point3D start,
        Point3D end,
        string dirname,
        int zmin,
        int zmax,
        bool includeitems,
        bool includestatics,
        bool includemultis,
        bool includeinvisible,
        bool includeaddons
    )
    {
        if (from != null && map != null)
        {
            ArrayList itemlist = new ArrayList();
            ArrayList staticlist = new ArrayList();
            ArrayList tilelist = new ArrayList();

            int sx = start.X > end.X ? end.X : start.X;
            int sy = start.Y > end.Y ? end.Y : start.Y;
            int ex = start.X < end.X ? end.X : start.X;
            int ey = start.Y < end.Y ? end.Y : start.Y;

            // find all of the world-placed items within the specified area
            if (includeitems)
            {
                // make the first pass for items only
                IPooledEnumerable eable = map.GetItemsInBounds(new Rectangle2D(sx, sy, ex - sx + 1, ey - sy + 1));

                foreach (Item item in eable)
                {
                    // is it within the bounding area
                    if (item.Parent == null && (zmin == int.MinValue || item.Location.Z >= zmin && item.Location.Z <= zmax))
                    {
                        // add the item
                        if ((includeinvisible || item.Visible) && item.ItemID <= 16383)
                        {
                            itemlist.Add(item);
                        }
                    }
                }

                eable.Free();

                int searchrange = 100;

                // make the second expanded pass to pick up addon components and multi components
                eable = map.GetItemsInBounds(new Rectangle2D(sx - searchrange, sy - searchrange, ex - sy + searchrange * 2 + 1,
                    ey - sy + searchrange * 2 + 1));

                foreach (Item item in eable)
                {
                    // is it within the bounding area
                    if (item.Parent == null)
                    {

                        if (item is BaseAddon addon && includeaddons)
                        {
                            // go through all of the addon components
                            foreach (AddonComponent c in addon.Components)
                            {
                                int x = c.X;
                                int y = c.Y;
                                int z = c.Z;

                                if ((includeinvisible || addon.Visible) && (addon.ItemID <= 16383 || includemultis) &&
                                    x >= sx && x <= ex && y >= sy && y <= ey && (zmin == int.MinValue || z >= zmin && z <= zmax))
                                {
                                    itemlist.Add(c);
                                }
                            }
                        }

                        if (item is BaseMulti multi && includemultis)
                        {
                            // go through all of the multi components
                            MultiComponentList mcl = multi.Components;
                            if (mcl != null && mcl.List != null)
                            {
                                for (int i = 0; i < mcl.List.Length; i++)
                                {
                                    MultiTileEntry t = mcl.List[i];

                                    int x = t.OffsetX + multi.X;
                                    int y = t.OffsetY + multi.Y;
                                    int z = t.OffsetZ + multi.Z;
                                    int itemID = t.ItemId & 0x3FFF;

                                    if (x >= sx && x <= ex && y >= sy && y <= ey && (zmin == int.MinValue || z >= zmin && z <= zmax))
                                    {
                                        tilelist.Add(new TileEntry(itemID, x, y, z));
                                    }
                                }

                            }
                        }
                    }
                }

                eable.Free();
            }

            // find all of the static tiles within the specified area
            if (includestatics)
            {
                // count the statics
                for (int x = sx; x < ex; x++)
                {
                    for (int y = sy; y < ey; y++)
                    {
                        StaticTile[] statics = map.Tiles.GetStaticTiles(x, y, false);

                        for (int j = 0; j < statics.Length; j++)
                        {
                            if (zmin == int.MinValue || statics[j].Z >= zmin && statics[j].Z <= zmax)
                            {
                                staticlist.Add(new TileEntry(statics[j].ID & 0x3FFF, x, y, statics[j].Z));
                            }
                        }
                    }
                }
            }

            int nstatics = staticlist.Count;
            int nitems = itemlist.Count;
            int ntiles = tilelist.Count;

            int ntotal = nitems + nstatics + ntiles;

            int ninvisible = 0;
            int nmultis = ntiles;
            int naddons = 0;

            foreach (Item item in itemlist)
            {
                int x = item.X - from.X;
                int y = item.Y - from.Y;
                int z = item.Z - from.Z;

                if (item.ItemID > 16383)
                {
                    nmultis++;
                }
                if (!item.Visible)
                {
                    ninvisible++;
                }
                if (item is BaseAddon || item is AddonComponent)
                {
                    naddons++;
                }
            }

            try
            {
                // open the file, overwrite any previous contents
                StreamWriter op = new StreamWriter(dirname, false);

                if (op != null)
                {
                    // write the header
                    op.WriteLine("1 version {0}", from.Name);
                    op.WriteLine("{0} num components", ntotal);

                    // write out the items
                    foreach (Item item in itemlist)
                    {

                        int x = item.X - from.X;
                        int y = item.Y - from.Y;
                        int z = item.Z - from.Z;

                        if (item.Hue > 0)
                        {
                            // format is x y z visible hue
                            op.WriteLine("{0} {1} {2} {3} {4} {5}", item.ItemID, x, y, z, item.Visible ? 1 : 0, item.Hue);
                        }
                        else
                        {
                            // format is x y z visible
                            op.WriteLine("{0} {1} {2} {3} {4}", item.ItemID, x, y, z, item.Visible ? 1 : 0);
                        }
                    }

                    if (includestatics)
                    {
                        foreach (TileEntry s in staticlist)
                        {
                            int x = s.X - from.X;
                            int y = s.Y - from.Y;
                            int z = s.Z - from.Z;
                            int ID = s.ID;
                            op.WriteLine("{0} {1} {2} {3} {4}", ID, x, y, z, 1);
                        }
                    }

                    if (includemultis)
                    {
                        foreach (TileEntry s in tilelist)
                        {
                            int x = s.X - from.X;
                            int y = s.Y - from.Y;
                            int z = s.Z - from.Z;
                            int ID = s.ID;
                            op.WriteLine("{0} {1} {2} {3} {4}", ID, x, y, z, 1);
                        }
                    }
                }

                op.Close();
            }
            catch
            {
                from.SendMessage($"Error writing multi file {dirname}");
                return;
            }

            from.SendMessage(66, "WriteMulti results:");

            if (includeitems)
            {
                from.SendMessage(66, $"Included {nitems} items");

                if (includemultis)
                {
                    from.SendMessage($"{nmultis} multis");
                }
                else
                {
                    from.SendMessage(33, "Ignored multis");
                }

                if (includeinvisible)
                {
                    from.SendMessage($"{ninvisible} invisible");
                }
                else
                {
                    from.SendMessage(33, "Ignored invisible");
                }

                if (includeaddons)
                {
                    from.SendMessage($"{naddons} addons");
                }
                else
                {
                    from.SendMessage(33, "Ignored addons");
                }

            }
            else
            {
                from.SendMessage(33, "Ignored items");
            }

            if (includestatics)
            {
                from.SendMessage(66, $"Included {nstatics} statics");
            }
            else
            {
                from.SendMessage(33, "Ignored statics");
            }

            from.SendMessage(66, $"Saved {ntotal} components to {dirname}");
        }
    }
}