using System;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConnectionUtil
{
    /// <summary>
    /// TCP客户端包装类
    /// </summary>
    /// <summary>
    /// TCP客户端包装类
    /// </summary>
    public class TcpClientWrapper : IDisposable
    {
        private System.Net.Sockets.TcpClient _client;
        private NetworkStream _stream;
        private readonly string _host;
        private readonly int _port;
        private bool _isConnected;
        private readonly CancellationTokenSource _cts;
        private Task _heartbeatTask;
        private readonly SemaphoreSlim _sendReceiveLock;

        /// <summary>
        /// 初始化TCP客户端
        /// </summary>
        /// <param name="host">服务器地址</param>
        /// <param name="port">服务器端口</param>
        public TcpClientWrapper(string host = "127.0.0.1", int port = 6543)
        {
            _host = host;
            _port = port;
            _cts = new CancellationTokenSource();
            _sendReceiveLock = new SemaphoreSlim(1, 1);
        }

        /// <summary>
        /// 异步连接到服务器
        /// </summary>
        /// <returns>连接是否成功</returns>
        public async Task<bool> ConnectAsync()
        {
            try
            {
                _client = new System.Net.Sockets.TcpClient();
                await _client.ConnectAsync(_host, _port);
                _stream = _client.GetStream();
                _isConnected = true;

                // 启动心跳任务
                _heartbeatTask = StartHeartbeatAsync(_cts.Token);

                Console.WriteLine($"成功连接到服务器 {_host}:{_port}");
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"连接服务器失败：{ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 同步连接到服务器
        /// </summary>
        /// <returns>连接是否成功</returns>
        public bool Connect()
        {
            try
            {
                _client = new System.Net.Sockets.TcpClient();
                _client.Connect(_host, _port);
                _stream = _client.GetStream();
                _isConnected = true;

                // 启动心跳任务
                _heartbeatTask = StartHeartbeatAsync(_cts.Token);
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"连接服务器失败：{ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 启动心跳检测
        /// </summary>
        private async Task StartHeartbeatAsync(CancellationToken token)
        {
            while (!token.IsCancellationRequested && _isConnected)
            {
                try
                {
                    await Task.Delay(20000, token); // 20秒发送一次心跳
                    if (_isConnected)
                    {
                        await SendMessageAsync("ping");
                    }
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch (Exception)
                {
                    _isConnected = false;
                    break;
                }
            }
        }

        /// <summary>
        /// 发送消息并接收响应
        /// </summary>
        /// <typeparam name="T">响应数据类型</typeparam>
        /// <param name="data">要发送的数据对象</param>
        /// <param name="timeout">超时时间</param>
        /// <returns>服务器响应数据</returns>
        public async Task<string> SendMessageAsync(string message, TimeSpan? timeout = null)
        {
            if (!_isConnected)
            {
                throw new InvalidOperationException("未连接到服务器");
            }

            TimeSpan actualTimeout = timeout ?? TimeSpan.FromSeconds(30);

            if (!await _sendReceiveLock.WaitAsync(actualTimeout))
            {
                throw new TimeoutException("等待发送超时");
            }

            try
            {
                byte[] messageBytes = Encoding.UTF8.GetBytes(message + "\r\n");

                // 发送消息
                await _stream.WriteAsync(messageBytes, 0, messageBytes.Length);

                // 接收响应
                byte[] buffer = new byte[1024];
                StringBuilder response = new StringBuilder();
                int bytesRead;

                CancellationTokenSource cts = new CancellationTokenSource(actualTimeout);

                try
                {
                    // 读取直到遇到换行符
                    while ((bytesRead = await _stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
                    {
                        string received = Encoding.UTF8.GetString(buffer, 0, bytesRead);
                        response.Append(received);

                        if (received.EndsWith("\r\n"))
                        {
                            break;
                        }

                        if (cts.Token.IsCancellationRequested)
                        {
                            throw new TimeoutException("接收响应超时");
                        }
                    }
                }
                finally
                {
                    cts.Dispose();
                }

                string jsonResponse = response.ToString().TrimEnd('\r', '\n');
                Console.WriteLine($"收到服务器响应：{jsonResponse}");

                // 反序列化响应
                return jsonResponse;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"发送消息失败：{ex.Message}");
                _isConnected = false;
                throw;
            }
            finally
            {
                _sendReceiveLock.Release();
            }
        }

        /// <summary>
        /// 同步发送消息并接收响应
        /// </summary>
        /// <typeparam name="T">响应数据类型</typeparam>
        /// <param name="data">要发送的数据对象</param>
        /// <param name="timeout">超时时间</param>
        /// <returns>服务器响应数据</returns>
        public string SendMessage(string message, TimeSpan? timeout = null)
        {
            timeout = timeout ?? TimeSpan.FromSeconds(30);

            try
            {
                // 使用 Task.Run 来执行异步操作，并等待结果
                return Task.Run(() => SendMessageAsync(message, timeout)).Result;
            }
            catch (AggregateException ae)
            {
                // 解包异常
                throw ae.InnerException;
            }
        }

        /// <summary>
        /// 检查是否已连接
        /// </summary>
        public bool IsConnected
        {
            get { return _isConnected; }
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            _cts.Cancel();
            _isConnected = false;
            if (_stream != null)
            {
                _stream.Dispose();
            }
            if (_client != null)
            {
                _client.Dispose();
            }
            _cts.Dispose();
            if (_sendReceiveLock != null)
            {
                _sendReceiveLock.Dispose();
            }
        }

        /// <summary>
        /// 关闭连接
        /// </summary>
        public void Close()
        {
            Dispose();
        }
    }
}