using System.Net;
using System.Net.Sockets;
using System.Text;

namespace Client;

internal class Program
{
    private const int Porta = 1322;

    private const int TimeoutLetturaMs = 5 * 60 * 1000;

    private static void Main(string[] args)
    {
        Console.WriteLine("Hello, Server!");

        try
        {
            using var client = new TcpClient("127.0.0.1", Porta);

            Encoding utf8SenzaBom = new UTF8Encoding(false);

            client.ReceiveTimeout = TimeoutLetturaMs;
            Console.WriteLine("Client connesso alla porta " + Porta);

            using NetworkStream stream = client.GetStream();
            using StreamReader reader = new StreamReader(stream, utf8SenzaBom);
            using StreamWriter writer = new StreamWriter(stream, utf8SenzaBom);

            writer.AutoFlush = true;

            //var messaggioDalServer = reader.ReadLine();
            string messaggioDalServer = recieveMsg(stream);
            
            if (messaggioDalServer == null)
                Console.WriteLine("Server morto");
            else
            {
                Console.WriteLine("Server: " + messaggioDalServer);

                while (true)
                {
                    Console.Write("$: ");
                    string? msg = Console.ReadLine();

                    if (msg == null) break;
                    
                    //writer.WriteLine(msg);
                    sendMsg(msg, stream);

                    if (msg == "exit") break;

                    //string? msgServer = reader.ReadLine();
                    string? msgServer = recieveMsg(stream);
                    Console.WriteLine(msgServer);
                }
            }

        }
        catch (IOException e)
        {
            SocketException? causa = e.InnerException as SocketException;

            if (causa != null && causa.SocketErrorCode == SocketError.TimedOut)
                Console.WriteLine("Time out");
            else
                Console.WriteLine("Connessione terminata dal server: " + e.Message);

            Console.WriteLine(e.Message);
        }
        catch (Exception e)
        {
            Console.WriteLine("Errore: " + e.Message);
        }
        finally
        {
            Console.WriteLine("Premi un tasto per chiudere");
            Console.ReadKey();
        }
    }

    public static string recieveMsg(NetworkStream stream)
    {
        int dimMax = 1024 * 1024;
        int lungHeadMsg = 4;
        
        if (stream == null) throw new ArgumentNullException(nameof(stream));

        try
        {
            byte[] header = new byte[lungHeadMsg];
            if (!leggiByteDaStream(stream, header, header.Length))
                return "connessione chiusa prima di poter leggere";

            int lunghezza = BitConverter.ToInt32(header, 0);

            if (lunghezza < 0 || lunghezza > dimMax)
                return "Lunghezza non valida";

            byte[] corpo = new byte[lunghezza];
            if (!leggiByteDaStream(stream, corpo, corpo.Length))
                return "connessione chiusa prima di poter leggere";

            return Encoding.UTF8.GetString(corpo);
        }
        catch (Exception)
        {
            return "errore";
        }
    }

    private static bool leggiByteDaStream(NetworkStream stream, byte[] buffer, int length)
    {
        int letti = 0;
        while (letti < length)
        {
            int n = stream.Read(buffer, letti, length - letti);
            if (n == 0)
                return false;
            letti += n;
        }
        return true;
    }
    
    public static string sendMsg(string messaggio, NetworkStream stream)
    {
        int dimMax = 1024 * 1024;
        int lungHeadMsg = 4;

        if (messaggio == null) throw new ArgumentNullException(nameof(messaggio));

        try
        {
            byte[] corpo = Encoding.UTF8.GetBytes(messaggio);
            if (corpo.Length > dimMax)
                return "Messaggio troppo lungo";
            
            byte[] header = BitConverter.GetBytes(corpo.Length);
            
            byte[] pacchetto = new byte[lungHeadMsg + corpo.Length];
            
            Buffer.BlockCopy(header, 0, pacchetto, 0, lungHeadMsg);
            Buffer.BlockCopy(corpo, 0, pacchetto, lungHeadMsg, corpo.Length);
            
            stream.Write(pacchetto, 0, pacchetto.Length);
            return "Messaggio inviato";
        }
        catch (Exception)
        {
            return "Errore nell'invio del messaggio";
        }
    }
}