using System;
using System.Collections.Generic;

using RidR.Exceptions;
using RidR.Extensions;

namespace RidR.Protocol
{
    /// <summary>
    /// The type of the message recieved from the client.
    /// </summary>
    public enum ClientMessageType
    {
        /// <summary>
        /// The PLAY command is send by a bot when regestering his team position:
        /// PLAY [TeamName] [TeamRole]
        /// </summary>
        Play,
        /// <summary>
        /// The STARTPOS command is send by a bot when picking a starting location:
        /// STARTPOS [PositionID] [xPos] [yPos] [Orientation]
        /// </summary>
        StartPosition,
        /// <summary>
        /// A MOVE command is send by a bot who wishes to move:
        /// MOVE [Action] [MoveCode]
        /// </summary>
        Move,
        /// <summary>
        /// A SHOOT command is send by a bot firing his laser:
        /// SHOOT [Range] [MoveCode]
        /// </summary>
        Shoot,
        /// <summary>
        /// A SPECTATE command, send by a visualizer:
        /// SPECTATE
        /// </summary>
        Spectate,
        /// <summary>
        /// The command is not a RidR protocol command.
        /// </summary>
        UnknownCommand
    }


    /// <summary>
    /// This class provides static methodes to help you format server messages and interpret client messages.
    /// </summary>
    public static class ServerProtocolHelper
    {
        #region Reading Client Messages

        /// <summary>
        /// Reads the message and determines the command.
        /// </summary>
        /// <param name="message">The message string</param>
        /// <param name="args">The arguments passed with the message</param>
        /// <param name="valid">Returns if the message was formated correctly</param>
        /// <returns>The type of the message</returns>
        public static ClientMessageType GetMessageType(string message,
                                                       out string[] args,
                                                       out bool valid)
        {
            if (!String.IsNullOrWhiteSpace(message))
            {
                string[] split = message.Split();
                args = split.RemoveAt(0);
                switch (split[0])
                {
                    case CommonProtocol.PLAY:
                        valid = args.Length == 2;
                        return ClientMessageType.Play;
                    case CommonProtocol.STARTPOS:
                        valid = args.Length == 4;
                        return ClientMessageType.StartPosition;
                    case CommonProtocol.MOVE:
                        valid = args.Length == 2;
                        return ClientMessageType.Move;
                    case CommonProtocol.SHOOT:
                        valid = args.Length == 2;
                        return ClientMessageType.Shoot;
                    case CommonProtocol.SPECTATE:
                        valid = true;
                        return ClientMessageType.Spectate;
                }

            }

            args = new string[] { message };
            valid = false;
            return ClientMessageType.UnknownCommand;
        }


        /// <summary>
        /// Interprets the arguments of a PLAY command.
        /// </summary>
        /// <param name="args">Argument list for the Play command.</param>
        /// <param name="teamName">The team name</param>
        /// <param name="role">The team role</param>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadPlayCommand(string[] args,
                                           out string teamName,
                                           out TeamRole role)
        {
            try
            {
                teamName = args[0];
                role = (TeamRole)int.Parse(args[1]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        /// <summary>
        /// Interprets the arguments of a STARTPOS command.
        /// </summary>
        /// <param name="args">Argument list for the Start Position command.</param>
        /// <param name="PositionID">The ID of the start position set</param>
        /// <param name="position">The position</param>
        /// <param name="orientation">The desired starting orientation</param>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadStartPosCommand(string[] args,
                                               out int PositionID,
                                               out Position position,
                                               out Orientation orientation)
        {
            try
            {
                PositionID = int.Parse(args[0]);
                int xPos = int.Parse(args[1]);
                int yPos = int.Parse(args[2]);
                position = new Position(xPos, yPos);
                orientation = (Orientation)int.Parse(args[3]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }


        /// <summary>
        /// Interprets the arguments of a MOVE command.
        /// </summary>
        /// <param name="args">Argument list for the Move command.</param>
        /// <param name="move">The desired move</param>
        /// <param name="moveCode">The move code</param>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadMoveCommand(string[] args,
                                           out Move move,
                                           out int moveCode)
        {
            try
            {
                move = (Move)int.Parse(args[0]);
                moveCode = int.Parse(args[1]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        /// <summary>
        /// Interprets the arguments of a SHOOT command
        /// </summary>
        /// <param name="args">Argument list for the Shoot command.</param>
        /// <param name="range">The desired range</param>
        /// <param name="moveCode">The move code</param>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadShootCommand(string[] args,
                                            out int range,
                                            out int moveCode)
        {
            try
            {
                range = int.Parse(args[0]);
                moveCode = int.Parse(args[1]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        #endregion

        #region Format Server Messages

        /// <summary>
        /// Formats an ACK message.
        /// </summary>
        public static string FormatAcknowledgeCommand()
        {
            return CommonProtocol.ACK;
        }

        /// <summary>
        /// Formats a NAK message.
        /// </summary>
        public static string FormatNotAcknowledgedCommand()
        {
            return CommonProtocol.NAK;
        }

        /// <summary>
        /// Formats a TEAM message (for clients).
        /// </summary>
        /// <param name="TeamCount">Number of teams</param>
        /// <param name="TeamNumber">ID of this team</param>
        public static string FormatTeamCommand(int TeamCount, int TeamNumber)
        {
            return CommonProtocol.TEAM + " " + TeamCount + " " + TeamNumber;
        }

        /// <summary>
        /// Formats a TEAM message (for spectators).
        /// </summary>
        /// <param name="TeamName">The name of the team</param>
        /// <param name="TeamNumber">ID of this team</param>
        public static string FormatTeamCommand(string TeamName, int TeamNumber)
        {
            return CommonProtocol.TEAM + " " + TeamName + " " + TeamNumber;
        }

        /// <summary>
        /// Formats an INFO command.
        /// </summary>
        /// <param name="roundTime">Total time of this round in seconds</param>
        /// <param name="sightRadius">The radius in which clients can see</param>
        /// <param name="chargeTime">The amount of time it takes to charge 10 points of energy in milliseconds</param>
        /// <param name="shootTime">The amount of time a laser persists in milliseconds</param>
        /// <param name="stunTime">The amount of time a bot is stunned when hit in milliseconds</param>
        public static string FormatInfoCommand(int roundTime, int sightRadius, int chargeTime, int shootTime, int stunTime)
        {
            return CommonProtocol.INFO + " " + roundTime + " " + sightRadius + " " + chargeTime + " " + shootTime + " " + stunTime;
        }

        /// <summary>
        /// Formats a MAP command, consisting of a list of messages.
        /// </summary>
        /// <param name="map">The current game map</param>
        public static string[] FormatMapCommandList(TileType[,] map)
        {
            List<string> sTiles = new List<string>();

            int width = map.GetLength(0);
            int height = map.GetLength(1);

            for (int x = 0; x < width; ++x)
            {
                for (int y = 0; y < height; ++y)
                {
                    if (map[x, y] != TileType.Floor)
                    {
                        string tileString = map[x, y].toChar() + " " + x + " " + y;
                        sTiles.Add(tileString);
                    }
                }
            }

            int listCount = sTiles.Count;
            string[] commandList = new string[listCount + 1];

            commandList[0] = CommonProtocol.MAP + " " + width + " " + height + " " + listCount;

            for (int i = 0; i < listCount; ++i)
            {
                commandList[i + 1] = sTiles[i];
            }

            return commandList;
        }

        /// <summary>
        /// Formats a STARTPOS command, consisting of a list of messages.
        /// </summary>
        /// <param name="startList">A list of possible start position sets</param>
        public static string[] FormatStartPositionCommandList(IList<StartPositionSet> startList)
        {
            // Met dank aan Matthijs
            int count = startList.Count;
            string[] commandList = new string[count * 3 + 1];

            commandList[0] = CommonProtocol.STARTPOS + " " + count;
            int i = 1;
            foreach (StartPositionSet sps in startList)
            {
                commandList[i++] = sps.PositionID + " " + sps.P1.ToString();
                commandList[i++] = sps.PositionID + " " + sps.P2.ToString();
                commandList[i++] = sps.PositionID + " " + sps.P3.ToString();
            }

            return commandList;
        }

        /// <summary>
        /// Formats a FALSE command.
        /// </summary>
        public static string FormatFalseCommand()
        {
            return CommonProtocol.FALSE;
        }

        /// <summary>
        /// Formats a DISQUALIFIED command (for clients).
        /// </summary>
        public static string FormatDisqualifiedCommand()
        {
            return CommonProtocol.DISQUALIFIED;
        }

        /// <summary>
        /// Formats a DISQUALIFIED command (for spectators).
        /// </summary>
        /// <param name="robotCode">The ID of the robot being disqualified</param>
        public static string FormatDisqualifiedCommand(int robotCode)
        {
            return CommonProtocol.DISQUALIFIED + " " + robotCode;
        }

        /// <summary>
        /// Formats a START command.
        /// </summary>
        /// <param name="moveCode">The first move code for this bot</param>
        public static string FormatStartCommand(int moveCode)
        {
            return CommonProtocol.START + " " + moveCode;
        }

        /// <summary>
        /// Formats a GAMESTATE command.
        /// </summary>
        /// <param name="moveCode">The move code for the bot's next move</param>
        /// <param name="visableRobots">A list of all the robots visable to the current bot, or, if this message is for a spectator, a list of all the bots in the game</param>
        /// <param name="visableLasers">A list of laser ranges which fall within the current bot's sight radius, or, if this message is for a spectator, a list of all the active lasers</param>
        /// <param name="scores">A list of new scores since the last gamestate update</param>
        /// <param name="hits">A list of hits on the current bot, or, if this message is for a spectator, a list of all hits throughout the game</param>
        /// <param name="forSpectator">Wheter this update is meant for a spectator</param>
        public static string[] FormatGameStateCommandList(int moveCode,
                                                          IList<RobotInfo> visableRobots,
                                                          IList<LaserRange> visableLasers,
                                                          IList<ScoreEvent> scores,
                                                          IList<HitEvent> hits,
                                                          bool forSpectator = false)
        {
            int count = visableRobots.Count + visableLasers.Count + scores.Count + hits.Count;

            string[] commandList = new string[count + 1];

            commandList[0] = CommonProtocol.GAMESTATE + " " + count + " " + moveCode;
            int c = 1;
            for (int i = 0; i < visableRobots.Count; ++i)
            {
                commandList[c++] = CommonProtocol.ROBOT + " " + visableRobots[i].BotCode + " " + visableRobots[i].Position.ToString() + " " + (int)visableRobots[i].Orientation;
            }
            for (int i = 0; i < visableLasers.Count; ++i)
            {
                commandList[c++] = CommonProtocol.LASER + " " + visableLasers[i].ToString();
            }
            for (int i = 0; i < scores.Count; ++i)
            {
                commandList[c++] = CommonProtocol.CRYSTAL + " " + scores[i].ToString(); ;
            }
            for (int i = 0; i < hits.Count; ++i)
            {
                if (forSpectator)
                {
                    commandList[c++] = CommonProtocol.HIT + " " + hits[i].BotCode;
                }
                else
                {
                    commandList[c++] = CommonProtocol.HIT + " " + hits[i].RemainingStun;
                }
            }

            return commandList;
        }

        /// <summary>
        /// Formats a WIN command.
        /// </summary>
        /// <param name="winningTeamId">ID of the winning team</param>
        public static string FormatWinCommand(int winningTeamId)
        {
            return CommonProtocol.WIN + " " + winningTeamId;
        }

        /// <summary>
        /// Formats a SCORE command.
        /// </summary>
        /// <param name="scoreTeam1">Final score of team 1</param>
        /// <param name="scoreTeam2">Final score of team 2</param>
        /// <param name="scoreTeam3">Final score of team 3</param>
        /// <param name="scoreTeam4">Final score of team 4</param>
        public static string FormatScoreCommand(int scoreTeam1, int scoreTeam2, int scoreTeam3, int scoreTeam4)
        {
            return CommonProtocol.SCORE + " " + scoreTeam1 + " " + scoreTeam2 + " " + scoreTeam3 + " " + scoreTeam4;
        }

        /// <summary>
        /// Formats a GAMETIME command.
        /// </summary>
        /// <param name="gameTime">Amount of time this round lasted in ms</param>
        public static string FormatGameTimeCommand(int gameTime)
        {
            return CommonProtocol.GAMETIME + " " + gameTime;
        }

        /// <summary>
        /// Formats a FIRSTTOSCORE command.
        /// </summary>
        /// <param name="teamID">ID of the team</param>
        /// <param name="gameTime">Amount of time it took to score in ms</param>
        public static string FormatFirstToScoreCommand(int teamID, int gameTime)
        {
            return CommonProtocol.FIRSTTOSCORE + " " + teamID + " " + gameTime;
        }

        /// <summary>
        /// Formats a ROBOTSTAT command.
        /// </summary>
        /// <param name="robotCode">The robot ID</param>
        /// <param name="msgPerMin">Messges per minute</param>
        /// <param name="distanceTraveled">Distance traveled by this bot</param>
        /// <param name="lasersFired">The amount of lasers fired by this bot</param>
        /// <param name="botsHit">Amount of bots hit by this bot's lasers</param>
        /// <param name="beenHit">Amount of times this bot was hit by a laser</param>
        public static string FormatRobotStatCommand(int robotCode, float msgPerMin, int distanceTraveled, int lasersFired, int botsHit, int beenHit)
        {
            return CommonProtocol.ROBOTSTAT + " " + robotCode + " " + msgPerMin + " " + distanceTraveled + " " + lasersFired + " " + botsHit + " " + beenHit;
        }

        #endregion
    }
}