using SmartScanner.ViewModel;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SmartScanner
{
    public class TcpServerManager : IDisposable
    {
        private TcpListener _listener;
        public static bool _isRunning;
        private CancellationTokenSource _cts;
        private Func<Task<int[]>> _imageProcessingHandler; // 图像处理委托
        private int _outputIOCount; // 输出IO数量
        // 心跳配置
        public bool EnableHeartbeat { get; private set; }
        public string HeartbeatCommand { get; private set; }
        public int HeartbeatInterval { get; private set; }

        // 客户端列表管理（如果需要跟踪多个客户端）
        // private ConcurrentDictionary<string, TcpClient> _connectedClients = new ConcurrentDictionary<string, TcpClient>();

        public event Action<string> LogMessage;
        public event Action<string, string> CommandReceived;
        public event Action<string> ClientConnected;
        public event Action<string> ClientDisconnected;

        public TcpServerManager(bool enableHeartbeat, string heartbeatCommand, int heartbeatInterval,
                               Func<Task<int[]>> imageProcessingHandler, int outputIOCount)
        {
            EnableHeartbeat = enableHeartbeat;
            HeartbeatCommand = heartbeatCommand ?? "heartBeat";
            HeartbeatInterval = heartbeatInterval > 0 ? heartbeatInterval : 1000;
            _imageProcessingHandler = imageProcessingHandler ?? throw new ArgumentNullException(nameof(imageProcessingHandler));
            _outputIOCount = outputIOCount > 0 ? outputIOCount : 1;
        }
        /// <summary>
        /// TCP服务器开始侦听
        /// </summary>
        /// <param name="ip">服务器IP地址</param>
        /// <param name="port">服务器端口</param>
        public async Task StartAsync(string ip, int port)
        {
            if (port == -1) return;
            _cts = new CancellationTokenSource();
            _isRunning = true;
            _listener = new TcpListener(IPAddress.Parse(ip), port);
            _listener.Start();

            LogMessage?.Invoke($"TCP服务器已启动，开始侦听 {ip}:{port}");
            LogMessage?.Invoke($"心跳检测: {(EnableHeartbeat ? "已启用" : "已禁用")}");
            if (EnableHeartbeat)
            {
                LogMessage?.Invoke($"心跳指令: {HeartbeatCommand}, 间隔: {HeartbeatInterval}ms");
            }

            try
            {
                while (_isRunning)
                {
                    var acceptTask = _listener.AcceptTcpClientAsync();
                    var cancelTask = Task.Delay(-1, _cts.Token);

                    var completedTask = await Task.WhenAny(acceptTask, cancelTask);

                    if (completedTask == cancelTask || _cts.Token.IsCancellationRequested)
                    {
                        break;
                    }
                    var client = await acceptTask;
                    _ = HandleClientAsync(client);
                }
            }
            catch (Exception ex)
            {
                LogMessage?.Invoke($"服务器错误: {ex.Message}");
            }
        }

        private async Task HandleClientAsync(TcpClient client)
        {
            var clientId = client.Client.RemoteEndPoint?.ToString() ?? "未知客户端";
            ClientConnected?.Invoke(clientId);
            LogMessage?.Invoke($"客户端已连接: {clientId}");

            try
            {
                using (client)
                using (var stream = client.GetStream())
                {
                    // 使用NetworkStream读取
                    byte[] buffer = new byte[4096];
                    MemoryStream ms = new MemoryStream();

                    while (!_cts.IsCancellationRequested && client.Connected)
                    {
                        // 检查数据是否可用
                        if (!stream.DataAvailable)
                        {
                            await Task.Delay(10, _cts.Token); // 短暂等待
                            continue;
                        }

                        // 同步读取方式
                        int bytesRead = stream.Read(buffer, 0, buffer.Length);
                        if (bytesRead == 0) // 连接已关闭
                        {
                            LogMessage?.Invoke($"客户端 {clientId} 正常断开");
                            break;
                        }

                        ms.Write(buffer, 0, bytesRead);

                        // 处理完整消息（消息以换行符结尾）
                        string receivedData = Encoding.ASCII.GetString(ms.ToArray());
                        //if (receivedData.Contains('\n'))
                        //{
                        string[] messages = receivedData.Split('\n');
                        for (int i = 0; i < messages.Length - 1; i++) // 最后一段可能不完整
                        {
                            string message = messages[i].Trim();
                            if (!string.IsNullOrEmpty(message))
                            {
                                await ProcessMessageAsync(message, stream, clientId);
                            }
                        }

                        // 保留不完整的部分
                        ms.SetLength(0);
                        if (!string.IsNullOrEmpty(messages.Last()))
                        {
                            ms.Write(Encoding.ASCII.GetBytes(messages.Last()), 0, messages.Last().Length);
                        }
                        //}
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessage?.Invoke($"处理客户端 {clientId} 时出错: {ex.Message}");
            }
            finally
            {
                ClientDisconnected?.Invoke(clientId);
                LogMessage?.Invoke($"客户端断开: {clientId}");
            }
        }

        private async Task ProcessMessageAsync(string message, NetworkStream stream, string clientId)
        {
            LogMessage?.Invoke($"来自 {clientId}: {message}");

            Console.WriteLine($"{DateTime.Now:HH:mm:ss:fff}：检测到触发信号{message}");
            EnhancedLogViewModel.Instance.AddLog($"{DateTime.Now:HH:mm:ss:fff}：检测到触发信号{message}");
            // 处理心跳
            if (EnableHeartbeat && message == HeartbeatCommand)
            {
                byte[] ack = Encoding.ASCII.GetBytes($"{HeartbeatCommand}_ACK\n");
                await stream.WriteAsync(ack, 0, ack.Length);
                return;
            }

            // 处理业务消息
            var parts = message.Split(',');
            if (parts.Length >= 2 && int.TryParse(parts[0], out var functionCode))
            {
                // 处理触发信号 (暂定功能码为3，待后续与客户沟通)
                if (functionCode == 3)
                {
                    await HandleTriggerCommand(stream, clientId);
                }
                else
                {
                    // 其他功能码处理
                    var response = $"{functionCode},0,Invalid function code\n";
                    byte[] responseBytes = Encoding.ASCII.GetBytes(response);
                    await stream.WriteAsync(responseBytes, 0, responseBytes.Length);
                }
            }
        }
        private async Task HandleTriggerCommand(NetworkStream stream, string clientId)
        {
            try
            {
                LogMessage?.Invoke($"开始处理触发命令，进行图像采集和推理...");
                // 调用图像处理委托
                int[] processingResults = await _imageProcessingHandler()
         .ConfigureAwait(false); // 避免死锁
                if (processingResults == null || processingResults.Length != _outputIOCount)
                {
                    throw new InvalidOperationException($"图像处理结果无效，预期{_outputIOCount}个输出，实际得到{processingResults?.Length ?? 0}");
                }

                // 构建响应消息
                var responseBuilder = new StringBuilder();
                responseBuilder.Append("3,"); // 功能号
                responseBuilder.Append(_outputIOCount); // 输出IO数

                // 添加每个点位的处理结果
                foreach (var result in processingResults)
                {
                    responseBuilder.Append($",{result}");
                }

                responseBuilder.Append("\n"); // 结束符

                string response = responseBuilder.ToString();
                LogMessage?.Invoke($"返回结果: {response.Trim()}");
                EnhancedLogViewModel.Instance.AddLog($"{DateTime.Now:HH:mm:ss:fff}：检测完成，返回结果{response.Trim()}");
                // 发送响应
                byte[] responseBytes = Encoding.ASCII.GetBytes(response);
                await stream.WriteAsync(responseBytes, 0, responseBytes.Length);
            }
            catch (Exception ex)
            {
                LogMessage?.Invoke($"处理触发命令时出错: {ex.Message}");

                // 发送错误响应
                var errorResponse = $"3,0,Error: {ex.Message}\n";
                byte[] errorBytes = Encoding.ASCII.GetBytes(errorResponse);
                await stream.WriteAsync(errorBytes, 0, errorBytes.Length);
            }
        }

        private async Task StartHeartbeatAsync(StreamWriter writer, CancellationToken token)
        {
            try
            {
                while (!token.IsCancellationRequested)
                {
                    await writer.WriteLineAsync(HeartbeatCommand);
                    await Task.Delay(HeartbeatInterval, token);
                }
            }
            catch (OperationCanceledException)
            {
                // 正常取消
            }
            catch (Exception ex)
            {
                LogMessage?.Invoke($"心跳任务错误: {ex.Message}");
            }
        }

        public void Stop()
        {
            _isRunning = false;
            _cts?.Cancel();
            try
            {
                _listener?.Stop();
                LogMessage?.Invoke("TCP服务器已停止");
            }
            catch (Exception ex)
            {
                LogMessage?.Invoke($"停止服务器时出错: {ex.Message}");
            }
        }

        public void Dispose()
        {
            Stop();
            _cts?.Dispose();
        }
    }
}