using System;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Text;

namespace Server
{
    class Program
    {
        const int STD_PORT = 1234;
        const string STD_IP = "127.0.0.1";
        const int STD_MSG_SIZE = 1024;
        const int STD_HEAD_LEN = 1;
        const string STD_CRYPTOKEY = "mojKluc";

        static bool run = true;
        static string Recive(NetworkStream networkStream)
        {
            try
            {
                byte[] reciveMessage = new byte[STD_MSG_SIZE];
                int lenght = networkStream.Read(reciveMessage, 0, reciveMessage.Length);
                return Encoding.UTF8.GetString(reciveMessage, 0, lenght);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message + e.StackTrace);
                return "";
            }
        }

        static void Send(NetworkStream networkStream, string Message)
        {
            try
            {
                byte[] bytes = Encoding.UTF8.GetBytes(Message);
                networkStream.Write(bytes, 0, bytes.Length);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }

        }

        static string Encrypt(string source, string key)
        {
            try
            {
                using (var hashMD5Provider = new MD5CryptoServiceProvider())
                {
                    using var tripleDes = TripleDES.Create();
                    tripleDes.Mode = CipherMode.ECB;
                    tripleDes.Padding = PaddingMode.PKCS7;
                    tripleDes.Key = hashMD5Provider.ComputeHash(Encoding.UTF8.GetBytes(key));
                    byte[] data = Encoding.Unicode.GetBytes(source);
                    return Convert.ToBase64String(tripleDes.CreateEncryptor().TransformFinalBlock(data, 0, data.Length));
                }


                /*
                using (var tripleDESCryptoService = new TripleDESCryptoServiceProvider())
                {
                    using (var hashMD5Provider = new MD5CryptoServiceProvider())
                    {
                        byte[] byteHash = hashMD5Provider.ComputeHash(Encoding.UTF8.GetBytes(key));
                        tripleDESCryptoService.Key = byteHash;
                        tripleDESCryptoService.Mode = CipherMode.ECB;
                        byte[] data = Encoding.Unicode.GetBytes(source);
                        var encryptor = tripleDESCryptoService.CreateEncryptor();
                        return Convert.ToBase64String(encryptor.TransformFinalBlock(data, 0, data.Length));
                    }
                }
                */
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return "";
            }
        }

        static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (plainText == null || plainText.Length <= 0)
                throw new ArgumentNullException("plainText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");
            byte[] encrypted;

            


            // Create an Rijndael object
            // with the specified key and IV.
            using (Rijndael rijAlg = Rijndael.Create())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;

                // Create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {

                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                        encrypted = msEncrypt.ToArray();
                    }
                }
            }

            // Return the encrypted bytes from the memory stream.
            return encrypted;
        }

        static string FEN(string code)
        {
            try
            {
                // rnbqkbnr/pppppppp/2p2p2/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
                string ret = "";
                string[] strings = code.Split(' ');

                string[] board = strings[0].Split('/');

                foreach (var line in board)
                {
                    foreach (var sq in line)
                    {
                        if (Char.IsNumber(sq)){
                            int spaces = sq - '0';
                            for (int j = 0; j < spaces; j++) ret += " ";
                        }
                        else
                        {
                            ret += sq;
                        }
                    }
                    ret += "\n";
                }

                ret += "\nNa vrsti je: " + (strings[1] == "w" ? "beli" : "crni") + "\n\n";

                ret += "Moznosti rokade: \n";
                foreach(var m in strings[2])
                {
                    switch (m)
                    {
                        case 'K':
                            ret += "beli, kraljeva stran\n";
                            break;
                        case 'Q':
                            ret += "beli, kraljiceva stran\n";
                            break;
                        case 'k':
                            ret += "crni, kraljeva stran\n";
                            break;
                        case 'q':
                            ret += "crni, kraljiceva stran\n";
                            break;
                        case '-':
                            ret += "Ni moznosti\n";
                            break;
                    }
                }

                ret += "\nMoznosti en pasant: " + (strings[3] == "-" ? "ni moznosti" : strings[3]) + "\n";

                ret += "stevilo polpotez: " + strings[4] + "\n";
                ret += "stevilo poltez: " + strings[5] + "\n";

                return ret;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return "";
            }
        }

        static void Main(string[] args)
        {
            Console.WriteLine("Server\n");
            TcpListener listener = new TcpListener(IPAddress.Parse(STD_IP), STD_PORT);
            listener.Start();

            while (run)
            {
                TcpClient client = listener.AcceptTcpClient();
                NetworkStream networkStream = client.GetStream();

                Console.WriteLine("Odjemalec: " + client.Client.RemoteEndPoint.ToString());

                string message = Recive(networkStream);
                Console.WriteLine("Prejel: " + message);
                char head = message[0];
                string body = "";

                if (message.Length > 1)
                {
                    body = message[1..];
                }
                    
                string response = "";

                switch (head)
                {
                    case 'A':
                        response = "Pozdravljen " + client.Client.RemoteEndPoint.ToString();
                        break;

                    case 'B':
                        response = DateTime.Now.ToString("dd/MM/yyyy HH:mm");
                        break;

                    case 'C':
                        response = Environment.CurrentDirectory;
                        break;

                    case 'D':
                        response = body;
                        break;

                    case 'E':
                        response = Environment.MachineName + " " + Environment.OSVersion.ToString();
                        break;

                    case 'F':
                        response = FEN(body);
                        break;

                    case 'G':
                        response = Encrypt(body, STD_CRYPTOKEY);
                        break;

                    case 'Q':
                        response = "Q";
                        run = false;
                        break;
                }

                if(response == "") response = "No Response";
                

                Console.WriteLine("Odgovor:\n" + response + "\n");
                Send(networkStream, response);

            }

            listener.Stop();
        }
    }
}