using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using Server;
using Server.Items;
using Server.Network;
using Server.Targeting;
using CPA = Server.CommandPropertyAttribute;

namespace Server.Commands
{
    public class Add
    {
        public static void Initialize()
        {
            CommandSystem.Register("Tile", AccessLevel.GameMaster, new CommandEventHandler(Tile_OnCommand));
            CommandSystem.Register("TileRXYZ", AccessLevel.GameMaster, new CommandEventHandler(TileRXYZ_OnCommand));
            CommandSystem.Register("TileXYZ", AccessLevel.GameMaster, new CommandEventHandler(TileXYZ_OnCommand));
            CommandSystem.Register("TileZ", AccessLevel.GameMaster, new CommandEventHandler(TileZ_OnCommand));
            CommandSystem.Register("TileAvg", AccessLevel.GameMaster, new CommandEventHandler(TileAvg_OnCommand));

            CommandSystem.Register("Outline", AccessLevel.GameMaster, new CommandEventHandler(Outline_OnCommand));
            CommandSystem.Register("OutlineRXYZ", AccessLevel.GameMaster, new CommandEventHandler(OutlineRXYZ_OnCommand));
            CommandSystem.Register("OutlineXYZ", AccessLevel.GameMaster, new CommandEventHandler(OutlineXYZ_OnCommand));
            CommandSystem.Register("OutlineZ", AccessLevel.GameMaster, new CommandEventHandler(OutlineZ_OnCommand));
            CommandSystem.Register("OutlineAvg", AccessLevel.GameMaster, new CommandEventHandler(OutlineAvg_OnCommand));
        }

        public static void Invoke(Mobile from, Point3D start, Point3D end, string[] args)
        {
            Invoke(from, start, end, args, null, false, false);
        }

        public static void Invoke(Mobile from, Point3D start, Point3D end, string[] args, List<Container> packs)
        {
            Invoke(from, start, end, args, packs, false, false);
        }

        public static void Invoke(Mobile from, Point3D start, Point3D end, string[] args, List<Container> packs, bool outline, bool mapAvg)
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendFormat("{0} {1} building ", from.AccessLevel, CommandLogging.Format(from));

            if (start == end)
                sb.AppendFormat("at {0} in {1}", start, from.Map);
            else
                sb.AppendFormat("from {0} to {1} in {2}", start, end, from.Map);

            sb.Append(":");

            for (int i = 0; i < args.Length; ++i)
                sb.AppendFormat(" \"{0}\"", args[i]);

            CommandLogging.WriteLine(from, sb.ToString());

            string name = args[0];

            FixArgs(ref args);

            string[,] props = null;

            for (int i = 0; i < args.Length; ++i)
            {
                if (Insensitive.Equals(args[i], "set"))
                {
                    int remains = args.Length - i - 1;

                    if (remains >= 2)
                    {
                        props = new string[remains / 2, 2];

                        remains /= 2;

                        for (int j = 0; j < remains; ++j)
                        {
                            props[j, 0] = args[i + (j * 2) + 1];
                            props[j, 1] = args[i + (j * 2) + 2];
                        }

                        FixSetString(ref args, i);
                    }

                    break;
                }
            }

            Type type = ScriptCompiler.FindTypeByName(name);

            if (!IsEntity(type))
            {
                from.SendMessage("No type with that name was found.");
                return;
            }

            DateTime time = DateTime.Now;

            int built = BuildObjects(from, type, start, end, args, props, packs, outline, mapAvg);

            if (built > 0)
                from.SendMessage("{0} object{1} generated in {2:F1} seconds.", built, built != 1 ? "s" : "", (DateTime.Now - time).TotalSeconds);
            else
                SendUsage(type, from);
        }

        public static void FixSetString(ref string[] args, int index)
        {
            string[] old = args;
            args = new string[index];

            Array.Copy(old, 0, args, 0, index);
        }

        public static void FixArgs(ref string[] args)
        {
            string[] old = args;
            args = new string[args.Length - 1];

            Array.Copy(old, 1, args, 0, args.Length);
        }

        public static int BuildObjects(Mobile from, Type type, Point3D start, Point3D end, string[] args, string[,] props, List<Container> packs)
        {
            return BuildObjects(from, type, start, end, args, props, packs, false, false);
        }

        public static int BuildObjects(Mobile from, Type type, Point3D start, Point3D end, string[] args, string[,] props, List<Container> packs, bool outline, bool mapAvg)
        {
            Utility.FixPoints(ref start, ref end);

            PropertyInfo[] realProps = null;

            if (props != null)
            {
                realProps = new PropertyInfo[props.GetLength(0)];

                PropertyInfo[] allProps = type.GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public);

                for (int i = 0; i < realProps.Length; ++i)
                {
                    PropertyInfo thisProp = null;

                    string propName = props[i, 0];

                    for (int j = 0; thisProp == null && j < allProps.Length; ++j)
                    {
                        if (Insensitive.Equals(propName, allProps[j].Name))
                            thisProp = allProps[j];
                    }

                    if (thisProp == null)
                    {
                        from.SendMessage("Property not found: {0}", propName);
                    }
                    else
                    {
                        CPA attr = Properties.GetCPA(thisProp);

                        if (attr == null)
                            from.SendMessage("Property ({0}) not found.", propName);
                        else if (from.AccessLevel < attr.WriteLevel)
                            from.SendMessage("Setting this property ({0}) requires at least {1} access level.", propName, Mobile.GetAccessLevelName(attr.WriteLevel));
                        else if (!thisProp.CanWrite || attr.ReadOnly)
                            from.SendMessage("Property ({0}) is read only.", propName);
                        else
                            realProps[i] = thisProp;
                    }
                }
            }

            ConstructorInfo[] ctors = type.GetConstructors();

            for (int i = 0; i < ctors.Length; ++i)
            {
                ConstructorInfo ctor = ctors[i];

                if (!IsConstructable(ctor, from.AccessLevel))
                    continue;

                ParameterInfo[] paramList = ctor.GetParameters();

                if (args.Length == paramList.Length)
                {
                    object[] paramValues = ParseValues(paramList, args);

                    if (paramValues == null)
                        continue;

                    int built = Build(from, start, end, ctor, paramValues, props, realProps, packs, outline, mapAvg);

                    if (built > 0)
                        return built;
                }
            }

            return 0;
        }

        public static object[] ParseValues(ParameterInfo[] paramList, string[] args)
        {
            object[] values = new object[args.Length];

            for (int i = 0; i < args.Length; ++i)
            {
                object value = ParseValue(paramList[i].ParameterType, args[i]);

                if (value != null)
                    values[i] = value;
                else
                    return null;
            }

            return values;
        }

        public static object ParseValue(Type type, string value)
        {
            try
            {
                if (IsEnum(type))
                {
                    return Enum.Parse(type, value, true);
                }
                else if (IsType(type))
                {
                    return ScriptCompiler.FindTypeByName(value);
                }
                else if (IsParsable(type))
                {
                    return ParseParsable(type, value);
                }
                else
                {
                    object obj = value;

                    if (value != null && value.StartsWith("0x"))
                    {
                        if (IsSignedNumeric(type))
                            obj = Convert.ToInt64(value.Substring(2), 16);
                        else if (IsUnsignedNumeric(type))
                            obj = Convert.ToUInt64(value.Substring(2), 16);

                        obj = Convert.ToInt32(value.Substring(2), 16);
                    }

                    if (obj == null && !type.IsValueType)
                        return null;
                    else
                        return Convert.ChangeType(obj, type);
                }
            }
            catch
            {
                return null;
            }
        }

        public static IEntity Build(Mobile from, ConstructorInfo ctor, object[] values, string[,] props, PropertyInfo[] realProps, ref bool sendError)
        {
            object built = ctor.Invoke(values);

            if (built != null && realProps != null)
            {
                bool hadError = false;

                for (int i = 0; i < realProps.Length; ++i)
                {
                    if (realProps[i] == null)
                        continue;

                    string result = Properties.InternalSetValue(from, built, built, realProps[i], props[i, 1], props[i, 1], false);

                    if (result != "Property has been set.")
                    {
                        if (sendError)
                            from.SendMessage(result);

                        hadError = true;
                    }
                }

                if (hadError)
                    sendError = false;
            }

            return (IEntity)built;
        }

        public static int Build(Mobile from, Point3D start, Point3D end, ConstructorInfo ctor, object[] values, string[,] props, PropertyInfo[] realProps, List<Container> packs)
        {
            return Build(from, start, end, ctor, values, props, realProps, packs, false, false);
        }

        public static int Build(Mobile from, Point3D start, Point3D end, ConstructorInfo ctor, object[] values, string[,] props, PropertyInfo[] realProps, List<Container> packs, bool outline, bool mapAvg)
        {
            try
            {
                Map map = from.Map;

                int width = end.X - start.X + 1;
                int height = end.Y - start.Y + 1;

                if (outline && (width < 3 || height < 3))
                    outline = false;

                int objectCount;

                if (packs != null)
                    objectCount = packs.Count;
                else if (outline)
                    objectCount = (width + height - 2) * 2;
                else
                    objectCount = width * height;

                if (objectCount >= 20)
                    from.SendMessage("Constructing {0} objects, please wait.", objectCount);

                bool sendError = true;

                StringBuilder sb = new StringBuilder();
                sb.Append("Serials: ");

                if (packs != null)
                {
                    for (int i = 0; i < packs.Count; ++i)
                    {
                        IEntity built = Build(from, ctor, values, props, realProps, ref sendError);

                        sb.AppendFormat("0x{0:X}; ", built.Serial.Value);

                        if (built is Item)
                        {
                            Container pack = packs[i];
                            pack.DropItem((Item)built);
                        }
                        else if (built is Mobile)
                        {
                            Mobile m = (Mobile)built;
                            m.MoveToWorld(new Point3D(start.X, start.Y, start.Z), map);
                        }
                    }
                }
                else
                {
                    int z = start.Z;

                    for (int x = start.X; x <= end.X; ++x)
                    {
                        for (int y = start.Y; y <= end.Y; ++y)
                        {
                            if (outline && x != start.X && x != end.X && y != start.Y && y != end.Y)
                                continue;

                            if (mapAvg)
                                z = map.GetAverageZ(x, y);

                            IEntity built = Build(from, ctor, values, props, realProps, ref sendError);

                            sb.AppendFormat("0x{0:X}; ", built.Serial.Value);

                            if (built is Item)
                            {
                                Item item = (Item)built;
                                item.MoveToWorld(new Point3D(x, y, z), map);
                            }
                            else if (built is Mobile)
                            {
                                Mobile m = (Mobile)built;
                                m.MoveToWorld(new Point3D(x, y, z), map);
                            }
                        }
                    }
                }

                CommandLogging.WriteLine(from, sb.ToString());

                return objectCount;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                return 0;
            }
        }

        public static void SendUsage(Type type, Mobile from)
        {
            ConstructorInfo[] ctors = type.GetConstructors();
            bool foundCtor = false;

            for (int i = 0; i < ctors.Length; ++i)
            {
                ConstructorInfo ctor = ctors[i];

                if (!IsConstructable(ctor, from.AccessLevel))
                    continue;

                if (!foundCtor)
                {
                    foundCtor = true;
                    from.SendMessage("Usage:");
                }

                SendCtor(type, ctor, from);
            }

            if (!foundCtor)
                from.SendMessage("That type is not marked constructable.");
        }

        public static void SendCtor(Type type, ConstructorInfo ctor, Mobile from)
        {
            ParameterInfo[] paramList = ctor.GetParameters();

            StringBuilder sb = new StringBuilder();

            sb.Append(type.Name);

            for (int i = 0; i < paramList.Length; ++i)
            {
                if (i != 0)
                    sb.Append(',');

                sb.Append(' ');

                sb.Append(paramList[i].ParameterType.Name);
                sb.Append(' ');
                sb.Append(paramList[i].Name);
            }

            from.SendMessage(sb.ToString());
        }

        public class AddTarget : Target
        {
            private string[] m_Args;

            public AddTarget(string[] args)
                : base(-1, true, TargetFlags.None)
            {
                m_Args = args;
            }

            protected override void OnTarget(Mobile from, object o)
            {
                IPoint3D p = o as IPoint3D;

                if (p != null)
                {
                    if (p is Item)
                        p = ((Item)p).GetWorldTop();
                    else if (p is Mobile)
                        p = ((Mobile)p).Location;

                    Point3D point = new Point3D(p);
                    Add.Invoke(from, point, point, m_Args);
                }
            }
        }

        private enum TileZType
        {
            Start,
            Fixed,
            MapAverage
        }

        private class TileState
        {
            public TileZType m_ZType;
            public int m_FixedZ;
            public string[] m_Args;
            public bool m_Outline;

            public TileState(TileZType zType, int fixedZ, string[] args, bool outline)
            {
                m_ZType = zType;
                m_FixedZ = fixedZ;
                m_Args = args;
                m_Outline = outline;
            }
        }

        private static void TileBox_Callback(Mobile from, Map map, Point3D start, Point3D end, object state)
        {
            TileState ts = (TileState)state;
            bool mapAvg = false;

            switch (ts.m_ZType)
            {
                case TileZType.Fixed:
                    {
                        start.Z = end.Z = ts.m_FixedZ;
                        break;
                    }
                case TileZType.MapAverage:
                    {
                        mapAvg = true;
                        break;
                    }
            }

            Invoke(from, start, end, ts.m_Args, null, ts.m_Outline, mapAvg);
        }

        private static void Internal_OnCommand(CommandEventArgs e, bool outline)
        {
            if (e.Length >= 1)
                BoundingBoxPicker.Begin(e.Mobile, new BoundingBoxCallback(TileBox_Callback), new TileState(TileZType.Start, 0, e.Arguments, outline));
            else
                e.Mobile.SendMessage("Format: {0} <type> [params] [set {{<propertyName> <value> ...}}]", outline ? "Outline" : "Tile");
        }

        private static void InternalRXYZ_OnCommand(CommandEventArgs e, bool outline)
        {
            if (e.Length >= 6)
            {
                Point3D p = new Point3D(e.Mobile.X + e.GetInt32(0), e.Mobile.Y + e.GetInt32(1), e.Mobile.Z + e.GetInt32(4));
                Point3D p2 = new Point3D(p.X + e.GetInt32(2) - 1, p.Y + e.GetInt32(3) - 1, p.Z);

                string[] subArgs = new string[e.Length - 5];

                for (int i = 0; i < subArgs.Length; ++i)
                    subArgs[i] = e.Arguments[i + 5];

                Add.Invoke(e.Mobile, p, p2, subArgs, null, outline, false);
            }
            else
            {
                e.Mobile.SendMessage("Format: {0}RXYZ <x> <y> <w> <h> <z> <type> [params] [set {{<propertyName> <value> ...}}]", outline ? "Outline" : "Tile");
            }
        }

        private static void InternalXYZ_OnCommand(CommandEventArgs e, bool outline)
        {
            if (e.Length >= 6)
            {
                Point3D p = new Point3D(e.GetInt32(0), e.GetInt32(1), e.GetInt32(4));
                Point3D p2 = new Point3D(p.X + e.GetInt32(2) - 1, p.Y + e.GetInt32(3) - 1, e.GetInt32(4));

                string[] subArgs = new string[e.Length - 5];

                for (int i = 0; i < subArgs.Length; ++i)
                    subArgs[i] = e.Arguments[i + 5];

                Add.Invoke(e.Mobile, p, p2, subArgs, null, outline, false);
            }
            else
            {
                e.Mobile.SendMessage("Format: {0}XYZ <x> <y> <w> <h> <z> <type> [params] [set {{<propertyName> <value> ...}}]", outline ? "Outline" : "Tile");
            }
        }

        private static void InternalZ_OnCommand(CommandEventArgs e, bool outline)
        {
            if (e.Length >= 2)
            {
                string[] subArgs = new string[e.Length - 1];

                for (int i = 0; i < subArgs.Length; ++i)
                    subArgs[i] = e.Arguments[i + 1];

                BoundingBoxPicker.Begin(e.Mobile, new BoundingBoxCallback(TileBox_Callback), new TileState(TileZType.Fixed, e.GetInt32(0), subArgs, outline));
            }
            else
            {
                e.Mobile.SendMessage("Format: {0}Z <z> <type> [params] [set {{<propertyName> <value> ...}}]", outline ? "Outline" : "Tile");
            }
        }

        private static void InternalAvg_OnCommand(CommandEventArgs e, bool outline)
        {
            if (e.Length >= 1)
                BoundingBoxPicker.Begin(e.Mobile, new BoundingBoxCallback(TileBox_Callback), new TileState(TileZType.MapAverage, 0, e.Arguments, outline));
            else
                e.Mobile.SendMessage("Format: {0}Avg <type> [params] [set {{<propertyName> <value> ...}}]", outline ? "Outline" : "Tile");
        }

        [Usage("Tile <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name into a targeted bounding box. Optional constructor parameters. Optional set property list.")]
        public static void Tile_OnCommand(CommandEventArgs e)
        {
            Internal_OnCommand(e, false);
        }

        [Usage("TileRXYZ <x> <y> <w> <h> <z> <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name into a given bounding box, (x, y) parameters are relative to your characters position. Optional constructor parameters. Optional set property list.")]
        public static void TileRXYZ_OnCommand(CommandEventArgs e)
        {
            InternalRXYZ_OnCommand(e, false);
        }

        [Usage("TileXYZ <x> <y> <w> <h> <z> <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name into a given bounding box. Optional constructor parameters. Optional set property list.")]
        public static void TileXYZ_OnCommand(CommandEventArgs e)
        {
            InternalXYZ_OnCommand(e, false);
        }

        [Usage("TileZ <z> <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name into a targeted bounding box at a fixed Z location. Optional constructor parameters. Optional set property list.")]
        public static void TileZ_OnCommand(CommandEventArgs e)
        {
            InternalZ_OnCommand(e, false);
        }

        [Usage("TileAvg <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name into a targeted bounding box on the map's average Z elevation. Optional constructor parameters. Optional set property list.")]
        public static void TileAvg_OnCommand(CommandEventArgs e)
        {
            InternalAvg_OnCommand(e, false);
        }

        [Usage("Outline <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name around a targeted bounding box. Optional constructor parameters. Optional set property list.")]
        public static void Outline_OnCommand(CommandEventArgs e)
        {
            Internal_OnCommand(e, true);
        }

        [Usage("OutlineRXYZ <x> <y> <w> <h> <z> <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name around a given bounding box, (x, y) parameters are relative to your characters position. Optional constructor parameters. Optional set property list.")]
        public static void OutlineRXYZ_OnCommand(CommandEventArgs e)
        {
            InternalRXYZ_OnCommand(e, true);
        }

        [Usage("OutlineXYZ <x> <y> <w> <h> <z> <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name around a given bounding box. Optional constructor parameters. Optional set property list.")]
        public static void OutlineXYZ_OnCommand(CommandEventArgs e)
        {
            InternalXYZ_OnCommand(e, true);
        }

        [Usage("OutlineZ <z> <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name around a targeted bounding box at a fixed Z location. Optional constructor parameters. Optional set property list.")]
        public static void OutlineZ_OnCommand(CommandEventArgs e)
        {
            InternalZ_OnCommand(e, true);
        }

        [Usage("OutlineAvg <name> [params] [set {<propertyName> <value> ...}]")]
        [Description("Tiles an item or npc by name around a targeted bounding box on the map's average Z elevation. Optional constructor parameters. Optional set property list.")]
        public static void OutlineAvg_OnCommand(CommandEventArgs e)
        {
            InternalAvg_OnCommand(e, true);
        }

        private static Type m_EntityType = typeof(IEntity);

        public static bool IsEntity(Type t)
        {
            return m_EntityType.IsAssignableFrom(t);
        }

        private static Type m_ConstructableType = typeof(ConstructableAttribute);

        public static bool IsConstructable(ConstructorInfo ctor, AccessLevel accessLevel)
        {
            object[] attrs = ctor.GetCustomAttributes(m_ConstructableType, false);

            if (attrs.Length == 0)
                return false;

            return accessLevel >= ((ConstructableAttribute)attrs[0]).AccessLevel;
        }

        private static Type m_EnumType = typeof(Enum);

        public static bool IsEnum(Type type)
        {
            return type.IsSubclassOf(m_EnumType);
        }

        private static Type m_TypeType = typeof(Type);

        public static bool IsType(Type type)
        {
            return (type == m_TypeType || type.IsSubclassOf(m_TypeType));
        }

        private static Type m_ParsableType = typeof(ParsableAttribute);

        public static bool IsParsable(Type type)
        {
            return type.IsDefined(m_ParsableType, false);
        }

        private static Type[] m_ParseTypes = new Type[] { typeof(string) };
        private static object[] m_ParseArgs = new object[1];

        public static object ParseParsable(Type type, string value)
        {
            MethodInfo method = type.GetMethod("Parse", m_ParseTypes);

            m_ParseArgs[0] = value;

            return method.Invoke(null, m_ParseArgs);
        }

        private static Type[] m_SignedNumerics = new Type[]
			{
				typeof( Int64 ),
				typeof( Int32 ),
				typeof( Int16 ),
				typeof( SByte )
			};

        public static bool IsSignedNumeric(Type type)
        {
            for (int i = 0; i < m_SignedNumerics.Length; ++i)
                if (type == m_SignedNumerics[i])
                    return true;

            return false;
        }

        private static Type[] m_UnsignedNumerics = new Type[]
			{
				typeof( UInt64 ),
				typeof( UInt32 ),
				typeof( UInt16 ),
				typeof( Byte )
			};

        public static bool IsUnsignedNumeric(Type type)
        {
            for (int i = 0; i < m_UnsignedNumerics.Length; ++i)
                if (type == m_UnsignedNumerics[i])
                    return true;

            return false;
        }
    }
}