using System;
using System.Collections.Generic;

using System.IO;
using RidR.Exceptions;
using RidR.Extensions;

namespace RidR.Protocol
{
    /// <summary>
    /// The type of the message recieved from the server.
    /// </summary>
    public enum ServerMessageType
    {
        /// <summary>
        /// The server Acknowledged command:
        /// ACK
        /// </summary>
        Ack,
        /// <summary>
        /// The server Not Acknowledged command:
        /// NAK
        /// </summary>
        Nak,
        /// <summary>
        /// The TEAM command is sent by the server after team registration:
        /// TEAM [TeamCount] [TeamNumber]
        /// </summary>
        Team,
        /// <summary>
        /// The Info command is sent by the server to inform the client of the game rules:
        /// INFO [RoundTime] [SightRadius] [ChargeTime] [ShootTime] [StunTime]
        /// </summary>
        Info,
        /// <summary>
        /// The Map command is sent when the server wants to send the game map to the client:
        /// MAP [Width] [Height] [ElementCount]
        /// </summary>
        Map,
        /// <summary>
        /// The StartPos command is sent to inform the client of all the posible spawn location:
        /// STARTPOS [ElementCount]
        /// </summary>
        StartPos,
        /// <summary>
        /// The False command is sent when the client requested an invalid starting position:
        /// FALSE
        /// </summary>
        False,
        /// <summary>
        /// The Disqualified command is sent when the client has been disqualified by the server:
        /// DISQUALIFIED
        /// </summary>
        Disqualified,
        /// <summary>
        /// The Start command is sent when the game begins:
        /// START [MoveCode]
        /// </summary>
        Start,
        /// <summary>
        /// The GameState command is sent when the server informs the client of the current game state:
        /// GAMESTATE [ElementCount] [MoveCode]
        /// </summary>
        GameState,
        /// <summary>
        /// The Robot command is part of the gamestate command, informing the client of a robot position:
        /// ROBOT [BotCode] [xPos] [yPos] [Orientation]
        /// </summary>
        Robot,
        /// <summary>
        /// The Laser command is part of the gamestate command, informing the client of a laser beam:
        /// LASER [TeamID] [xBegin] [xEnd] [yBegin] [yEnd] [ActiveTime]
        /// </summary>
        Laser,
        /// <summary>
        /// The Crystal command is part of a gamestate command, informing the client of a new score:
        /// Crystal [TeamID] [xCrystal] [yCrystal]
        /// </summary>
        Crystal,
        /// <summary>
        /// The Hit command is part of a gamestate command, informing the client that he has been hit:
        /// HIT [RemainingStun]
        /// </summary>
        Hit,
        /// <summary>
        /// The Win command is sent when a team has won the current game:
        /// WIN [WinningTeamID]
        /// </summary>
        Win,
        /// <summary>
        /// The Score command is sent after the game has ended to inform the client of the final score:
        /// SCORE [ScoreTeam1] [ScoreTeam2] [ScoreTeam3] [ScoreTeam4]
        /// </summary>
        Score,
        /// <summary>
        /// The GameTime command is sent after the game has ended and informs the client of the total game time:
        /// GAMETIME [GameTime]
        /// </summary>
        GameTime,
        /// <summary>
        /// The First to Score command is sent after the game has ended and informs the clients of the first team to score:
        /// FIRSTTOSCORE [TeamID] [GameTime]
        /// </summary>
        FirstToScore,
        /// <summary>
        /// The Robot stat command shows statistics on the bots:
        /// ROBOTSTAT [RobotCode] [MsgPerMin] [DistanceTraveled] [LasersFired] [BotsHit] [BeenHit]
        /// </summary>
        RobotStats,
        /// <summary>
        /// The command is not a RidR protocol command.
        /// </summary>
        Unknown
    }


    /// <summary>
    /// This class provides static methodes to help you format client messages and interpret server messages.
    /// </summary>
    public static class ClientProtocolHelper
    {
        #region Reading Server 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 ServerMessageType 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.ACK:
                        valid = true;
                        return ServerMessageType.Ack;
                    case CommonProtocol.NAK:
                        valid = true;
                        return ServerMessageType.Nak;
                    case CommonProtocol.TEAM:
                        valid = args.Length == 2;
                        return ServerMessageType.Team;
                    case CommonProtocol.INFO:
                        valid = args.Length == 5;
                        return ServerMessageType.Info;
                    case CommonProtocol.MAP:
                        valid = args.Length == 3;
                        return ServerMessageType.Map;
                    case CommonProtocol.STARTPOS:
                        valid = args.Length == 1;
                        return ServerMessageType.StartPos;
                    case CommonProtocol.FALSE:
                        valid = true;
                        return ServerMessageType.False;
                    case CommonProtocol.DISQUALIFIED:
                        valid = true;
                        return ServerMessageType.Disqualified;
                    case CommonProtocol.START:
                        valid = args.Length == 1;
                        return ServerMessageType.Start;
                    case CommonProtocol.GAMESTATE:
                        valid = args.Length == 2;
                        return ServerMessageType.GameState;
                    case CommonProtocol.ROBOT:
                        valid = args.Length == 4;
                        return ServerMessageType.Robot;
                    case CommonProtocol.LASER:
                        valid = args.Length == 6;
                        return ServerMessageType.Laser;
                    case CommonProtocol.CRYSTAL:
                        valid = args.Length == 3;
                        return ServerMessageType.Crystal;
                    case CommonProtocol.HIT:
                        valid = args.Length == 1;
                        return ServerMessageType.Hit;
                    case CommonProtocol.WIN:
                        valid = args.Length == 1;
                        return ServerMessageType.Win;
                    case CommonProtocol.SCORE:
                        valid = args.Length == 4;
                        return ServerMessageType.Score;
                    case CommonProtocol.GAMETIME:
                        valid = args.Length == 1;
                        return ServerMessageType.GameTime;
                    case CommonProtocol.FIRSTTOSCORE:
                        valid = args.Length == 2;
                        return ServerMessageType.FirstToScore;
                    case CommonProtocol.ROBOTSTAT:
                        valid = args.Length == 6;
                        return ServerMessageType.RobotStats;
                }
            }

            args = new string[] { message };
            valid = false;
            return ServerMessageType.Unknown;
        }

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

        /// <summary>
        /// Interprets the arguments of an INFO command.
        /// </summary>
        /// <param name="args">Argument list for the INFO command</param>
        /// <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>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadInfoCommand(string[] args,
                                           out int roundTime,
                                           out int sightRadius,
                                           out int chargeTime,
                                           out int shootTime,
                                           out int stunTime)
        {
            try
            {
                roundTime = int.Parse(args[0]);
                sightRadius = int.Parse(args[1]);
                chargeTime = int.Parse(args[2]);
                shootTime = int.Parse(args[3]);
                stunTime = int.Parse(args[4]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        /// <summary>
        /// Interprets the arguments of a MAP command.
        /// </summary>
        /// <param name="args">Argument list for the MAP command</param>
        /// <param name="inputReader">The input stream from which to read the map</param>
        /// <param name="map">The current game map</param>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadMapCommand(string[] args,
                                          StreamReader inputReader,
                                          out TileType[,] map)
        {
            try
            {
                int width = int.Parse(args[0]);
                int height = int.Parse(args[1]);
                int msgCount = int.Parse(args[2]);

                map = new TileType[width, height];
                for (int i = 0; i < msgCount; ++i)
                {
                    string[] split = inputReader.ReadLine().Split();
                    TileType tile;
                    switch (split[0])
                    {
                        case "R":
                            tile = TileType.Rift;
                            break;
                        case "W":
                            tile = TileType.Wall;
                            break;
                        case "C":
                            tile = TileType.Crystal;
                            break;
                        default:
                            tile = TileType.Floor;
                            break;
                    }
                    int x = int.Parse(split[1]);
                    int y = int.Parse(split[2]);

                    map[x, y] = tile;
                }
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        /// <summary>
        /// Interprets the arguments of a STARTPOS command.
        /// </summary>
        /// <param name="args">Argument list for the STARTPOS command</param>
        /// <param name="inputReader">The input stream from which to read the position list</param>
        /// <param name="startList">A list of possible start position sets</param>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadStartPosCommand(string[] args,
                                               StreamReader inputReader,
                                               out IList<StartPositionSet> startList)
        {
            try
            {
                int count = int.Parse(args[0]);
                startList = new StartPositionSet[count];
                for (int i = 0; i < count * 3; ++i)
                {
                    string[] split;

                    split = inputReader.ReadLine().Split();

                    int index = int.Parse(split[0]) - 1;
                    Position p = new Position(int.Parse(split[1]), int.Parse(split[2]));

                    StartPositionSet set = startList[index];
                    set.PositionID = index + 1;

                    if (set.P1.IsEmpty)
                    { set.P1 = p; }
                    else if (set.P2.IsEmpty)
                    { set.P2 = p; }
                    else
                    { set.P3 = p; }

                    startList[index] = set;
                }

            }
            catch
            {
                throw new ProtocolException();
            }
        }

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

        /// <summary>
        /// Interprets the arguments of a GAMESTATE command.
        /// </summary>
        /// <param name="args">Argument list for the GAMESTATE command</param>
        /// <param name="inputReader">The stream from which to read the game state</param>
        /// <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</param>
        /// <param name="visableLasers">A list of laser ranges which fall within the current bot's sight radius</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</param>
        /// <param name="timeout">remaining timeout in milliseconds this bot has incurred due to laser hits</param>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadGameStateCommand(string[] args,
                                                StreamReader inputReader,
                                                out int moveCode,
                                                out IList<RobotInfo> visableRobots,
                                                out IList<LaserRange> visableLasers,
                                                out IList<ScoreEvent> scores,
                                                out int timeout)
        {
            try
            {
                visableRobots = new List<RobotInfo>();
                visableLasers = new List<LaserRange>();
                scores = new List<ScoreEvent>();
                timeout = 0;

                int count = int.Parse(args[0]);
                moveCode = int.Parse(args[1]);

                for (int i = 0; i < count; ++i)
                {
                    string[] split = inputReader.ReadLine().Split();
                    switch (split[0])
                    {
                        case CommonProtocol.ROBOT:
                            {
                                Position p = new Position(int.Parse(split[2]), int.Parse(split[3]));
                                Orientation o = (Orientation)int.Parse(split[4]);
                                RobotInfo r = new RobotInfo(split[1], p, o);
                                visableRobots.Add(r);
                                break;
                            }
                        case CommonProtocol.LASER:
                            {
                                int id = int.Parse(split[1]);
                                Position s = new Position(int.Parse(split[2]), int.Parse(split[4]));
                                Position e = new Position(int.Parse(split[3]), int.Parse(split[5]));
                                LaserRange l = new LaserRange();
                                l.ActiveTime = int.Parse(split[6]);
                                l.StartPoint = s;
                                l.EndPoint = e;
                                visableLasers.Add(l);
                                break;
                            }
                        case CommonProtocol.CRYSTAL:
                            {
                                ScoreEvent s = new ScoreEvent();
                                s.TeamId = int.Parse(split[1]);
                                Position p = new Position(int.Parse(split[2]), int.Parse(split[3]));
                                s.Position = p;
                                scores.Add(s);
                                break;
                            }
                        case CommonProtocol.HIT:
                            {
                                timeout = Math.Max(timeout, int.Parse(split[1]));
                                break;
                            }
                    }
                }
            }
            catch
            {
                throw new ProtocolException();
            }

        }

        /// <summary>
        /// Interprets the arguments of a WIN command.
        /// </summary>
        /// <param name="args">Argument list for the WIN command</param>
        /// <param name="winningTeamId">ID of the winning team</param>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadWinCommand(string[] args,
                                          out int winningTeamID)
        {
            try
            {
                winningTeamID = int.Parse(args[0]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        /// <summary>
        /// Interprets the arguments of a SCORE command.
        /// </summary>
        /// <param name="args">Argument list for the SCORE command</param>
        /// <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>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadFinalScoreCommand(string[] args,
                                                 out int scoreTeam1,
                                                 out int scoreTeam2,
                                                 out int scoreTeam3,
                                                 out int scoreTeam4)
        {
            try
            {
                scoreTeam1 = int.Parse(args[0]);
                scoreTeam2 = int.Parse(args[1]);
                scoreTeam3 = int.Parse(args[2]);
                scoreTeam4 = int.Parse(args[3]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        /// <summary>
        /// Interprets the arguments of a GAMETIME command.
        /// </summary>
        /// <param name="args">Argument list for the GAMETIME command</param>
        /// <param name="gameTime">Amount of time this round lasted in ms</param>
        public static void ReadGameTimeCommand(string[] args,
                                               out int gameTime)
        {
            try
            {
                gameTime = int.Parse(args[0]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        /// <summary>
        /// Interprets the arguments of a FIRSTTOSCORE command.
        /// </summary>
        /// <param name="args">Argument list for the FIRSTTOSCORE command</param>
        /// <param name="teamID">ID of the team</param>
        /// <param name="gameTime">Amount of time it took to score in ms</param>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadFirstToScoreCommand(string[] args,
                                                   out int teamID,
                                                   out int gameTime)
        {
            try
            {
                teamID = int.Parse(args[0]);
                gameTime = int.Parse(args[1]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        /// <summary>
        /// Interprets the arguments of a ROBOTSTAT command.
        /// </summary>
        /// <param name="args">Argument list for the ROBOTSTAT command</param>
        /// <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>
        /// <exception cref="ProtocolException">Thrown when the args parameter does not conform to the RidR protocol.</exception>
        public static void ReadRobotStatCommand(string[] args,
                                                out int robotCode,
                                                out float msgPerMin,
                                                out int distanceTraveled,
                                                out int lasersFired,
                                                out int botsHit,
                                                out int beenHit)
        {
            try
            {
                robotCode = int.Parse(args[0]);
                msgPerMin = float.Parse(args[1]);
                distanceTraveled = int.Parse(args[2]);
                lasersFired = int.Parse(args[3]);
                botsHit = int.Parse(args[4]);
                beenHit = int.Parse(args[5]);
            }
            catch
            {
                throw new ProtocolException();
            }
        }

        #endregion

        #region Format Client Messages

        /// <summary>
        /// Formats a PLAY command.
        /// </summary>
        /// <param name="teamName">The team name</param>
        /// <param name="role">The team role</param>
        public static string FormatPlayCommand(string TeamName, TeamRole role)
        {
            return CommonProtocol.PLAY + " " + TeamName + " " + (int)role;
        }

        /// <summary>
        /// Formats 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>
        public static string FormatStartPosCommand(int PositionID, Position position, Orientation orientation)
        {
            return CommonProtocol.STARTPOS + " " + PositionID + " " + position.ToString() + " " + (int)orientation;
        }

        /// <summary>
        /// Formats a MOVE command.
        /// </summary>
        /// <param name="move">The desired move</param>
        /// <param name="moveCode">The move code</param>
        public static string FormatMoveCommand(Move move, int moveCode)
        {
            return CommonProtocol.MOVE + " " + (int)move + " " + moveCode;
        }

        /// <summary>
        /// Formats a SHOOT command.
        /// </summary>
        /// <param name="range">The desired range</param>
        /// <param name="moveCode">The move code</param>
        public static string FormatShootCommand(int range, int moveCode)
        {
            return CommonProtocol.SHOOT + " " + range + " " + moveCode;
        }

        #endregion
    }
}