using Logs;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using WCS.Entity;
using WCS.Service;

namespace WCS.Core
{
    /// <summary>
    /// 逻辑处理器
    /// </summary>
    public abstract class LogicHandler
    {
        /// <summary>
        /// 停止
        /// </summary>
        protected bool Stoped = false;

        /// <summary>
        /// 描述
        /// </summary>
        protected string Description { get; }

        /// <summary>
        /// 所有对象
        /// </summary>
        public static List<object> AllObjects = new();

        /// <summary>
        /// 所有处理器
        /// </summary>
        private static readonly List<LogicHandler> Handlers = new();

        /// <summary>
        /// 日志委托，暂时弃用
        /// </summary>
        [Obsolete]
        public static Action<string, string, string> DbLog;

        /// <summary>
        /// 逻辑处理器
        /// </summary>
        protected LogicHandler()
        {
            var attr = this.GetType().GetCustomAttributes(false).OfType<DescriptionAttribute>().FirstOrDefault();
            Description = attr != null ? attr.Description : this.GetType().Name;
        }

        /// <summary>
        /// 开始
        /// </summary>
        public abstract void Start();

        /// <summary>
        /// 是否并行
        /// </summary>
        public virtual bool ParallelRun => false;

        /// <summary>
        /// 数据刷新时触发
        /// </summary>
        /// <param name="milliseconds">离上次触发的间隔时间（毫秒）</param>
        public abstract void Update(double milliseconds);

        /// <summary>
        /// 停止
        /// </summary>
        public void Stop()
        {
            Stoped = true;
        }

        /// <summary>
        /// 添加处理器
        /// </summary>
        /// <param name="handler">处理器</param>
        public static void AddManager(LogicHandler handler)
        {
            Handlers.Add(handler);
        }

        /// <summary>
        /// 启动所有的处理器
        /// </summary>
        public static void StartAll()
        {
            foreach (var h in Handlers)
            {
                h.Start();
            }
            var th = new Thread(Loop)
            {
                IsBackground = true //前台线程即主线程关闭，立即结束该线程
            };
            th.Start();
        }

        /// <summary>
        /// 最后一次执行结束的时间
        /// </summary>
        private static DateTime _last = DateTime.Now;

        /// <summary>
        ///逻辑耗时
        /// </summary>
        private static int _logicTimes;

        public static DateTime Frame { get; private set; }

        /// <summary>
        /// 主循环体，用于PLC数据的读取与逻辑执行
        /// </summary>
        private static void Loop()
        {
            //TODO:可能存在异常，使用时需验证一次
            var arr = AllObjects.OfType<WCS_DEVICE>().Where(v => v.ENABLED).SelectMany(v => v.DEVICEPROTOCOLS)
                .Where(v => v.ENABLED && v.DB.ENABLED && v.DB.PLC.ENABLED)
                .GroupBy(v => v.DB).Select(v => v.Key)
                .ToArray();

            while (true)
            {
                var dd = DateTime.Now;
                Frame = DateTime.Now;
                Parallel.ForEach(arr, db =>
                {
                    try
                    {
                        Ltc.SetChannel("刷新");
                        db.Ex().DataRefresh();
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("更新" + db.NAME + "数据失败:" + ex.Message);
                    }
                });
                var dbTimes = (DateTime.Now - dd).TotalMilliseconds;

                var total = (DateTime.Now - _last).TotalMilliseconds;
                var s = (int)(600 - total);
                if (s > 0)
                    Thread.Sleep(s);
                total = (DateTime.Now - _last).TotalMilliseconds;
                Console.ForegroundColor = ConsoleColor.Blue;
                //此处打印的logicTimes实际是上一个周期的业务处理时长
                Console.WriteLine("------刷新DB块数据耗时:" + ((int)dbTimes).ToString().PadRight(4, ' ') + "；业务逻辑耗时：" + ((int)_logicTimes).ToString().PadRight(4, ' ') + "；周期总耗时" + ((int)total).ToString().PadRight(4, ' ') + "");
                Console.ResetColor();
                _last = DateTime.Now;

                Parallel.ForEach(Handlers, m =>
                {
                    var dm = DateTime.Now;
                    try
                    {
                        m.Update(total);
                    }
                    catch (Exception)
                    {
                        //TODO:增加一个异常记录
                    }
                    var dm2 = (DateTime.Now - dm).TotalMilliseconds;
                });

                Configs.Publish();
                _logicTimes = (int)(DateTime.Now - _last).TotalMilliseconds;
            }
        }

        /// <summary>
        /// 停止所有的处理器
        /// </summary>
        public static void StopAll()
        {
            foreach (var h in Handlers)
            {
                try
                {
                    h.Stop();
                }
                catch
                {
                    // TODO:等待处理
                }
            }
        }
    }

    /// <summary>
    /// 逻辑处理器 泛型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class LogicHandler<T> : LogicHandler where T : EntityEx<WCS_DEVICE>
    {
        /// <summary>
        /// 业务类集合
        /// </summary>
        protected List<WorkInfo<T>> Works = new();

        /// <summary>
        /// TODO:？
        /// </summary>
        private IEnumerable<T> _objects = null;

        protected IEnumerable<T> Objects
        {
            get
            {
                _objects ??= AllObjects.OfType<WCS_DEVICE>().Where(SelectDevice)
                    .Select(v => Activator.CreateInstance(typeof(T), v)).OfType<T>().ToArray();
                return _objects.Where(v => v.Entity.ENABLED && v.Entity.DEVICEPROTOCOLS.All(d => d.ENABLED && d.DB.ENABLED && d.DB.PLC.ENABLED));
            }
        }

        /// <summary>
        /// 写入设备信息
        /// </summary>
        /// <param name="dev">设备</param>
        /// <returns></returns>
        private static bool SelectDevice(WCS_DEVICE dev)
        {
            var typenames = typeof(T).GenericTypeArguments.Select(v => v.AssemblyQualifiedName).ToArray();
            var res = typenames.All(v => dev.DEVICEPROTOCOLS.Any(d => d.DB.PROTOCOL == v));
            return res;
        }

        /// <summary>
        /// 添加Work
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="work">work</param>
        /// <param name="parallel">是否并发</param>
        public void AddWork(Func<T, bool> condition, Action<T> work, bool parallel = false)
        {
            var title = work.Method.Name;
            var attr = work.Method.GetCustomAttributes(false).OfType<DescriptionAttribute>().FirstOrDefault();
            if (attr != null)
                title = attr.Description;
            var arr = Objects.Where(condition).ToArray();
            this.Works.Add(new WorkInfo<T> { Work = work, Params = arr, Title = title, Parallel = parallel });
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="work"></param>
        /// <param name="parallel"></param>
        public void AddWork(IEnumerable<T> arr, Action<T> work, bool parallel = false)
        {
            var title = work.Method.Name;
            var attr = work.Method.GetCustomAttributes(false).OfType<DescriptionAttribute>().FirstOrDefault();
            if (attr != null)
                title = attr.Description;

            this.Works.Add(new WorkInfo<T> { Work = work, Params = arr, Title = title, Parallel = parallel });
        }

        /// <summary>
        /// 开始执行业务流程
        /// </summary>
        /// <param name="milliseconds"></param>
        public override void Update(double milliseconds)
        {
            if (ParallelRun)
            {
                Parallel.ForEach(Works, DoWork);
            }
            else
            {
                foreach (var w in Works)
                {
                    DoWork(w);
                }
            }
        }

        /// <summary>
        /// 执行Work
        /// </summary>
        /// <param name="work"></param>
        protected virtual void DoWork(WorkInfo<T> work)
        {
            if (work.Parallel)
            {
                Parallel.ForEach(work.Params, p =>
                {
                    Do(work, p);
                });
            }
            else
            {
                foreach (var p in work.Params)
                {
                    Do(work, p);
                }
            }
        }

        /// <summary>
        /// 开始执行
        /// </summary>
        /// <param name="wi"></param>
        /// <param name="p"></param>
        protected virtual void Do(WorkInfo<T> wi, T p)
        {
            var channel = Description + "." + wi.Title + "." + p;
            try
            {
                Ltc.SetChannel(channel);
                Ltc.Log("开始---------------------------------------");

                wi.Work(p);
            }
            catch (DoException ex)
            {
                InfoLog.INFO_INFO($"[{channel}]--{ex.Message}");
            }
            //WarnException进阶条件未满足，添加数据库，记录文本日志、数据库，上抛WCS，上抛WMS
            catch (WarnException ex)
            {
                InfoLog.INFO_WARN($"[{channel}]--{ex.Message}");
                Ltc.Log(ex.GetBaseException().Message);
                Configs.UploadException?.Invoke(p.ToString(), ex.GetBaseException().Message);
            }
            //未知异常，仅记录文本日志，需定期排查该文件，检查系统是否有未知异常，并处理
            catch (Exception ex)
            {
                InfoLog.INFO_ERROR($"[{channel}]--{ex.Message}--{ex.StackTrace}");
            }
            finally
            {
                Ltc.Log("结束\n");
            }
        }

        /// <summary>
        /// 此方法不会被自动调用，请在Start方法中使用AddWork将其添加至工作队列
        /// </summary>
        /// <param name="dev"></param>
        [Description("执行")]
        protected abstract void Execute(T dev);
    }

    public class WorkTitleAttribute : Attribute
    {
        public Type Handler { get; set; }
        public string Title { get; set; }
        public bool Parallel { get; set; }

        public WorkTitleAttribute(Type handler, string title, bool parallel = false)
        {
            this.Handler = handler;
            this.Title = title;
            this.Parallel = parallel;
        }
    }

    public abstract class Work
    {
        public abstract IEnumerable<object> GetObjs();

        public abstract void Execute(object obj);
    }

    public abstract class Work<T> : Work
    {
        public override sealed void Execute(object obj)
        {
            Do((T)obj);
        }

        public override sealed IEnumerable<object> GetObjs()
        {
            return InitObjects().OfType<object>().ToArray();
        }

        protected abstract void Do(T obj);

        protected abstract bool SelectDevice(WCS_DEVICE dev);

        protected virtual IEnumerable<T> InitObjects()
        {
            var arr = Device.Where(v => v.ENABLED)
                     .Where(SelectDevice).ToArray();
            var res = arr.Select(v => (T)Activator.CreateInstance(typeof(T), v));
            return res;
        }
    }

    public abstract class DeviceWork<T> : Work<T> where T : EntityEx<WCS_DEVICE>
    {
        private readonly string[] _typenames;

        protected DeviceWork()
        {
            _typenames = typeof(T).GenericTypeArguments.Select(v => v.AssemblyQualifiedName).ToArray();
        }

        protected abstract override void Do(T obj);

        protected override sealed IEnumerable<T> InitObjects()
        {
            var arr = Device.Where(v => v.ENABLED && v.DEVICEPROTOCOLS.All(d => d.ENABLED && d.DB.ENABLED && d.DB.PLC.ENABLED))
                   .Where(v => _typenames.All(d => v.DEVICEPROTOCOLS.Any(e => e.DB.PROTOCOL == d)))
                   .Where(SelectDevice).ToArray();
            var res = arr.Select(v => Activator.CreateInstance(typeof(T), v) as T);

            return res;
        }
    }
}