namespace EonaCat.FastBin.Tester
{
    public class User
    {
        public int Id;
        public string Name;
        public string Email;
        public DateTime CreatedAt;
        public List<Order> Orders;
        public User Manager; // Self-referencing for testing
    }

    public class Order
    {
        public Guid OrderId;
        public decimal TotalAmount;
        public List<OrderItem> Items;
        public OrderStatus Status;
    }

    public class OrderItem
    {
        public string ProductName;
        public int Quantity;
        public decimal Price;
    }

    public enum OrderStatus
    {
        Pending,
        Processing,
        Shipped,
        Delivered
    }

    public class GetUserRequest
    {
        public int UserId;
    }

    public class CreateOrderRequest
    {
        public int UserId;
        public List<OrderItem> Items;
    }

    public class CreateOrderResponse
    {
        public Guid OrderId;
        public string Message;
    }

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

            // Test 1: Basic Serialization
            Console.WriteLine("Test 1: Basic Serialization");
            TestBasicSerialization();

            // Test 2: Complex Objects with Nesting
            Console.WriteLine("\nTest 2: Complex Objects with Nesting");
            TestComplexObjects();

            // Test 3: Self-Referencing Objects
            Console.WriteLine("\nTest 3: Self-Referencing Objects");
            TestSelfReferencing();

            // Test 4: Polymorphism
            Console.WriteLine("\nTest 4: Polymorphism");
            TestPolymorphism();

            // Test 5: Client-Server Communication
            Console.WriteLine("\nTest 5: Client-Server Communication");
            await TestClientServer();

            Console.WriteLine("\n=== All EonaCat.FastBin Tests Complete ===");
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }

        static void TestBasicSerialization()
        {
            var data = new Dictionary<string, object>
            {
                ["string"] = "Someone is a brasser",
                ["int"] = 42,
                ["double"] = 3.14159,
                ["bool"] = true,
                ["guid"] = Guid.NewGuid(),
                ["date"] = DateTime.Now
            };

            var bytes = FastBin.Serialize(data);
            var restored = FastBin.Deserialize<Dictionary<string, object>>(bytes);

            Console.WriteLine($"Original count: {data.Count}");
            Console.WriteLine($"Restored count: {restored.Count}");
            Console.WriteLine($"Serialized size: {bytes.Length} bytes");
            Console.WriteLine("Basic serialization works!");
        }

        static void TestComplexObjects()
        {
            var user = new User
            {
                Id = 1,
                Name = "Brian Asser",
                Email = "brasser@example.com",
                CreatedAt = DateTime.Now,
                Orders = new List<Order>
                {
                    new Order
                    {
                        OrderId = Guid.NewGuid(),
                        TotalAmount = 299.99m,
                        Status = OrderStatus.Delivered,
                        Items = new List<OrderItem>
                        {
                            new OrderItem { ProductName = "Laptop", Quantity = 1, Price = 299.99m }
                        }
                    }
                }
            };

            var bytes = FastBin.Serialize(user);
            var restored = FastBin.Deserialize<User>(bytes);

            Console.WriteLine($"User: {restored.Name}");
            Console.WriteLine($"Orders: {restored.Orders.Count}");
            Console.WriteLine($"First order total: ${restored.Orders[0].TotalAmount}");
            Console.WriteLine($"Serialized size: {bytes.Length} bytes");
            Console.WriteLine("Complex objects work!");
        }

        static void TestSelfReferencing()
        {
            var manager = new User
            {
                Id = 1,
                Name = "Manager",
                Email = "manager@example.com",
                CreatedAt = DateTime.Now
            };

            var employee = new User
            {
                Id = 2,
                Name = "Brasser",
                Email = "brasser@example.com",
                CreatedAt = DateTime.Now,
                Manager = manager
            };

            manager.Manager = manager; // Self-reference

            var bytes = FastBin.Serialize(employee);
            var restored = FastBin.Deserialize<User>(bytes);

            Console.WriteLine($"Employee: {restored.Name}");
            Console.WriteLine($"Manager: {restored.Manager.Name}");
            Console.WriteLine($"Manager's manager: {restored.Manager.Manager.Name}");
            Console.WriteLine($"Self-reference intact: {ReferenceEquals(restored.Manager, restored.Manager.Manager)}");
            Console.WriteLine("Self-referencing works!");
        }

        static void TestPolymorphism()
        {
            object[] items = new object[]
            {
                "A string",
                42,
                new User { Id = 1, Name = "ThisGuy", Email = "ThisGuy@test.com", CreatedAt = DateTime.Now },
                new Order { OrderId = Guid.NewGuid(), TotalAmount = 99.99m, Status = OrderStatus.Pending }
            };

            var bytes = FastBin.Serialize(items);
            var restored = FastBin.Deserialize<object[]>(bytes);

            Console.WriteLine($"Item 0: {restored[0]} (type: {restored[0].GetType().Name})");
            Console.WriteLine($"Item 1: {restored[1]} (type: {restored[1].GetType().Name})");
            Console.WriteLine($"Item 2: {((User)restored[2]).Name} (type: {restored[2].GetType().Name})");
            Console.WriteLine($"Item 3: ${((Order)restored[3]).TotalAmount} (type: {restored[3].GetType().Name})");
            Console.WriteLine("Polymorphism works!");
        }

        static async Task TestClientServer()
        {
            var server = new FastServer();

            // Register handlers
            server.RegisterHandler<GetUserRequest, User>("GetUser", request =>
            {
                return new User
                {
                    Id = request.UserId,
                    Name = "Brian Asser",
                    Email = "Brasser@example.com",
                    CreatedAt = DateTime.Now,
                    Orders = new List<Order>()
                };
            });

            server.RegisterHandler<CreateOrderRequest, CreateOrderResponse>("CreateOrder", request =>
            {
                return new CreateOrderResponse
                {
                    OrderId = Guid.NewGuid(),
                    Message = $"Order created for user {request.UserId} with {request.Items.Count} items"
                };
            });

            // Start server in background
            var serverTask = Task.Run(() => server.StartAsync(5000));
            
            // Give server time to start
            await Task.Delay(1000);

            try
            {
                // Create client
                using (var client = new FastClient())
                {
                    await client.ConnectAsync("localhost", 5000);
                    Console.WriteLine("Connected to server");

                    // Test GetUser
                    var user = await client.CallAsync<GetUserRequest, User>(
                        "GetUser",
                        new GetUserRequest { UserId = 123 }
                    );
                    Console.WriteLine($"Retrieved user: {user.Name} ({user.Email})");

                    // Test CreateOrder
                    var orderResponse = await client.CallAsync<CreateOrderRequest, CreateOrderResponse>(
                        "CreateOrder",
                        new CreateOrderRequest
                        {
                            UserId = 123,
                            Items = new List<OrderItem>
                            {
                                new OrderItem { ProductName = "Widget", Quantity = 5, Price = 19.99m }
                            }
                        }
                    );
                    Console.WriteLine($"Created order: {orderResponse.OrderId}");
                    Console.WriteLine($"Message: {orderResponse.Message}");
                }

                Console.WriteLine("Client-Server communication works!");
            }
            finally
            {
                server.Stop();
            }
        }
    }
}