using System.Collections.Generic;

using RidR;
using RidR.Protocol;
using RidR.Extensions;

using System.IO;
using System;

namespace CCP3
{
    /// <summary>
    /// Voorbeeld programma voor CCP3.
    /// Maakt gebruik van RidRProtocol class library
    /// </summary>
    public class Program
    {
        static void Main(string[] args)
        {
            // Debug regels kan je printen met de volgende functie. Ze worden alleen geprint als je compileert in debug mode.
            Debug.WriteLine("Deze regel is alleen zichtbaar wanneer RidRProtocol in debug modus is gecompileerd");

            // Ook kan je je eigen assert checks erin gooien. Deze worden ook alleen geevalueerd in debug mode.
            // Als een Assert faalt, krijgt de gebruiker een melding. Dit kan gebruikt worden om je assumpties te checken in debug builds.
            // Gefaalde assert meldingen zijn gewoon weg te klikken zonder dat de rest van je code er meteen mee ophoud.
            Debug.Assert(1 < 2, "Mogen de goden je bijstaan als dit niet opgaat...");
            Debug.Assert(2 < 1, "Mijn hemel, 2 is groter dan 1!");

            // De utility funcities geven je de mogelijkheid makkelijk een kaart of een settings file in te lezen:
            int poort, rondeTijd, zichtveld, laadTijd, stunTijd, laserTijd, threads;
            string mapPath;
            Utility.ReadSettingsFile("VoorbeeldSettings.ini", out poort, out rondeTijd, out zichtveld, out laadTijd, out stunTijd, out laserTijd, out mapPath, out threads);
            
            TileType[,] map;
            IList<StartPositionSet> startPositions;
            Utility.ReadMapFile(mapPath, out map, out startPositions);

            // Met de ServerProtocolHelper class kunnen RidR protocol berichten gevormd worden.
            // Een MAP commando kan bijvoorbeeld gemaakt worden met behulp van een map.
            string[] mapCommand = ServerProtocolHelper.FormatMapCommandList(map);
            // Hetzelfde idee voor een STARTPOS commando.
            string[] startposCommand = ServerProtocolHelper.FormatStartPositionCommandList(startPositions);

            // Nu ga ik natuurlijk geen netwerk code weggeven, dus we gebruiken deze FileStream om een netwerk voor te stellen:
            FileStream nietEenNetworkMaarWelEenStream = new FileStream("temp", FileMode.Create, FileAccess.ReadWrite);
            StreamWriter writer = new StreamWriter(nietEenNetworkMaarWelEenStream);

            // We schrijven de commandos naar onze stream..
            for (int i = 0; i < mapCommand.Length; ++i)
                writer.WriteLine(mapCommand[i]);
            for (int i = 0; i < startposCommand.Length; ++i)
                writer.WriteLine(startposCommand[i]);

            writer.Flush();


            // ..En nu stellen we ons voor dat we aan de netwerk kant weer de stream lezen.
            // De ClientProtocolHelper class geeft ons functies om de stream te lezen en te interpreteren:
            nietEenNetworkMaarWelEenStream.Seek(0, SeekOrigin.Begin);
            StreamReader reader = new StreamReader(nietEenNetworkMaarWelEenStream);

            string message = reader.ReadLine();
            string[] argList;
            bool valid;
            // Deze functie leest een bericht van uit de stream en vertelt wat het bericht type is en geeft een lijst van argumenten die
            // erbij gestuurd is. Eenzelfde soort functie is natuurlijk ook beschikbaar voor het Server Protocol.
            ServerMessageType type = ClientProtocolHelper.GetMessageType(message, out argList, out valid);

            // Dit zou altijd goed moeten gaan, maar we kunnen het altijd asserten. Als er ergens iets verandert en het gaat ineens mis,
            // zien we het meteen en weten we waar we moeten zoeken.
            Debug.Assert(valid && type == ServerMessageType.Map);

            TileType[,] ontvangenMap;
            // Deze functie leest speciefiek een MAP command aan de hand van de argumenten (opgehaald bij GetMessageType) en een StreamReader
            // (een MAP command bestaat uit meerdere regels, en deze methode leest automatisch het correcte aantal regels uit)
            ClientProtocolHelper.ReadMapCommand(argList, reader, out ontvangenMap);

            // We hebben nu onze map ontvangen, dus laten we er iets mee doen. Printen ofzo is wel aardig.
            for (int x = 0; x < map.GetLength(0); ++x)
            {
                for (int y = 0; y < map.GetLength(1); ++y)
                {
                    // En een assert om te kijken of de ontvangen map gelijk is aan de opgestuurde map. We weten dat het goed zou moeten gaan,
                    // dus dit is gewoon een snelle check om te kijken of onze code nog correct is. Lang verhaal kort: asserts zijn leuk.
                    Debug.Assert(map[x, y] == ontvangenMap[x, y], "(" + x + "," + y + ") heeft niet de verwachte waarde!");
                    Console.Write(ontvangenMap[x, y].toChar());
                }
                Console.WriteLine();
            }

            // Laten we ook het startpos command uitlezen.
            message = reader.ReadLine();
            type = ClientProtocolHelper.GetMessageType(message, out argList, out valid);

            // Dit zou dus een correct STARTPOS command moeten zijn:
            Debug.Assert(valid && type == ServerMessageType.StartPos);

            // Laten we hem dan maar uitlezen
            IList<StartPositionSet> ontvangenSet;

            ClientProtocolHelper.ReadStartPosCommand(argList, reader, out ontvangenSet);

            // Met assert controleren we even of ie klopt:
            for (int i = 0; i < startPositions.Count; ++i)
            {
                Debug.Assert(startPositions[i].PositionID == ontvangenSet[i].PositionID &&
                             startPositions[i].P1 == ontvangenSet[i].P1 &&
                             startPositions[i].P2 == ontvangenSet[i].P2 &&
                             startPositions[i].P3 == ontvangenSet[i].P3);
            }


            nietEenNetworkMaarWelEenStream.Close();

            // En zo werken de belangrijkste classes in RidRProtocol.
            // Gaat nu voort en maakt mooi practica! Succes!
            //  xoxo 
            // Het Concurency Team
            Console.WriteLine();
            Console.WriteLine("klaar!");
            Console.ReadKey();
        }
    }
}