using System.Text;

namespace EonaCat.JASP
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("EonaCat.JASP.Tester");
            Console.WriteLine("==========================================\n");

            Console.WriteLine("Select example to run:");
            Console.WriteLine("1. TCP Server/Client (No encryption)");
            Console.WriteLine("2. TCP Server/Client with AES Encryption");
            Console.WriteLine("3. TCP Server/Client with Authentication");
            Console.WriteLine("4. UDP Server/Client");
            Console.WriteLine("5. Client-to-Client Messaging");
            Console.WriteLine("6. Performance Test (10,000 messages)");
            Console.Write("\nEnter choice (1-6): ");

            var choice = Console.ReadLine();

            switch (choice)
            {
                case "1":
                    await RunBasicTcpExample();
                    break;
                case "2":
                    await RunTcpWithEncryptionExample();
                    break;
                case "3":
                    await RunTcpWithAuthExample();
                    break;
                case "4":
                    await RunUdpExample();
                    break;
                case "5":
                    await RunClientToClientExample();
                    break;
                case "6":
                    await RunPerformanceTest();
                    break;
                default:
                    Console.WriteLine("Invalid choice");
                    break;
            }

            Console.WriteLine("\nPress any key to exit...");
            Console.ReadKey();
        }

        static async Task RunBasicTcpExample()
        {
            Console.WriteLine("\n=== Basic TCP Example ===\n");

            // Create server
            var server = new NetworkServer(ProtocolType.TCP, 5000);

            server.DataReceived += (s, e) =>
            {
                var message = Encoding.UTF8.GetString(e.Data);
                Console.WriteLine($"[SERVER] Received from {e.FromUsername}: {message}");

                // Echo back
                server.SendToClient(e.FromUsername, $"Echo: {message}");
            };

            server.ClientConnected += (s, e) =>
            {
                Console.WriteLine($"[SERVER] Client connected: {e.Username}");
            };

            server.ClientDisconnected += (s, e) =>
            {
                Console.WriteLine($"[SERVER] Client disconnected: {e.Username}");
            };

            server.ErrorOccurred += (s, e) =>
            {
                Console.WriteLine($"[SERVER ERROR] {e.Message}: {e.Exception?.Message}");
            };

            server.Start();
            Console.WriteLine("[SERVER] Started on port 5000");

            // Wait for server to start
            await Task.Delay(500);

            // Create client
            var client = new NetworkClient(ProtocolType.TCP, "127.0.0.1", 5000);

            client.DataReceived += (s, e) =>
            {
                var message = Encoding.UTF8.GetString(e.Data);
                Console.WriteLine($"[CLIENT] Received: {message}");
            };

            client.Connected += (s, e) =>
            {
                Console.WriteLine("[CLIENT] Connected to server");
            };

            client.ErrorOccurred += (s, e) =>
            {
                Console.WriteLine($"[CLIENT ERROR] {e.Message}: {e.Exception?.Message}");
            };

            await client.ConnectAsync();

            // Send messages
            for (int i = 1; i <= 5; i++)
            {
                client.SendString($"Message {i}");
                await Task.Delay(100);
            }

            await Task.Delay(1000);

            // Show stats
            Console.WriteLine("\n--- Server Stats ---");
            Console.WriteLine(server.GetStats());

            Console.WriteLine("\n--- Client Stats ---");
            Console.WriteLine(client.GetStats());

            // Cleanup
            client.Disconnect();
            server.Stop();
        }

        static async Task RunTcpWithEncryptionExample()
        {
            Console.WriteLine("\n=== TCP with AES Encryption Example ===\n");

            var server = new NetworkServer(ProtocolType.TCP, 5001, useAES: true);

            server.DataReceived += (s, e) =>
            {
                var message = Encoding.UTF8.GetString(e.Data);
                Console.WriteLine($"[SERVER] Received encrypted message: {message}");
            };

            server.ClientConnected += (s, e) =>
            {
                Console.WriteLine($"[SERVER] Client connected with encryption: {e.Username}");
            };

            server.Start();
            Console.WriteLine("[SERVER] Started with AES encryption on port 5001");

            await Task.Delay(500);

            var client = new NetworkClient(ProtocolType.TCP, "127.0.0.1", 5001, useAES: true);

            client.DataReceived += (s, e) =>
            {
                var message = Encoding.UTF8.GetString(e.Data);
                Console.WriteLine($"[CLIENT] Received encrypted message: {message}");
            };

            await client.ConnectAsync();

            client.SendString("This message is encrypted!");
            client.SendString("All communication is secure.");

            await Task.Delay(1000);

            Console.WriteLine("\n--- Server Stats ---");
            Console.WriteLine(server.GetStats());

            client.Disconnect();
            server.Stop();
        }

        static async Task RunTcpWithAuthExample()
        {
            Console.WriteLine("\n=== TCP with Authentication Example ===\n");

            var server = new NetworkServer(
                ProtocolType.TCP,
                5002,
                username: "ServerAdmin",
                password: "SecurePassword123");

            server.DataReceived += (s, e) =>
            {
                var message = Encoding.UTF8.GetString(e.Data);
                Console.WriteLine($"[SERVER] Received from authenticated user {e.FromUsername}: {message}");
            };

            server.ClientConnected += (s, e) =>
            {
                Console.WriteLine($"[SERVER] Authenticated client: {e.Username}");
            };

            server.Start();
            Console.WriteLine("[SERVER] Started with authentication on port 5002");

            await Task.Delay(500);

            // Client with correct credentials
            var client1 = new NetworkClient(
                ProtocolType.TCP,
                "127.0.0.1",
                5002,
                username: "Alice",
                password: "SecurePassword123");

            await client1.ConnectAsync();
            client1.SendString("Hello from authenticated client!");

            await Task.Delay(500);

            // Try client with wrong credentials (will fail to connect)
            try
            {
                var client2 = new NetworkClient(
                    ProtocolType.TCP,
                    "127.0.0.1",
                    5002,
                    username: "Hacker",
                    password: "WrongPassword");

                await client2.ConnectAsync();
                Console.WriteLine("[CLIENT2] Should not see this - auth should fail");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[CLIENT2] Authentication failed (expected): {ex.Message}");
            }

            await Task.Delay(1000);

            client1.Disconnect();
            server.Stop();
        }

        static async Task RunUdpExample()
        {
            Console.WriteLine("\n=== UDP Example ===\n");

            var server = new NetworkServer(ProtocolType.UDP, 5003);

            server.DataReceived += (s, e) =>
            {
                var message = Encoding.UTF8.GetString(e.Data);
                Console.WriteLine($"[SERVER] UDP received: {message}");
            };

            server.Start();
            Console.WriteLine("[SERVER] Started UDP on port 5003");

            await Task.Delay(500);

            var client = new NetworkClient(ProtocolType.UDP, "127.0.0.1", 5003, username: "UDPClient");

            await client.ConnectAsync();

            for (int i = 1; i <= 5; i++)
            {
                client.SendString($"UDP Message {i}");
                await Task.Delay(50);
            }

            await Task.Delay(1000);

            Console.WriteLine("\n--- Server Stats ---");
            Console.WriteLine(server.GetStats());

            client.Disconnect();
            server.Stop();
        }

        static async Task RunClientToClientExample()
        {
            Console.WriteLine("\n=== Client-to-Client Messaging Example ===\n");

            var server = new NetworkServer(ProtocolType.TCP, 5004);

            server.DataReceived += (s, e) =>
            {
                Console.WriteLine($"[SERVER] Routing message from {e.FromUsername} to {e.Message.ToUsername}");
            };

            server.ClientConnected += (s, e) =>
            {
                Console.WriteLine($"[SERVER] Client connected: {e.Username}");
                server.BroadcastString($"User {e.Username} joined", e.Username);
            };

            server.Start();
            Console.WriteLine("[SERVER] Started on port 5004");

            await Task.Delay(500);

            // Create multiple clients
            var alice = new NetworkClient(ProtocolType.TCP, "127.0.0.1", 5004, username: "Alice");
            var bob = new NetworkClient(ProtocolType.TCP, "127.0.0.1", 5004, username: "Bob");
            var charlie = new NetworkClient(ProtocolType.TCP, "127.0.0.1", 5004, username: "Charlie");

            alice.DataReceived += (s, e) =>
            {
                var message = Encoding.UTF8.GetString(e.Data);
                Console.WriteLine($"[ALICE] Received: {message}");
            };

            bob.DataReceived += (s, e) =>
            {
                var message = Encoding.UTF8.GetString(e.Data);
                Console.WriteLine($"[BOB] Received: {message}");
            };

            charlie.DataReceived += (s, e) =>
            {
                var message = Encoding.UTF8.GetString(e.Data);
                Console.WriteLine($"[CHARLIE] Received: {message}");
            };

            await alice.ConnectAsync();
            await Task.Delay(100);
            await bob.ConnectAsync();
            await Task.Delay(100);
            await charlie.ConnectAsync();
            await Task.Delay(500);

            // Alice sends direct message to Bob
            Console.WriteLine("\n[ALICE] Sending direct message to Bob...");
            alice.SendToClient("Bob", "Hi Bob, this is Alice!");

            await Task.Delay(200);

            // Bob sends direct message to Charlie
            Console.WriteLine("\n[BOB] Sending direct message to Charlie...");
            bob.SendToClient("Charlie", "Hey Charlie, it's Bob!");

            await Task.Delay(200);

            // Server broadcasts to all
            Console.WriteLine("\n[SERVER] Broadcasting to all clients...");
            server.BroadcastString("Server announcement: System maintenance in 5 minutes");

            await Task.Delay(1000);

            Console.WriteLine("\n--- Connected Clients ---");
            foreach (var client in server.GetConnectedClients())
            {
                Console.WriteLine($"  - {client.Username} (ID: {client.ClientId})");
            }

            alice.Disconnect();
            bob.Disconnect();
            charlie.Disconnect();
            server.Stop();
        }

        static async Task RunPerformanceTest()
        {
            Console.WriteLine("\n=== Performance Test (10,000 messages) ===\n");

            var server = new NetworkServer(ProtocolType.TCP, 5005);
            int messagesReceived = 0;

            server.DataReceived += (s, e) =>
            {
                Interlocked.Increment(ref messagesReceived);
            };

            server.Start();
            Console.WriteLine("[SERVER] Started on port 5005");

            await Task.Delay(500);

            var client = new NetworkClient(ProtocolType.TCP, "127.0.0.1", 5005);
            await client.ConnectAsync();

            Console.WriteLine("[CLIENT] Connected. Starting performance test...\n");

            var startTime = DateTime.UtcNow;

            // Send 10,000 messages as fast as possible
            var tasks = new Task[10];
            int messagesPerTask = 1000;

            for (int t = 0; t < 10; t++)
            {
                int taskId = t;
                tasks[t] = Task.Run(() =>
                {
                    for (int i = 0; i < messagesPerTask; i++)
                    {
                        client.SendString($"Performance test message {taskId}-{i}");
                    }
                });
            }

            await Task.WhenAll(tasks);

            // Wait for all messages to be received
            while (messagesReceived < 10000)
            {
                await Task.Delay(10);
            }

            var endTime = DateTime.UtcNow;
            var duration = (endTime - startTime).TotalMilliseconds;

            Console.WriteLine($"Performance Test Results:");
            Console.WriteLine($"  Total Messages: 10,000");
            Console.WriteLine($"  Duration: {duration:N2} ms");
            Console.WriteLine($"  Messages/second: {(10000 / (duration / 1000)):N2}");
            Console.WriteLine($"  Average latency: {(duration / 10000):N4} ms per message");

            await Task.Delay(500);

            Console.WriteLine("\n--- Server Stats ---");
            Console.WriteLine(server.GetStats());

            Console.WriteLine("\n--- Client Stats ---");
            Console.WriteLine(client.GetStats());

            client.Disconnect();
            server.Stop();
        }
    }
}