using DBHelper;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using WCS.Core;
using WCS.Entity;

namespace WCS.Service
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

        public Worker(ILogger<Worker> logger)
        {
            _logger = logger;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        { 
            if (stoppingToken.IsCancellationRequested)
                return;
            _logger.LogInformation("WCS开始启动");

            Configs.ProtocolProxyBaseType = typeof(ProtocolProxy);
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
            Configs.StringEncoding = Encoding.UTF8; 

            DB.SetDefaultDbContextType<WCSDB>();

            Configs.DoCmds = act =>
            {
                DB.Do(db => 
                {
                    var cmds = db.Default.Set<WCS_CMD>().Where(v => v.ENABLED).ToArray();
                    Parallel.ForEach(cmds, cmd =>
                    {
                        act(cmd);
                        cmd.ENABLED = false;
                    });
                });
            };

            PLCAccessor.Creater = new PLCAccessors.PLCAccessorsCreater();
            try
            {
                DB.Do(db => 
                {
                    var items = db.Default.Set<WCS_DEVICEPROTOCOL>()
                   //.Where(v=>v.DB.NO==537)
                   .Where(v => v.ENABLED && v.DEVICE.ENABLED && v.DB.ENABLED && v.DB.PLC.ENABLED)
                   .Include(v => v.DEVICE)
                   .Include(v => v.DB.PLC).ToArray();
                    items.Select(v => v.Data()).ToArray();
                    LogicHandler.AllObjects.AddRange(items);

                    var devices = items.GroupBy(v => v.DEVICE).Select(v => v.Key).ToArray();
                    LogicHandler.AllObjects.AddRange(devices);
                });

                var managerTypes = Assembly.GetExecutingAssembly().GetTypes().Where(v => v.IsSubclassOf(typeof(LogicHandler)) && !v.IsGenericType).ToArray();
                foreach (var type in managerTypes)
                {
                    var m = Activator.CreateInstance(type);
                    LogicHandler.AddManager(m as LogicHandler);
                }

                LogicHandler.StartAll();
                _logger.LogInformation("WCS启动成功");
            }
            catch(Exception ex)
            {
                _logger.LogError("WCS启动失败{0}", ex.Message);
            }
           
        }

        public override Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogError("WCS关闭");
            LogicHandler.StopAll();
            return base.StopAsync(cancellationToken);
        }
    }
}