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

namespace Server.Engines.ConPVP
{
	public class ArenaController : Item
	{
		private Arena m_Arena;

		[CommandProperty( AccessLevel.GameMaster )]
		public Arena Arena{ get => m_Arena;
			set{} }

		[CommandProperty( AccessLevel.GameMaster )]
		public bool IsPrivate { get; set; }

		public override string DefaultName => "arena controller";

		[Constructible]
		public ArenaController() : base( 0x1B7A )
		{
			Visible = false;
			Movable = false;

			m_Arena = new Arena();

			Instances.Add( this );
		}

		public override void OnDelete()
		{
			base.OnDelete();

			Instances.Remove( this );
			m_Arena.Delete();
		}

		public override void OnDoubleClick( Mobile from )
		{
			if ( from.AccessLevel >= AccessLevel.GameMaster )
				from.SendGump( new Gumps.PropertiesGump( from, m_Arena ) );
		}

		public ArenaController( Serial serial ) : base( serial )
		{
		}

		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int) 1 );

			writer.Write( (bool) IsPrivate );

			m_Arena.Serialize( writer );
		}

		public override void Deserialize( GenericReader reader )
		{
			base.Deserialize( reader );

			int version = reader.ReadInt();

			switch ( version )
			{
				case 1:
				{
					IsPrivate = reader.ReadBool();

					goto case 0;
				}
				case 0:
				{
					m_Arena = new Arena( reader );
					break;
				}
			}

			Instances.Add( this );
		}

		public static List<ArenaController> Instances { get; set; } = new List<ArenaController>();
	}

	[PropertyObject]
	public class ArenaStartPoints
	{
		public Point3D[] Points { get; }

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D EdgeWest{ get => Points[0];
			set => Points[0] = value;
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D EdgeEast{ get => Points[1];
			set => Points[1] = value;
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D EdgeNorth{ get => Points[2];
			set => Points[2] = value;
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D EdgeSouth{ get => Points[3];
			set => Points[3] = value;
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D CornerNW{ get => Points[4];
			set => Points[4] = value;
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D CornerSE{ get => Points[5];
			set => Points[5] = value;
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D CornerSW{ get => Points[6];
			set => Points[6] = value;
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D CornerNE{ get => Points[7];
			set => Points[7] = value;
		}

		public override string ToString()
		{
			return "...";
		}

		public ArenaStartPoints() : this( new Point3D[8] )
		{
		}

		public ArenaStartPoints( Point3D[] points )
		{
			Points = points;
		}

		public ArenaStartPoints( GenericReader reader )
		{
			Points = new Point3D[reader.ReadEncodedInt()];

			for ( int i = 0; i < Points.Length; ++i )
				Points[i] = reader.ReadPoint3D();
		}

		public void Serialize( GenericWriter writer )
		{
			writer.WriteEncodedInt( (int) Points.Length );

			for ( int i = 0; i < Points.Length; ++i )
				writer.Write( (Point3D) Points[i] );
		}
	}

	[PropertyObject]
	public class Arena : IComparable
	{
		private Map m_Facet;
		private Rectangle2D m_Bounds;
		private Rectangle2D m_Zone;
		private Point3D m_GateOut;
		private ArenaStartPoints m_Points;
		private bool m_Active;
		private string m_Name;

		private bool m_IsGuarded;

		private TournamentController m_Tournament;

		[CommandProperty( AccessLevel.GameMaster )]
		public LadderController Ladder { get; set; }

		[CommandProperty( AccessLevel.GameMaster )]
		public bool IsGuarded
		{
			get => m_IsGuarded;
			set
			{
				m_IsGuarded = value;

				if ( m_Region != null )
					m_Region.Disabled = !m_IsGuarded;
			}
		}

		public Ladder AcquireLadder()
		{
			if ( Ladder != null )
				return Ladder.Ladder;

			return Server.Engines.ConPVP.Ladder.Instance;
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public TournamentController Tournament
		{
			get => m_Tournament;
			set
			{
				m_Tournament?.Tournament.Arenas.Remove( this );

				m_Tournament = value;

				m_Tournament?.Tournament.Arenas.Add( this );
			}
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Mobile Announcer { get; set; }

		[CommandProperty( AccessLevel.GameMaster )]
		public string Name
		{
			get => m_Name;
			set{ m_Name = value; if ( m_Active ) Arenas.Sort(); }
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Map Facet
		{
			get => m_Facet;
			set
			{
				m_Facet = value;

				if ( Teleporter != null )
					Teleporter.Map = value;

				m_Region?.Unregister();

				if ( m_Zone.Start != Point2D.Zero && m_Zone.End != Point2D.Zero && m_Facet != null )
					m_Region = new SafeZone( m_Zone, Outside, m_Facet, m_IsGuarded );
				else
					m_Region = null;
			}
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Rectangle2D Bounds{ get => m_Bounds;
			set => m_Bounds = value;
		}

		private SafeZone m_Region;

		public int Spectators
		{
			get
			{
				if ( m_Region == null )
					return 0;

				int specs = m_Region.GetPlayerCount() - Players.Count;

				if ( specs < 0 )
					specs = 0;

				return specs;
			}
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Rectangle2D Zone
		{
			get => m_Zone;
			set
			{
				m_Zone = value;

				if ( m_Zone.Start != Point2D.Zero && m_Zone.End != Point2D.Zero && m_Facet != null )
				{
					m_Region?.Unregister();

					m_Region = new SafeZone( m_Zone, Outside, m_Facet, m_IsGuarded );
				}
				else
				{
					m_Region?.Unregister();

					m_Region = null;
				}
			}
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D Outside { get; set; }

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D GateIn { get; set; }

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D GateOut{ get => m_GateOut;
			set{ m_GateOut = value; if ( Teleporter != null ) Teleporter.Location = m_GateOut; } }

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D Wall { get; set; }

		[CommandProperty( AccessLevel.GameMaster )]
		public bool IsOccupied => ( Players.Count > 0 );

		[CommandProperty( AccessLevel.GameMaster )]
		public ArenaStartPoints Points{ get => m_Points;
			set{} }

		public Item Teleporter { get; set; }

		public List<Mobile> Players { get; }

		[CommandProperty( AccessLevel.GameMaster )]
		public bool Active
		{
			get => m_Active;
			set
			{
				if ( m_Active == value )
					return;

				m_Active = value;

				if ( m_Active )
				{
					Arenas.Add( this );
					Arenas.Sort();
				}
				else
				{
					Arenas.Remove( this );
				}
			}
		}

		public void Delete()
		{
			 Active = false;

			m_Region?.Unregister();

			m_Region = null;
		}

		public override string ToString()
		{
			return "...";
		}

		public Point3D GetBaseStartPoint( int index )
		{
			if ( index < 0 )
				index = 0;

			return m_Points.Points[index % m_Points.Points.Length];
		}

		#region Offsets & Rotation
		private static Point2D[] m_EdgeOffsets = {
				/*
				 *        /\
				 *       /\/\
				 *      /\/\/\
				 *      \/\/\/
				 *       \/\/\
				 *        \/\/
				 */
				new Point2D( 0, 0 ),
				new Point2D( 0, -1 ),
				new Point2D( 0, +1 ),
				new Point2D( 1, 0 ),
				new Point2D( 1, -1 ),
				new Point2D( 1, +1 ),
				new Point2D( 2, 0 ),
				new Point2D( 2, -1 ),
				new Point2D( 2, +1 ),
				new Point2D( 3, 0 )
			};

		// nw corner
		private static Point2D[] m_CornerOffsets = {
				/*
				 *         /\
				 *        /\/\
				 *       /\/\/\
				 *      /\/\/\/\
				 *      \/\/\/\/
				 */
				new Point2D( 0, 0 ),
				new Point2D( 0, 1 ),
				new Point2D( 1, 0 ),
				new Point2D( 1, 1 ),
				new Point2D( 0, 2 ),
				new Point2D( 2, 0 ),
				new Point2D( 2, 1 ),
				new Point2D( 1, 2 ),
				new Point2D( 0, 3 ),
				new Point2D( 3, 0 )
			};

		private static int[][,] m_Rotate = {
				new[,]{ { +1, 0 }, { 0, +1 } }, // west
				new[,]{ { -1, 0 }, { 0, -1 } }, // east
				new[,]{ { 0, +1 }, { +1, 0 } }, // north
				new[,]{ { 0, -1 }, { -1, 0 } }, // south
				new[,]{ { +1, 0 }, { 0, +1 } }, // nw
				new[,]{ { -1, 0 }, { 0, -1 } }, // se
				new[,]{ { 0, +1 }, { +1, 0 } }, // sw
				new[,]{ { 0, -1 }, { -1, 0 } }, // ne
			};
		#endregion

		public void MoveInside( DuelPlayer[] players, int index )
		{
			if ( index < 0 )
				index = 0;
			else
				index %= m_Points.Points.Length;

			Point3D start = GetBaseStartPoint( index );

			int offset = 0;

			Point2D[] offsets = ( index < 4 ) ? m_EdgeOffsets : m_CornerOffsets;
			int[,] matrix = m_Rotate[index];

			for ( int i = 0; i < players.Length; ++i )
			{
				DuelPlayer pl = players[i];

				if ( pl == null )
					continue;

				Mobile mob = pl.Mobile;

				Point2D p;

				if ( offset < offsets.Length )
					p = offsets[offset++];
				else
					p = offsets[offsets.Length - 1];

				p.X = (p.X * matrix[0, 0]) + (p.Y * matrix[0, 1]);
				p.Y = (p.X * matrix[1, 0]) + (p.Y * matrix[1, 1]);

				mob.MoveToWorld( new Point3D( start.X + p.X, start.Y + p.Y, start.Z ), m_Facet );
				mob.Direction = mob.GetDirectionTo( Wall );

				Players.Add( mob );
			}
		}

		public Arena()
		{
			m_Points = new ArenaStartPoints();
			Players = new List<Mobile>();
		}

		public Arena( GenericReader reader )
		{
			int version = reader.ReadEncodedInt();

			switch ( version )
			{
				case 7:
				{
					m_IsGuarded = reader.ReadBool();

					goto case 6;
				}
				case 6:
				{
					Ladder = reader.ReadItem() as LadderController;

					goto case 5;
				}
				case 5:
				{
					m_Tournament = reader.ReadItem() as TournamentController;
					Announcer = reader.ReadMobile();

					goto case 4;
				}
				case 4:
				{
					m_Name = reader.ReadString();

					goto case 3;
				}
				case 3:
				{
					m_Zone = reader.ReadRect2D();

					goto case 2;
				}
				case 2:
				{
					GateIn = reader.ReadPoint3D();
					m_GateOut = reader.ReadPoint3D();
					Teleporter = reader.ReadItem();

					goto case 1;
				}
				case 1:
				{
					Players = reader.ReadStrongMobileList();

					goto case 0;
				}
				case 0:
				{
					m_Facet = reader.ReadMap();
					m_Bounds = reader.ReadRect2D();
					Outside = reader.ReadPoint3D();
					Wall = reader.ReadPoint3D();

					if ( version == 0 )
					{
						reader.ReadBool();
						Players = new List<Mobile>();
					}

					m_Active = reader.ReadBool();
					m_Points = new ArenaStartPoints( reader );

					if ( m_Active )
					{
						Arenas.Add( this );
						Arenas.Sort();
					}

					break;
				}
			}

			if ( m_Zone.Start != Point2D.Zero && m_Zone.End != Point2D.Zero && m_Facet != null )
				m_Region = new SafeZone( m_Zone, Outside, m_Facet, m_IsGuarded );

			if ( IsOccupied )
				Timer.DelayCall( TimeSpan.FromSeconds( 2.0 ), Evict );

			if ( m_Tournament != null )
				Timer.DelayCall( TimeSpan.Zero, AttachToTournament_Sandbox );
		}

		private void AttachToTournament_Sandbox()
		{
			m_Tournament?.Tournament.Arenas.Add( this );
		}

		[CommandProperty( AccessLevel.Administrator, AccessLevel.Administrator )]
		public bool ForceEvict{ get => false;
			set{ if ( value ) Evict(); } }

		public void Evict()
		{
			Point3D loc;
			Map facet;

			if ( m_Facet == null )
			{
				loc = new Point3D( 2715, 2165, 0 );
				facet = Map.Felucca;
			}
			else
			{
				loc = Outside;
				facet = m_Facet;
			}

			bool hasBounds = ( m_Bounds.Start != Point2D.Zero && m_Bounds.End != Point2D.Zero );

			for ( int i = 0; i < Players.Count; ++i )
			{
				Mobile mob = Players[i];

				if ( mob == null )
					continue;

				if ( mob.Map == Map.Internal )
				{
					if ( (m_Facet == null || mob.LogoutMap == m_Facet) && (!hasBounds || m_Bounds.Contains( mob.LogoutLocation )) )
						mob.LogoutLocation = loc;
				}
				else if ( (m_Facet == null || mob.Map == m_Facet) && (!hasBounds || m_Bounds.Contains( mob.Location )) )
				{
					mob.MoveToWorld( loc, facet );
				}

				mob.Combatant = null;
				mob.Frozen = false;
				DuelContext.Debuff( mob );
				DuelContext.CancelSpell( mob );
			}

			if ( hasBounds ) {
				List<Mobile> pets = new List<Mobile>();

				foreach ( Mobile mob in facet.GetMobilesInBounds( m_Bounds ) ) {
					if ( mob is BaseCreature pet && pet.Controlled && pet.ControlMaster != null && Players.Contains( pet.ControlMaster ) ) {
						pets.Add( pet );
					}
				}

				foreach ( Mobile pet in pets ) {
					pet.Combatant = null;
					pet.Frozen = false;

					pet.MoveToWorld( loc, facet );
				}
			}

			Players.Clear();
		}

		public void Serialize( GenericWriter writer )
		{
			writer.WriteEncodedInt( (int) 7 );

			writer.Write( (bool) m_IsGuarded );

			writer.Write( (Item) Ladder );

			writer.Write( (Item) m_Tournament );
			writer.Write( (Mobile) Announcer );

			writer.Write( (string) m_Name );

			writer.Write( (Rectangle2D) m_Zone );

			writer.Write( (Point3D) GateIn );
			writer.Write( (Point3D) m_GateOut );
			writer.Write( (Item) Teleporter );

			writer.Write( Players );

			writer.Write( (Map) m_Facet );
			writer.Write( (Rectangle2D) m_Bounds );
			writer.Write( (Point3D) Outside );
			writer.Write( (Point3D) Wall );
			writer.Write( (bool) m_Active );

			m_Points.Serialize( writer );
		}

		public static List<Arena> Arenas { get; } = new List<Arena>();

		public static Arena FindArena( List<Mobile> players )
		{
			Preferences prefs = Preferences.Instance;

			if ( prefs == null )
				return FindArena();

			if ( Arenas.Count == 0 )
				return null;

			if ( players.Count > 0 )
			{
				Mobile first = players[0];

				List<ArenaController> allControllers = ArenaController.Instances;

				for ( int i = 0; i < allControllers.Count; ++i )
				{
					ArenaController controller = allControllers[i];

					if ( controller != null && !controller.Deleted && controller.Arena != null && controller.IsPrivate && controller.Map == first.Map && first.InRange( controller, 24 ) )
					{
						Multis.BaseHouse house = Multis.BaseHouse.FindHouseAt( controller );
						bool allNear = true;

						for ( int j = 0; j < players.Count; ++j )
						{
							Mobile check = players[j];
							bool isNear;

							if ( house == null )
								isNear = ( controller.Map == check.Map && check.InRange( controller, 24 ) );
							else
								isNear = ( Multis.BaseHouse.FindHouseAt( check ) == house );

							if ( !isNear )
							{
								allNear = false;
								break;
							}
						}

						if ( allNear )
							return controller.Arena;
					}
				}
			}

			List<ArenaEntry> arenas = new List<ArenaEntry>();

			for ( int i = 0; i < Arenas.Count; ++i )
			{
				Arena arena = Arenas[i];

				if ( !arena.IsOccupied )
					arenas.Add( new ArenaEntry( arena ) );
			}

			if ( arenas.Count == 0 )
				return Arenas[0];

			int tc = 0;

			for ( int i = 0; i < arenas.Count; ++i )
			{
				ArenaEntry ae = arenas[i];

				for ( int j = 0; j < players.Count; ++j )
				{
					PreferencesEntry pe = prefs.Find( players[j] );

					if ( pe.Disliked.Contains( ae.m_Arena.Name ) )
						++ae.m_VotesAgainst;
					else
						++ae.m_VotesFor;
				}

				tc += ae.Value;
			}

			int rn = Utility.Random( tc );

			for ( int i = 0; i < arenas.Count; ++i )
			{
				ArenaEntry ae = arenas[i];

				if ( rn < ae.Value )
					return ae.m_Arena;

				rn -= ae.Value;
			}

			return arenas[Utility.Random( arenas.Count )].m_Arena;
		}

		private class ArenaEntry
		{
			public Arena m_Arena;
			public int m_VotesFor;
			public int m_VotesAgainst;

			public int Value => m_VotesFor;

			public ArenaEntry( Arena arena )
			{
				m_Arena = arena;
			}
		}

		public static Arena FindArena()
		{
			if ( Arenas.Count == 0 )
				return null;

			int offset = Utility.Random( Arenas.Count );

			for ( int i = 0; i < Arenas.Count; ++i )
			{
				Arena arena = Arenas[(i + offset) % Arenas.Count];

				if ( !arena.IsOccupied )
					return arena;
			}

			return Arenas[offset];
		}

		public int CompareTo(object obj)
		{
			Arena c = (Arena)obj;

			string a = m_Name;
			string b = c.m_Name;

			if ( a == null && b == null )
				return 0;
			if ( a == null )
				return -1;
			if ( b == null )
				return +1;

			return a.CompareTo( b );
		}
	}
}