using System.Reflection;

namespace Discord.Gateway
{
    public class Client
    {
        private WebSocket ws;
        private Discord.Client client;
        private Timer heartbeat;

        public Client(Discord.Client client)
        {
            ws = new WebSocket();
            heartbeat = new Timer(async (s) =>
            {
                await ws.Send(new GatewayPayload<int?>(GatewayOp.Heartbeat));
            });
            this.client = client;
        }

        public async Task Connect()
        {
            await ws.Connect("wss://gateway.discord.gg/?v=10&encoding=json");
        }

        public async Task EventLoop()
        {
            while (true)
            {
                string json = await ws.Recieve();
                GatewayBasicPayload? basic = JSON.Deserialize<GatewayBasicPayload>(json);
                Console.WriteLine(basic?.Op);
                switch (basic?.Op)
                {
                    case GatewayOp.Dispatch:
                        Console.WriteLine($"Event: {basic.T}");
                        switch (basic.T)
                        {
                            case "READY":
                                client.Ready?.Invoke(client);
                                break;

                            case "MESSAGE_CREATE":
                                Message? m = JSON.Deserialize<GatewayPayload<Message>>(json)?.D;
                                m!.Client = client;
                                client.MessageCreate?.Invoke(client, m);
                                break;
                        }
                        break;

                    case GatewayOp.Hello:
                        GatewayPayload<Payloads.Hello>? helloPayload = GatewayPayload<Payloads.Hello>.Parse(json);
                        int interval = helloPayload?.D?.HeartbeatInterval ?? Timeout.Infinite;
                        heartbeat.Change(interval, interval);

                        Console.WriteLine($"Heartbeat: {interval}");

                        string name = Assembly.GetExecutingAssembly().GetName().Name!;

                        GatewayPayload<Payloads.Identify> identify = new(GatewayOp.Identify, new Payloads.Identify()
                        {
                            Token = client.Token,
                            Properties = new Payloads.IdentifyConnectionProperties()
                            {
                                Os = Environment.OSVersion.ToString(),
                                Browser = name,
                                Device = name
                            }
                        });

                        Console.WriteLine(identify);

                        await ws.Send(identify);

                        break;
                    case GatewayOp.HeartbeatACK:
                        break;
                }
            }
        }
    }
}