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();


    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));
        _logger = logger;
    }

    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 allTasks = new List<Task>();
        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 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<Yarn?>> ls = _yarnScanners.Select(scanner => scanner.ScanAsync()
                .ContinueWith(task =>
                {
                    if (task.IsCompletedSuccessfully && !string.IsNullOrEmpty(task.Result))
                    {
                        _logger.LogInformation($"scanner[{scanner.Host}:{scanner.Port}] scan yarn {task.Result}");
                        return Yarn.Create(task.Result, varietyId);
                    }

                    return null;
                }))
            .ToList();

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

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

    public async Task<string> ScanFixtureAsync(int fixtureId)
    {
        return await _fixtureScanners[fixtureId].ScanAsync();
    }
}