using System;
using System.Collections;
using System.Collections.Generic;
using Server.Commands;
using Server.ContextMenus;
using Server.Mobiles;

namespace Server.Regions
{
    public class SpawnEntry : ISpawner
    {
        public static readonly TimeSpan DefaultMinSpawnTime = TimeSpan.FromMinutes(2.0);
        public static readonly TimeSpan DefaultMaxSpawnTime = TimeSpan.FromMinutes(5.0);
        public static readonly Direction InvalidDirection = Direction.Running;
        private static readonly Hashtable m_Table = new Hashtable();
        private static List<IEntity> m_RemoveList;
        private readonly int m_ID;
        private readonly BaseRegion m_Region;
        private readonly Point3D m_Home;
        private readonly int m_Range;
        private readonly Direction m_Direction;
        private readonly SpawnDefinition m_Definition;
        private readonly List<ISpawnable> m_SpawnedObjects;
        private readonly TimeSpan m_MinSpawnTime;
        private readonly TimeSpan m_MaxSpawnTime;
        private int m_Max;
        private bool m_Running;
        private DateTime m_NextSpawn;
        private Timer m_SpawnTimer;
        public SpawnEntry(int id, BaseRegion region, Point3D home, int range, Direction direction, SpawnDefinition definition, int max, TimeSpan minSpawnTime, TimeSpan maxSpawnTime)
        {
            this.m_ID = id;
            this.m_Region = region;
            this.m_Home = home;
            this.m_Range = range;
            this.m_Direction = direction;
            this.m_Definition = definition;
            this.m_SpawnedObjects = new List<ISpawnable>();
            this.m_Max = max;
            this.m_MinSpawnTime = minSpawnTime;
            this.m_MaxSpawnTime = maxSpawnTime;
            this.m_Running = false;

            if (m_Table.Contains(id))
                Console.WriteLine("Warning: double SpawnEntry ID '{0}'", id);
            else
                m_Table[id] = this;
        }

        public static Hashtable Table
        {
            get
            {
                return m_Table;
            }
        }
        // When a creature's AI is deactivated (PlayerRangeSensitive optimization) does it return home?
        public bool ReturnOnDeactivate
        {
            get
            {
                return true;
            }
        }
        // Are creatures unlinked on taming (true) or should they also go out of the region (false)?
        public bool UnlinkOnTaming
        {
            get
            {
                return false;
            }
        }
        // Are unlinked and untamed creatures removed after 20 hours?
        public bool RemoveIfUntamed
        {
            get
            {
                return true;
            }
        }
        public int ID
        {
            get
            {
                return this.m_ID;
            }
        }
        public BaseRegion Region
        {
            get
            {
                return this.m_Region;
            }
        }
        public Point3D HomeLocation
        {
            get
            {
                return this.m_Home;
            }
        }
        public int HomeRange
        {
            get
            {
                return this.m_Range;
            }
        }
        public Direction Direction
        {
            get
            {
                return this.m_Direction;
            }
        }
        public SpawnDefinition Definition
        {
            get
            {
                return this.m_Definition;
            }
        }
        public List<ISpawnable> SpawnedObjects
        {
            get
            {
                return this.m_SpawnedObjects;
            }
        }
        public int Max
        {
            get
            {
                return this.m_Max;
            }
        }
        public TimeSpan MinSpawnTime
        {
            get
            {
                return this.m_MinSpawnTime;
            }
        }
        public TimeSpan MaxSpawnTime
        {
            get
            {
                return this.m_MaxSpawnTime;
            }
        }
        public bool Running
        {
            get
            {
                return this.m_Running;
            }
        }
        public bool Complete
        {
            get
            {
                return this.m_SpawnedObjects.Count >= this.m_Max;
            }
        }
        public bool Spawning
        {
            get
            {
                return this.m_Running && !this.Complete;
            }
        }

        public virtual void GetSpawnProperties(ISpawnable spawn, ObjectPropertyList list)
        { }

        public virtual void GetSpawnContextEntries(ISpawnable spawn, Mobile m, List<ContextMenuEntry> list)
        { }

        public static void Remove(GenericReader reader, int version)
        {
            int count = reader.ReadInt();

            for (int i = 0; i < count; i++)
            {
                int serial = reader.ReadInt();
                IEntity entity = World.FindEntity(serial);

                if (entity != null)
                {
                    if (m_RemoveList == null)
                        m_RemoveList = new List<IEntity>();

                    m_RemoveList.Add(entity);
                }
            }

            reader.ReadBool(); // m_Running

            if (reader.ReadBool())
                reader.ReadDeltaTime(); // m_NextSpawn
        }

        public static void Initialize()
        {
            if (m_RemoveList != null)
            {
                foreach (IEntity ent in m_RemoveList)
                {
                    ent.Delete();
                }

                m_RemoveList = null;
            }

            SpawnPersistence.EnsureExistence();

            CommandSystem.Register("RespawnAllRegions", AccessLevel.Administrator, new CommandEventHandler(RespawnAllRegions_OnCommand));
            CommandSystem.Register("RespawnRegion", AccessLevel.GameMaster, new CommandEventHandler(RespawnRegion_OnCommand));
            CommandSystem.Register("DelAllRegionSpawns", AccessLevel.Administrator, new CommandEventHandler(DelAllRegionSpawns_OnCommand));
            CommandSystem.Register("DelRegionSpawns", AccessLevel.GameMaster, new CommandEventHandler(DelRegionSpawns_OnCommand));
            CommandSystem.Register("StartAllRegionSpawns", AccessLevel.Administrator, new CommandEventHandler(StartAllRegionSpawns_OnCommand));
            CommandSystem.Register("StartRegionSpawns", AccessLevel.GameMaster, new CommandEventHandler(StartRegionSpawns_OnCommand));
            CommandSystem.Register("StopAllRegionSpawns", AccessLevel.Administrator, new CommandEventHandler(StopAllRegionSpawns_OnCommand));
            CommandSystem.Register("StopRegionSpawns", AccessLevel.GameMaster, new CommandEventHandler(StopRegionSpawns_OnCommand));
        }

        public Point3D RandomSpawnLocation(int spawnHeight, bool land, bool water)
        {
            return this.m_Region.RandomSpawnLocation(spawnHeight, land, water, this.m_Home, this.m_Range);
        }

        public void Start()
        {
            if (this.m_Running)
                return;

            this.m_Running = true;
            this.CheckTimer();
        }

        public void Stop()
        {
            if (!this.m_Running)
                return;

            this.m_Running = false;
            this.CheckTimer();
        }

        public void DeleteSpawnedObjects()
        {
            this.InternalDeleteSpawnedObjects();

            this.m_Running = false;
            this.CheckTimer();
        }

        public void Respawn()
        {
            this.InternalDeleteSpawnedObjects();

            for (int i = 0; !this.Complete && i < this.m_Max; i++)
                this.Spawn();

            this.m_Running = true;
            this.CheckTimer();
        }

        public void Delete()
        {
            this.m_Max = 0;
            this.InternalDeleteSpawnedObjects();

            if (this.m_SpawnTimer != null)
            {
                this.m_SpawnTimer.Stop();
                this.m_SpawnTimer = null;
            }

            if (m_Table[this.m_ID] == this)
                m_Table.Remove(this.m_ID);
        }

        public void Serialize(GenericWriter writer)
        {
            writer.Write((int)this.m_SpawnedObjects.Count);

            for (int i = 0; i < this.m_SpawnedObjects.Count; i++)
            {
                ISpawnable spawn = this.m_SpawnedObjects[i];

                int serial = spawn.Serial;

                writer.Write((int)serial);
            }

            writer.Write((bool)this.m_Running);

            if (this.m_SpawnTimer != null)
            {
                writer.Write(true);
                writer.WriteDeltaTime((DateTime)this.m_NextSpawn);
            }
            else
            {
                writer.Write(false);
            }
        }

        public void Deserialize(GenericReader reader, int version)
        {
            int count = reader.ReadInt();

            for (int i = 0; i < count; i++)
            {
                int serial = reader.ReadInt();
                ISpawnable spawnableEntity = World.FindEntity(serial) as ISpawnable;

                if (spawnableEntity != null)
                    this.Add(spawnableEntity);
            }

            this.m_Running = reader.ReadBool();

            if (reader.ReadBool())
            {
                this.m_NextSpawn = reader.ReadDeltaTime();

                if (this.Spawning)
                {
                    if (this.m_SpawnTimer != null)
                        this.m_SpawnTimer.Stop();

                    TimeSpan delay = this.m_NextSpawn - DateTime.UtcNow;
                    this.m_SpawnTimer = Timer.DelayCall(delay > TimeSpan.Zero ? delay : TimeSpan.Zero, new TimerCallback(TimerCallback)); 
                }
            }

            this.CheckTimer();
        }

        private static BaseRegion GetCommandData(CommandEventArgs args)
        {
            Mobile from = args.Mobile;

            Region reg;
            if (args.Length == 0)
            {
                reg = from.Region;
            }
            else
            {
                string name = args.GetString(0);
                //reg = (Region) from.Map.Regions[name];

                if (!from.Map.Regions.TryGetValue(name, out reg))
                {
                    from.SendMessage("Could not find region '{0}'.", name);
                    return null;
                }
            }

            BaseRegion br = reg as BaseRegion;

            if (br == null || br.Spawns == null)
            {
                from.SendMessage("There are no spawners in region '{0}'.", reg);
                return null;
            }

            return br;
        }

        [Usage("RespawnAllRegions")]
        [Description("Respawns all regions and sets the spawners as running.")]
        private static void RespawnAllRegions_OnCommand(CommandEventArgs args)
        {
            foreach (SpawnEntry entry in m_Table.Values)
            {
                entry.Respawn();
            }

            args.Mobile.SendMessage("All regions have respawned.");
        }

        [Usage("RespawnRegion [<region name>]")]
        [Description("Respawns the region in which you are (or that you provided) and sets the spawners as running.")]
        private static void RespawnRegion_OnCommand(CommandEventArgs args)
        {
            BaseRegion region = GetCommandData(args);

            if (region == null)
                return;

            for (int i = 0; i < region.Spawns.Length; i++)
                region.Spawns[i].Respawn();

            args.Mobile.SendMessage("Region '{0}' has respawned.", region);
        }

        [Usage("DelAllRegionSpawns")]
        [Description("Deletes all spawned objects of every regions and sets the spawners as not running.")]
        private static void DelAllRegionSpawns_OnCommand(CommandEventArgs args)
        {
            foreach (SpawnEntry entry in m_Table.Values)
            {
                entry.DeleteSpawnedObjects();
            }

            args.Mobile.SendMessage("All region spawned objects have been deleted.");
        }

        [Usage("DelRegionSpawns [<region name>]")]
        [Description("Deletes all spawned objects of the region in which you are (or that you provided) and sets the spawners as not running.")]
        private static void DelRegionSpawns_OnCommand(CommandEventArgs args)
        {
            BaseRegion region = GetCommandData(args);

            if (region == null)
                return;

            for (int i = 0; i < region.Spawns.Length; i++)
                region.Spawns[i].DeleteSpawnedObjects();

            args.Mobile.SendMessage("Spawned objects of region '{0}' have been deleted.", region);
        }

        [Usage("StartAllRegionSpawns")]
        [Description("Sets the region spawners of all regions as running.")]
        private static void StartAllRegionSpawns_OnCommand(CommandEventArgs args)
        {
            foreach (SpawnEntry entry in m_Table.Values)
            {
                entry.Start();
            }

            args.Mobile.SendMessage("All region spawners have started.");
        }

        [Usage("StartRegionSpawns [<region name>]")]
        [Description("Sets the region spawners of the region in which you are (or that you provided) as running.")]
        private static void StartRegionSpawns_OnCommand(CommandEventArgs args)
        {
            BaseRegion region = GetCommandData(args);

            if (region == null)
                return;

            for (int i = 0; i < region.Spawns.Length; i++)
                region.Spawns[i].Start();

            args.Mobile.SendMessage("Spawners of region '{0}' have started.", region);
        }

        [Usage("StopAllRegionSpawns")]
        [Description("Sets the region spawners of all regions as not running.")]
        private static void StopAllRegionSpawns_OnCommand(CommandEventArgs args)
        {
            foreach (SpawnEntry entry in m_Table.Values)
            {
                entry.Stop();
            }

            args.Mobile.SendMessage("All region spawners have stopped.");
        }

        [Usage("StopRegionSpawns [<region name>]")]
        [Description("Sets the region spawners of the region in which you are (or that you provided) as not running.")]
        private static void StopRegionSpawns_OnCommand(CommandEventArgs args)
        {
            BaseRegion region = GetCommandData(args);

            if (region == null)
                return;

            for (int i = 0; i < region.Spawns.Length; i++)
                region.Spawns[i].Stop();

            args.Mobile.SendMessage("Spawners of region '{0}' have stopped.", region);
        }

        private void Spawn()
        {
            ISpawnable spawn = this.m_Definition.Spawn(this);

            if (spawn != null)
                this.Add(spawn);
        }

        private void Add(ISpawnable spawn)
        {
            this.m_SpawnedObjects.Add(spawn);

            spawn.Spawner = this;

            if (spawn is BaseCreature)
                ((BaseCreature)spawn).RemoveIfUntamed = this.RemoveIfUntamed;
        }

        void ISpawner.Remove(ISpawnable spawn)
        {
            this.m_SpawnedObjects.Remove(spawn);

            this.CheckTimer();
        }

        private TimeSpan RandomTime()
        {
            int min = (int)this.m_MinSpawnTime.TotalSeconds;
            int max = (int)this.m_MaxSpawnTime.TotalSeconds;

            int rand = Utility.RandomMinMax(min, max);
            return TimeSpan.FromSeconds(rand);
        }

        private void CheckTimer()
        {
            if (this.Spawning)
            {
                if (this.m_SpawnTimer == null)
                {
                    TimeSpan time = this.RandomTime();
                    this.m_SpawnTimer = Timer.DelayCall(time, new TimerCallback(TimerCallback));
                    this.m_NextSpawn = DateTime.UtcNow + time;
                }
            }
            else if (this.m_SpawnTimer != null)
            {
                this.m_SpawnTimer.Stop();
                this.m_SpawnTimer = null;
            }
        }

        private void TimerCallback()
        {
            int amount = Math.Max((this.m_Max - this.m_SpawnedObjects.Count) / 3, 1);

            for (int i = 0; i < amount; i++)
                this.Spawn();

            this.m_SpawnTimer = null;
            this.CheckTimer();
        }

        private void InternalDeleteSpawnedObjects()
        {
            foreach (ISpawnable spawnable in this.m_SpawnedObjects)
            {
                spawnable.Spawner = null;

                bool uncontrolled = !(spawnable is BaseCreature) || !((BaseCreature)spawnable).Controlled;

                if (uncontrolled)
                    spawnable.Delete();
            }

            this.m_SpawnedObjects.Clear();
        }
    }
}