/*------------------------------------------------------
 * 
 *              RidR utility classes
 * 
 * 
 */

using System;
using System.Collections.Generic;
using System.IO;

namespace RidR
{
    /// <summary>
    /// Represents a basic info container for robots.
    /// </summary>
    public struct RobotInfo
    {
        /// <summary>
        /// Gets or sets the robots current orientation.
        /// </summary>
        public Orientation Orientation
        { get; set; }
        /// <summary>
        /// Gets or sets the robots current position.
        /// </summary>
        public Position Position
        { get; set; }
        /// <summary>
        /// Gets or sets the current team role.
        /// </summary>
        public TeamRole TeamRole
        { get; set; }

        /// <summary>
        /// Gets or sets the current team.
        /// </summary>
        public int Team
        { get; set; }

        /// <summary>
        /// Gets the botcode for this robot.
        /// </summary>
        public string BotCode
        {
            get { return "" + Team + (int)TeamRole; }
        }

        /// <summary>
        /// Constructs a new RobotInfo instance.
        /// </summary>
        /// <param name="teamID">The team ID of this bot</param>
        /// <param name="role">The team role of this bot</param>
        /// <param name="p">The position of this bot</param>
        /// <param name="o">The orientation of this bot</param>
        public RobotInfo(int teamID, TeamRole role, Position p, Orientation o)
            : this()
        {
            Team = teamID;
            TeamRole = role;

            Position = p;
            Orientation = o;
        }

        internal RobotInfo(string botCode, Position p, Orientation o)
            : this()
        {
            Orientation = o;
            Position = p;

            Team = int.Parse("" + botCode[0]);
            TeamRole = (TeamRole)int.Parse("" + botCode[1]);
        }
    }

    /// <summary>
    /// Represents a laser (sub)range.
    /// </summary>
    public struct LaserRange
    {
        /// <summary>
        /// The ID of the team firing the laser.
        /// </summary>
        public int TeamId
        { get; set; }
        /// <summary>
        /// Starting position of this range.
        /// </summary>
        public Position StartPoint
        { get; set; }
        /// <summary>
        /// End position of this range.
        /// </summary>
        public Position EndPoint
        { get; set; }
        /// <summary>
        /// Amount of time this laser has been active in milliseconds.
        /// </summary>
        public int ActiveTime
        { get; set; }

        /// <summary>
        /// Converts this LaserRange to a human-readable string
        /// </summary>
        public override string ToString()
        {
            return TeamId + " " +
                   StartPoint.X + " " + EndPoint.X + " " +
                   StartPoint.Y + " " + EndPoint.Y + " " +
                   ActiveTime;
        }
    }

    /// <summary>
    /// Represents a crystal acquire event.
    /// </summary>
    public struct ScoreEvent
    {
        /// <summary>
        /// Position of the Crystal being acquired
        /// </summary>
        public Position Position
        { get; set; }
        /// <summary>
        /// ID of the team acquiring the crystal.
        /// </summary>
        public int TeamId
        { get; set; }

        /// <summary>
        /// Converts this ScoreEvent to a human-readable string
        /// </summary>
        public override string ToString()
        {
            return TeamId + " " + Position.ToString();
        }
    }

    /// <summary>
    /// Represents a laser hit event.
    /// </summary>
    public struct HitEvent
    {
        /// <summary>
        /// The bot code of the robot that got hit.
        /// </summary>
        public int BotCode
        { get; set; }

        /// <summary>
        /// The time at which the bot got hit in milliseconds.
        /// </summary>
        public int HitTime
        { get; set; }

        /// <summary>
        /// Amount of time the bot remains stunned in milliseconds.
        /// </summary>
        public int RemainingStun
        { get; set; }
    }

    /// <summary>
    /// Represents a set of 3 starting positions
    /// </summary>
    public struct StartPositionSet
    {
        /// <summary>
        /// The ID of this starting position
        /// </summary>
        public int PositionID
        { get; set; }
        /// <summary>
        /// The first position of this set
        /// </summary>
        public Position P1
        { get; set; }
        /// <summary>
        /// The second position of this set
        /// </summary>
        public Position P2
        { get; set; }
        /// <summary>
        /// The third position of this set
        /// </summary>
        public Position P3
        { get; set; }
    }


    /// <summary>
    /// Provides some utility methods.
    /// </summary>
    public static class Utility
    {
        /// <summary>
        /// Reads a settings file for a RidR server.
        /// </summary>
        /// <param name="settingsPath">Path to the settings file</param>
        /// <param name="portNumber">The port number</param>
        /// <param name="roundTime">The maximum amount of time in seconds one round may take</param>
        /// <param name="sightRadius">The radius in which bots can see</param>
        /// <param name="chargeTime">The amount of time in milliseconds bots need to charge their laser 10 points</param>
        /// <param name="laserStun">The amount of time in milliseconds a bot is stunned when hit by a laser</param>
        /// <param name="laserPersist">The amount of time in milliseconds a laser persists from the time it is fired</param>
        /// <param name="mapPath">The path to the map file</param>
        /// <param name="gameThreads">The amount of gameThreads</param>
        public static void ReadSettingsFile(string settingsPath,
                                            out int portNumber,
                                            out int roundTime,
                                            out int sightRadius,
                                            out int chargeTime,
                                            out int laserStun,
                                            out int laserPersist,
                                            out string mapPath,
                                            out int gameThreads)
        {
            FileStream settingsFS = new FileStream(settingsPath, FileMode.Open, FileAccess.Read);
            StreamReader settingsReader = new StreamReader(settingsFS);

            portNumber = int.Parse(settingsReader.ReadLine());
            roundTime = int.Parse(settingsReader.ReadLine());
            sightRadius = int.Parse(settingsReader.ReadLine());
            chargeTime = int.Parse(settingsReader.ReadLine());
            laserStun = int.Parse(settingsReader.ReadLine());
            laserPersist = int.Parse(settingsReader.ReadLine());
            mapPath = settingsReader.ReadLine();
            gameThreads = int.Parse(settingsReader.ReadLine());

            settingsReader.Close();
        }

        /// <summary>
        /// Writes a settings file for a RidR server.
        /// </summary>
        /// <param name="settingsPath">Path to the settings file</param>
        /// <param name="portNumber">The port number</param>
        /// <param name="roundTime">The maximum amount of time in seconds one round may take</param>
        /// <param name="sightRadius">The radius in which bots can see</param>
        /// <param name="chargeTime">The amount of time in milliseconds bots need to charge their laser 10 points</param>
        /// <param name="laserStun">The amount of time in milliseconds a bot is stunned when hit by a laser</param>
        /// <param name="laserPersist">The amount of time in milliseconds a laser persists from the time it is fired</param>
        /// <param name="mapPath">The path to the map file</param>
        /// <param name="gameThreads">The amount of gameThreads</param>
        public static void WriteSettingsFile(string settingsPath,
                                             int portNumber,
                                             int roundTime,
                                             int sightRadius,
                                             int chargeTime,
                                             int laserStun,
                                             int laserPersist,
                                             string mapPath,
                                             int gameThreads)
        {
            FileStream settingsFS = new FileStream(settingsPath, FileMode.Create, FileAccess.Write);
            StreamWriter settingsWriter = new StreamWriter(settingsFS);

            settingsWriter.WriteLine(portNumber);
            settingsWriter.WriteLine(roundTime);
            settingsWriter.WriteLine(sightRadius);
            settingsWriter.WriteLine(chargeTime);
            settingsWriter.WriteLine(laserStun);
            settingsWriter.WriteLine(laserPersist);
            settingsWriter.WriteLine(mapPath);
            settingsWriter.WriteLine(gameThreads);

            settingsWriter.Flush();
            settingsWriter.Close();
        }

        /// <summary>
        /// Reads a map file for a RidR game.
        /// </summary>
        /// <param name="mapPath">Path to the map file</param>
        /// <param name="map">The map</param>
        /// <param name="startPositions">List of starting positions on this map</param>
        public static void ReadMapFile(string mapPath,
                                       out TileType[,] map,
                                       out IList<StartPositionSet> startPositions)
        {
            FileStream mapFS = new FileStream(mapPath, FileMode.Open, FileAccess.Read);
            StreamReader mapReader = new StreamReader(mapFS);

            string[] header = mapReader.ReadLine().Split();

            int width = int.Parse(header[0]);
            int height = int.Parse(header[1]);
            int msgCount = int.Parse(header[2]);

            map = new TileType[width, height];
            for (int i = 0; i < msgCount; ++i)
            {
                string[] split = mapReader.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;
            }

            int posCount = int.Parse(mapReader.ReadLine());
            startPositions = new StartPositionSet[posCount];
            for (int i = 0; i < posCount * 3; ++i)
            {
                string[] split;

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

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

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

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

                startPositions[index] = set;
            }

            mapReader.Close();
        }
    }


    /// <summary>
    /// Provides debug functionality.
    /// </summary>
    public static class Debug
    {
        /// <summary>
        /// Writes a line to the console, but only if this assembly is built in debug mode.
        /// </summary>
        /// <param name="line"></param>
        public static void WriteLine(string line)
        {
#if DEBUG
            Console.WriteLine(line);
#endif
        }

        /// <summary>
        /// Asserts the condition, but only if this assembly is built in debug mode.
        /// </summary>
        /// <param name="condition">The condition to check</param>
        public static void Assert(bool condition)
        {
#if DEBUG
            System.Diagnostics.Debug.Assert(condition);
#endif
        }

        /// <summary>
        /// Asserts the condition, but only if this assembly is built in debug mode.
        /// </summary>
        /// <param name="condition">The condition to check</param>
        /// <param name="message">The message to show the user if the assert fails</param>
        public static void Assert(bool condition, string message)
        {
#if DEBUG
            System.Diagnostics.Debug.Assert(condition, message);
#endif
        }
    }
}