using System.Collections.Concurrent;
using Microsoft.Extensions.Logging;
using Seyounth.Hyosung.Data.Models;

namespace Seyounth.Hyosung.Core.Scanner;

public class HyosungScannerService : IHyosungScannerService
{
    private readonly List<HikScanner> _yarnScanners = new();

    private readonly ILogger<HyosungScannerService> _logger;

    private readonly ConcurrentDictionary<int, HikScanner> _fixtureScanners = new();

    private readonly List<HikScanner> _carScanners = new();
    private readonly List<HikScanner> _varietyScanners = new();
    private List<string> lastCodes = new List<string>();


    public HyosungScannerService(ILogger<HyosungScannerService> logger)
    {
        _yarnScanners.Add(new HikScanner("192.168.3.35", 2001));
        _yarnScanners.Add(new HikScanner("192.168.3.36", 2001));
        _yarnScanners.Add(new HikScanner("192.168.3.37", 2001));
        _yarnScanners.Add(new HikScanner("192.168.3.38", 2001));
        _yarnScanners.Add(new HikScanner("192.168.3.39", 2001));
        _fixtureScanners.TryAdd(1, new HikScanner("192.168.3.31", 2001));
        _fixtureScanners.TryAdd(2, new HikScanner("192.168.3.32", 2001));
        _fixtureScanners.TryAdd(3, new HikScanner("192.168.3.33", 2001));
        _fixtureScanners.TryAdd(4, new HikScanner("192.168.3.30", 2001));
        _carScanners.Add(new HikScanner("192.168.30.46", 2001,5000));
        //_carScanners.Add(new HikScanner("1920.168.3.48", 2001,5000));
        _varietyScanners.Add(new HikScanner("192.168.30.47", 2001,10000));
        //_varietyScanners.Add(new HikScanner("192.168.3.49", 2001,10000));
        _logger = logger;
        lastCodes.Add("");
        lastCodes.Add("");
        lastCodes.Add("");
        lastCodes.Add("");
    }

    public async Task StartAsync(CancellationToken token)
    {
        // 创建一个超时任务
        var timeoutTask = Task.Delay(2000, token);

        // 为每个纱线扫描器创建一个带有超时的连接任务
        var yarnScannerTasks = _yarnScanners.Select(scanner =>
        {
            var connectTask = scanner.ConnectAsync(token);
            return Task.WhenAny(connectTask, timeoutTask);
        }).ToList();

        // 为每个夹具扫描器创建一个带有超时的连接任务
        var fixtureScannerTasks = _fixtureScanners.Values.Select(scanner =>
        {
            var connectTask = scanner.ConnectAsync(token);
            return Task.WhenAny(connectTask, timeoutTask);
        }).ToList();

        var varietyScannerTasks = _varietyScanners.Select(scanner =>
        {
            var connectTask = scanner.ConnectAsync(token);
            return Task.WhenAny(connectTask, timeoutTask);
        }).ToList();

        // 为每个车号扫描器创建一个带有超时的连接任务
        var carScannerTasks = _carScanners.Select(scanner =>
        {
            var connectTask = scanner.ConnectAsync(token);
            return Task.WhenAny(connectTask, timeoutTask);
        }).ToList();

        // 合并所有任务
        var allTasks = new List<Task>();
        allTasks.AddRange(carScannerTasks);
        allTasks.AddRange(varietyScannerTasks);
        allTasks.AddRange(yarnScannerTasks);
        allTasks.AddRange(fixtureScannerTasks);

        // 等待所有任务完成
        await Task.WhenAll(allTasks);

        // 检查每个任务是否超时
        foreach (var task in yarnScannerTasks)
        {
            var innerTask = task as Task<Task>;
            if (innerTask.Result == timeoutTask)
            {
                // 处理纱线扫描器连接超时的情况
                Console.WriteLine($"纱线扫描器连接超时");
            }
        }

        foreach (var task in fixtureScannerTasks)
        {
            var innerTask = task as Task<Task>;
            if (innerTask.Result == timeoutTask)
            {
                // 处理夹具扫描器连接超时的情况
                Console.WriteLine($"夹具扫描器连接超时");
            }
        }

        foreach (var task in varietyScannerTasks)
        {
            var innerTask = task as Task<Task>;
            if (innerTask.Result == timeoutTask)
            {
                // 处理纱线扫描器连接超时的情况
                Console.WriteLine($"产品扫描器连接超时");
            }
        }

        foreach (var task in carScannerTasks)
        {
            var innerTask = task as Task<Task>;
            if (innerTask.Result == timeoutTask)
            {
                // 处理车号扫描器连接超时的情况
                Console.WriteLine($"车号扫描器连接超时");
            }
        }
        // foreach (var scanner in _yarnScanners)
        // {
        //     await scanner.ConnectAsync(token);
        // }
        //
        // foreach (var fixtureScanner in _fixtureScanners)
        // {
        //     await fixtureScanner.Value.ConnectAsync(token);
        // }
    }

    public async Task StopAsync(CancellationToken token)
    {
        List<Task> ls = _yarnScanners.Select(scanner => scanner.CloseAsync(token)).ToList();
        ls.AddRange(_fixtureScanners.Values.Select(scanner => scanner.CloseAsync(token)).ToList());
        await Task.WhenAll(ls);
    }

    public async Task<Yarn?> ScanYarnAsync(int varietyId)
    {
        List<Task<string>> ls = _yarnScanners.Select(scanner => scanner.ScanAsync()).ToList();

        //停止所有的扫码枪

        while (ls.Count > 0)
        {
            // 使用 Task.WhenAny 方法等待任意一个任务完成
            Task<string> completedTask = await Task.WhenAny(ls);
            // 移除已经完成的任务
            ls.Remove(completedTask);
            // 获取完成任务的结果
            string result = await completedTask;
            // 如果结果不为空，立即返回结果
            if (!string.IsNullOrEmpty(result))
            {
                _yarnScanners.Select(async scanner => await scanner.Stop());
                return Yarn.Create(result, varietyId);
            }
        }

        //_yarnScanners.Select( scanner =>  scanner.Stop());
        _logger.LogWarning($"all scanner no scan yarn");
        _yarnScanners.Select(async scanner => await scanner.Restart());
        // 如果所有任务都完成且没有找到非空结果，返回 null
        return null;
    }

    public async Task<string> ScanFixtureAsync(int fixtureId)
    {
        try
        {
            return await _fixtureScanners[fixtureId].ScanAsync();
        }
        catch (Exception e)
        {
            _logger.LogError(e, $"Fixture{fixtureId} Scan Error");
            await _fixtureScanners[fixtureId].Restart();
            return await _fixtureScanners[fixtureId].ScanAsync();
        }

        //string code = "";
        //do
        //{
        //    code= await _fixtureScanners[fixtureId].ScanAsync();
        //    await Task.Delay(100);
        //} while (code != lastCodes[fixtureId - 1]);
        //lastCodes[fixtureId - 1] = code;
        //return code;
    }

    public async Task<string> ScanYarnCarAsync(int entryId)
    {
        return await _carScanners[entryId - 1].ScanAsync();
    }

    public async Task<string> ScanVarietyAsync(int entryId)
    {
        return await _varietyScanners[entryId - 1].ScanAsync();
    }
}