using Newtonsoft.Json.Linq;
using Sodao.FastSocket.Server.Messaging;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BiosenSocketService.Exceptions;
using XImaging.Automation.Library.HxDriverLib;
using XImaging.Automation.Service;
using XImaging.Automation.Service.Instruction;
using Sodao.FastSocket.SocketBase.Utils;
using System.Xml.Linq;

namespace XImaging.Automation.Service.Instruction
{
    public delegate void TroubleShootDelegate();
    public delegate void OnTaskFinishDelegate(TaskInstruction tIns, JObject data, int status);
    public delegate void OnTaskAbortDelegate(TaskInstruction tIns, string errCode, string errString);
    public delegate void QueryDataDelegate(JObject data);
    /*
     * HxTroubleShoot
     * 记录并处理任务指令中途错误的类
     */
    public class HxTroubleShoot
    {
        public const int TS_Ignore = 1;    // 错误处理方式：忽略
        public const int TS_Retry = 2;    // 错误处理方式：重试
        public const int TS_Abort = 4;    // 错误处理方式：中断 

        private string str_errCode;        // 错误码
        private int p_Troubleshoot=7;   // 可能的错误处理方式，0-7
        private string str_Message;   // 错误信息
        private int nDealwithtype = 0;

        public event TroubleShootDelegate IgnoreTrigger;   // Ignore事件
        public event TroubleShootDelegate RetryTrigger;    // Retry事件
        public event TroubleShootDelegate AbortTrigger;    // Abort事件

        private bool b_onWaiting = false;
        private int r_Troubleshoot = -1;  // 用户反馈的错误处理方式

        /// <summary>
        /// 记录新错误的信息
        /// </summary>
        /// <param name="errCode">错误码</param>
        /// <param name="TroubleshootPossibility">可行的处理方式</param>
        /// <param name="message">错误信息</param>
        public void Error(HxMessage hxMessage, string errCode, int TroubleshootPossibility, string MsgText, int nDealwithtype)
        {
            //while (b_onWaiting)
            //{
            //    Thread.Sleep(1000);
            //}
            this.str_errCode = errCode;
            this.p_Troubleshoot = TroubleshootPossibility;
            this.str_Message = MsgText;
            this.nDealwithtype = nDealwithtype;

            JObject err = JObject.FromObject(
               new
               {
                   error_code = str_errCode,
                   error_text = str_Message,
                   troubleshoot = p_Troubleshoot,
                   dealwithtype= nDealwithtype,
               }
           );
            HxTcpHandler.ReplyErrorMessage(hxMessage, err , str_errCode, str_Message, nDealwithtype, p_Troubleshoot);
        }

        /// <summary>
        /// 记录新错误的信息
        /// </summary>
        /// <param name="errCode">错误码</param>
        /// <param name="TroubleshootPossibility">可行的处理方式</param>
        /// <param name="message">错误信息</param>
        public void Abort(HxMessage hxMessage, string errCode, int TroubleshootPossibility, string MsgText, int nDealwithtype)
        {
            while (b_onWaiting)
            {
                Thread.Sleep(1000);
            }
            this.str_errCode = errCode;
            this.p_Troubleshoot = TroubleshootPossibility;
            this.str_Message = MsgText;
            this.nDealwithtype = nDealwithtype;
            HxTcpHandler.ReplyFailedMessage(hxMessage, hxMessage.OriginJSON, str_errCode, str_Message, nDealwithtype, p_Troubleshoot, nDealwithtype);
        }

        public bool MatchTSCode(int TS_Code)
        {
            return (p_Troubleshoot & TS_Code) > 0;
        }

        /// <summary>
        /// 阻塞等待用户反馈
        /// </summary>
        public void Wait()
        {
            b_onWaiting = true;
            while (r_Troubleshoot < 0)
            {
                Thread.Sleep(500);
            }
            b_onWaiting = false;
        }

        /// <summary>
        /// 异步等待用户反馈
        /// </summary>
        public async void WaitAsync()
        {
            b_onWaiting = true;
            await Task.Run(() =>
            {
                while (r_Troubleshoot < 0)
                {
                    Thread.Sleep(500);
                }
            });
            b_onWaiting = false;
        }

        /// <summary>
        /// 同步处理用户反馈
        /// </summary>
        /// <param name="TroubleshootReply"></param>
        public void Reply(int TroubleshootReply)
        {
            r_Troubleshoot = TroubleshootReply;
            if (TroubleshootReply == TS_Ignore)
                IgnoreTrigger.Invoke();
            else if (TroubleshootReply == TS_Retry)
                RetryTrigger.Invoke();
            else if (TroubleshootReply == TS_Abort)
                AbortTrigger.Invoke();
        }

        /// <summary>
        /// 异步处理用户反馈
        /// </summary>
        /// <param name="TroubleshootReply"></param>
        public async void ReplyAsync(int TroubleshootReply)
        {
            r_Troubleshoot = TroubleshootReply;
            if (TroubleshootReply == TS_Ignore)
                await Task.Run(() => { IgnoreTrigger.Invoke(); });
            else if (TroubleshootReply == TS_Retry)
                await Task.Run(() => { RetryTrigger.Invoke(); });
            else if (TroubleshootReply == TS_Abort)
                await Task.Run(() => { AbortTrigger.Invoke(); });
        }

        ~HxTroubleShoot()
        {
            Delegate[] dels;
            if (IgnoreTrigger != null)
            {
                dels = IgnoreTrigger.GetInvocationList();
                foreach (Delegate del in dels)
                {
                    object delObj = del.GetType().GetProperty("Method").GetValue(del, null);
                    string funcName = (string)delObj.GetType().GetProperty("Name").GetValue(delObj, null);
                    Console.WriteLine(funcName);
                    IgnoreTrigger -= del as TroubleShootDelegate;
                }
            }

            if (RetryTrigger != null)
            {
                dels = RetryTrigger.GetInvocationList();
                foreach (Delegate del in dels)
                {
                    object delObj = del.GetType().GetProperty("Method").GetValue(del, null);
                    string funcName = (string)delObj.GetType().GetProperty("Name").GetValue(delObj, null);
                    Console.WriteLine(funcName);
                    RetryTrigger -= del as TroubleShootDelegate;
                }
            }

            if (AbortTrigger != null)
            {
                dels = AbortTrigger.GetInvocationList();
                foreach (Delegate del in dels)
                {
                    object delObj = del.GetType().GetProperty("Method").GetValue(del, null);
                    string funcName = (string)delObj.GetType().GetProperty("Name").GetValue(delObj, null);
                    Console.WriteLine(funcName);
                    AbortTrigger -= del as TroubleShootDelegate;
                }
            }
        }
    }

    interface IInstruction
    {
    }

    public class HxInstruction: IInstruction
    {
        public const int INSTYPE_HeartBeat = 0;    // 类型：心跳包
        public const int INSTYPE_Task = 1;         // 类型：任务，指有较长执行时间的指令
        public const int INSTYPE_Query = 2;        // 类型：查询，指即时返回的指令
        public const int INSTYPE_Troubleshoot = 3; // 类型：错误处理，指客户端返回的问题处理指令

        public const int TASKSTAT_Scheduled = 0;    // 状态：准备执行
        public const int TASKSTAT_InProgress = 1;   // 状态：正在执行
        public const int TASKSTAT_Completed = 2;    // 状态：执行完成
        public const int TASKSTAT_Failed = 3;       // 状态：执行失败
        public const int TASKSTAT_Canceled = 4;     // 状态：任务取消

        protected HxMessage m_Message;     // 接收到的Socket信息包
        protected int n_TaskStatus;        // 任务状态

        public HxInstruction(HxMessage message)
        {
            m_Message = message;
            n_TaskStatus = -1;  // HxInstruction.TASKSTAT_Scheduled;
        }

        public string InsId { get { return m_Message.MessageID; } }   // 指令ID，唯一
        public string InsName { get { return m_Message.Method; } }   // 指令名
        public int Type { get { return m_Message.MessageType; } }       // 指令类型
        public int Status { get { return n_TaskStatus; } }                     // 指令执行状态

        public HxMessage Message { get { return m_Message; } }
    }

    /*
     * 心跳包指令
     */
    public class HeartBeatInstruction : HxInstruction
    {
        public HeartBeatInstruction(HxMessage message) : base(message) { }
    }

    /*
     * 任务指令
     */
    public class TaskInstruction : HxInstruction
    {
        HxInsParser command = null;
        public HxTroubleShoot ErrorHandler;

        public TaskInstruction(HxMessage message)
            : base(message)
        {
            ErrorHandler = new HxTroubleShoot();
        }

        public TaskInstruction(HxMessage message, HxInsParser cmd)
            : base(message)
        {
            ErrorHandler = new HxTroubleShoot();
            command = cmd;
        }
        
        public void OnTaskError(Object objMsg, string errCode, int TroubleshootPossibility, string message, int dealwithtype)
        {
            LogConstant.logger.Print($"OnTaskError: {message}");
            JObject jObj = objMsg as JObject;
            string id = jObj["message_id"].ToString();
            if (Message.MessageID == id)
                ErrorHandler.Error(this.Message, errCode, TroubleshootPossibility, message, dealwithtype);
            //ErrorHandler.WaitAsync();
        }
        public void OnTaskAbort(Object objMsg, string errCode, int TroubleshootPossibility, string message, int dealwithtype)
        {
            ErrorHandler.Abort(this.Message, errCode, TroubleshootPossibility, message, dealwithtype);
            //ErrorHandler.WaitAsync();
        }

        public void OnFinishTest(Dictionary<string,int> result)
        {
            JObject data = new JObject();// StartExperimentInsArgs.ReturnDataWrapper(result);
            HxTcpHandler.ReplyFinishMessage(this.Message, data);
        }

        // 指令已收到，执行状态转为Scheduled
        public void Standby()
        {
            n_TaskStatus = TASKSTAT_Scheduled;
        }

        // 指令下发设备，开始正式执行
        public void Execute()
        {
            n_TaskStatus = TASKSTAT_InProgress;
        }

        // 指令已经执行完毕，并正常结束
        public void Finish()
        {
            n_TaskStatus = TASKSTAT_Completed;
        }

        // 指令已经执行但被迫中断或执行失败
        public void Abort()
        {
            n_TaskStatus = TASKSTAT_Failed;
        }
    }

    /*
     * 查询指令
     */
    public class QueryInstruction : HxInstruction
    {
        HxInsParser command = null;
        public QueryDataDelegate OnDataReturned;

        public QueryInstruction(HxMessage message)
            : base(message){}

        public QueryInstruction(HxMessage message, HxInsParser cmd) 
            : base(message) 
        {
            command = cmd;
        }
    }

    /*
     * 错误处理指令
     */
    public class TroubleshootInstruction : HxInstruction
    {
        public TroubleshootInstruction(HxMessage message) : base(message) { }

        public int TSCode
        {
            get
            {
                return m_Message.Troubleshoot;
            }
        }
    }

    public class InstructionManager
    {
        TaskInstruction t_Instrction = null;    // 任务指令
        //ConcurrentQueue<QueryInstruction> q_Instructions;   // 查询指令队列
        readonly static object qryLock = new object();   // 查询指令队列锁

        System.Threading.Timer qTimer;
        private InsProtocol insProtocol;

        /// <summary>
        /// 监控查询指令队列
        /// </summary>
        /// <param name="state">占位参数</param>
        /*protected void QueueObserver(object state)
        {
            QueryInstruction qIns = null;
            bool deqFlag = false;
            lock (qryLock)
            {
                // 当查询队列中有指令未处理时取出
                if (q_Instructions.Count > 0)
                    deqFlag = q_Instructions.TryDequeue(out qIns);
                else
                    return;
            }

            try
            {
                if (deqFlag && qIns != null)
                {
                    // 执行查询指令
                    JObject data = insProtocol.Query(qIns);
                    if (data == null)
                        data = new JObject();
                    HxTcpHandler.ReplyFinishMessage(qIns.Message,data);
                }
            }
            catch (Exception ex)
            {
                HxTcpHandler.ReplyFailedMessage(qIns.Message, new JObject(), "ERROR", qIns.InsName+" error", 4);
            }
        }*/

        public InstructionManager()
        {
            //q_Instructions = new ConcurrentQueue<QueryInstruction>();
            insProtocol = new InsProtocol();

            // 启动定时器，每100ms查看一次查询队列中是否有新的查询任务
            //qTimer = new System.Threading.Timer(QueueObserver, null, 0, 100);
        }

        public void OnConnect(bool isConnect)
        {
            insProtocol.OnConnect(isConnect);
        }
        /// <summary>
        /// 当任务指令完成时调用该函数反馈给客户端
        /// </summary>
        /// <param name="data">任务产生的数据</param>
        /// <param name="status">任务完成时的状态</param>
        public void OnTaskFinish(TaskInstruction tIns, JObject data, int status)
        {
            if (tIns != null)
            {
                if (status == HxMessage.METHOD_STATUS_COMPLETED)
                {
                    tIns.Finish();
                    // 返回任务结束信息
                    HxTcpHandler.ReplyFinishMessage(
                            tIns.Message,
                            data);
                }
                else
                {
                    tIns.Abort();

                    HxTcpHandler.ReplyFailedMessage(tIns.Message,data,"EC-00-000", "OnTaskFinish status=failed");
                }
            }
        }

        /// <summary>
        /// 当任务指令完成时调用该函数反馈给客户端
        /// </summary>
        /// <param name="data">任务产生的数据</param>
        /// <param name="status">任务完成时的状态</param>
        public void OnTaskAbort(TaskInstruction tIns, string errCode, string errString)
        {
            if (tIns != null)
            {
                tIns.Abort();

                HxTcpHandler.ReplyFailedMessage(tIns.Message, ResponseMessagePackage.NullData, "EC-00-000", errString);
            }
        }

        /// <summary>
        /// 设置当前设备的查任务指令
        /// </summary>
        /// <param name="tIns">任务指令</param>
        /// <exception cref="TaskUncompletedException">上一个任务指令还未完成</exception>
        public void Add(TaskInstruction tIns)
        {
            // 当前没有任务指令的时候
            //if (t_Instrction == null)
            //{
            //    t_Instrction = tIns;
            //}
            // 当前有任务指令的时候，需要判断该任务是否已完成
            //else
            {

                string msg = string.Format("收到指令:{0},{1}", tIns.InsName, tIns.InsId);
                LogConstant.logger.Print(msg);
                //// 如果任务准备进行或正在进行中，则抛出任务冲突的错误
                //if (t_Instrction.Status == TaskInstruction.TASKSTAT_Scheduled || 
                //    t_Instrction.Status == TaskInstruction.TASKSTAT_InProgress)
                //    throw new TaskUncompletedException(
                //        string.Format("执行冲突：任务\"{0}:{1}\"正在运行中", t_Instrction.InsName, t_Instrction.InsId));

                //// 如果设备处于TASKSTAT_Completed, TASKSTAT_Failed或TASKSTAT_Cancel状态，则重新将其设为准备态
                //else
                {
                    //t_Instrction = tIns;
                    //t_Instrction.Standby();
                }
            }
            // 异步执行任务
            insProtocol.AsyncTask(ref tIns, OnTaskFinish, OnTaskAbort);
        }

        /// <summary>
        /// 设置当前设备的查询指令
        /// </summary>
        /// <param name="qIns">查询指令</param>
        public void Add(QueryInstruction qIns)
        {
            lock (qryLock)
            {
                //q_Instructions.Enqueue(qIns);
            }
        }

        /// <summary>
        /// 设置当前设备的错误处理指令
        /// </summary>
        /// <param name="tsIns">错误处理指令</param>
        /// <exception cref="TaskUncompletedException">上一个任务指令还未完成</exception>
        public void Add(TroubleshootInstruction tsIns)
        {
            // 只有在当前任务存在，且当前任务正在执行过程中，且当前任务与错误处理的ID相同的情况下
            if (t_Instrction == null)
            {
                LogConstant.logger.Print("没有前置错误可以处理");
                return;
            }
            if (t_Instrction.Status != TaskInstruction.TASKSTAT_InProgress)
            {
                LogConstant.logger.Print(string.Format("任务状态不符合错误处理要求，当前状态为:{0}", t_Instrction.Status));
                return;
            }
            if (!tsIns.InsId.Equals(t_Instrction.InsId))
            {
                LogConstant.logger.Print(string.Format("任务ID不一致，当前需要处理的任务ID为:{0}", t_Instrction.InsId));
                return;
            }
            if (!t_Instrction.ErrorHandler.MatchTSCode(tsIns.TSCode))
            {
                LogConstant.logger.Print(string.Format("错误处理方式{0}不符合要求", tsIns.TSCode));
                return;
            }

            LogConstant.logger.Print(string.Format("开始处理错误，TS Code={0}", tsIns.TSCode));
            t_Instrction.ErrorHandler.ReplyAsync(tsIns.TSCode);
        }

    }
}