using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;
using TouchSocket.Core;
using TouchSocket.Http;
using TouchSocket.Http.WebSockets;
using TouchSocket.Sockets;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace ForwardingServerUI.Class
{
    public class AsyncWebSocketServer
    {

        public static HttpService service = new HttpService();
        public static async Task WebSocketMain()
        {
            //var service = new HttpService();

            var config = new TouchSocketConfig();
            config.SetListenIPHosts(7792)
                 .ConfigureContainer(a =>
                 {
                     a.AddConsoleLogger();
                 })
                 .ConfigurePlugins(a =>
                 {
                     //添加WebSocket功能
                     a.UseWebSocket(options =>
                     {
                         options.SetVerifyConnection(async (client, context) =>
                         {
                             if (!context.Request.IsUpgrade())
                             {
                                 //如果不包含升级协议的header，就直接返回false。
                                 return false;
                             }

                             // 在此处添加验证逻辑，例如：匹配特定的URL                        
                             if (true) // context.Request.UrlEquals("/ws"))
                             {
                                 var url = context.Request.URL;

                                 return true; // 允许连接
                             }

                             //如果url不匹配，则可以直接拒绝。
                             //await context.Response
                             //.SetStatus(403, "url不正确")
                             //.AnswerAsync();
                             return false;
                         });


                     });
                     

                     a.Add<MyWebSocketReceivePlugin>();
                     a.Add<MyWebSocketClosedPlugin>();
                 });

            //加载配置
            await service.SetupAsync(config);

            //启动服务
            await service.StartAsync();

            Console.WriteLine("WebSocketService:Run");
        }

        public async Task WebSocketSendAsync(string id,string dat) {
            var clients = service.Clients;
            foreach (var client in clients)
            {
                if (client.Protocol == Protocol.WebSocket)//先判断是不是websocket协议
                {
                    if (client.Id == id)//再按指定id发送，或者直接广播发送
                    {
                        var webSocket = client.WebSocket;
                        await webSocket.SendAsync(dat);
                    }
                }
            }
        }


        private class MyWebSocketClosedPlugin : PluginBase, IWebSocketClosedPlugin
        {         
           public async Task OnWebSocketClosed(IWebSocket webSocket, ClosedEventArgs e)
            {
                var ClientId = (webSocket as IIdClient)!.Id;

            }
    }
        private class MyWebSocketReceivePlugin : PluginBase, IWebSocketReceivedPlugin
        {
            public async Task OnWebSocketReceived(IWebSocket webSocket, WSDataFrameEventArgs e)
            {
                //处理接收的数据
                var dataFrame = e.DataFrame;
                switch (dataFrame.Opcode)
                {
                    case WSDataType.Cont:
                        //处理中继包
                        break;

                    case WSDataType.Text:
                        //处理文本包
                        Console.WriteLine(dataFrame.ToText());
                        break;

                    case WSDataType.Binary:
                        //处理二进制包
                        var data = dataFrame.PayloadData;
                        Console.WriteLine($"收到二进制数据，长度：{data.Length}");
                        break;

                    case WSDataType.Close:
                        //处理关闭包
                        break;

                    case WSDataType.Ping:
                        //处理Ping包
                        break;

                    case WSDataType.Pong:
                        //处理Pong包
                        break;

                    default:
                        //处理其他包
                        break;
                }
                await e.InvokeNext();
            }

        }


    }
}