using Nancy.Hosting.Self;
using Newtonsoft.Json.Linq;
using SSWMS.Common;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Threading;

namespace SSWMS.Server
{
    public class Service
    {
        public delegate void LogEventHandler(string sFunctionName, string sLog);
        public static event LogEventHandler Log;

        public static int Start()
        {
            try
            {
                lWCFService = new List<WCFService>()
                {
                    new WCFService(S_BaseService._S_BaseService),
                    new WCFService(S_BaseService._S_CellService),
                    new WCFService(S_BaseService._S_ControlService),
                    new WCFService(S_BaseService._S_DeviceService),
                    new WCFService(S_BaseService._S_ERPService),
                    new WCFService(S_BaseService._S_ManageService),
                    new WCFService(S_BaseService._S_PlanService),
                    new WCFService(S_BaseService._S_StorageService),
                    new WCFService(S_BaseService._S_SystemService)
                };
                StartService();
                StartWeb();
                bwTask = new BackgroundWorker
                {
                    WorkerSupportsCancellation = true
                };
                bwTask.DoWork += TaskDoWork;
                bwTask.RunWorkerAsync();
                bwTaskApply = new BackgroundWorker
                {
                    WorkerSupportsCancellation = true
                };
                bwTaskApply.DoWork += TaskApplyDoWork;
                bwTaskApply.RunWorkerAsync();
                bwTaskLED = new BackgroundWorker
                {
                    WorkerSupportsCancellation = true
                };
                bwTaskLED.DoWork += TaskLEDDoWork;
                bwTaskLED.RunWorkerAsync();
                bwTaskInterface = new BackgroundWorker
                {
                    WorkerSupportsCancellation = true
                };
                bwTaskInterface.DoWork += TaskInterfaceDoWork;
                bwTaskInterface.RunWorkerAsync();
                //bwTaskPlc = new BackgroundWorker
                //{
                //    WorkerSupportsCancellation = true
                //};
                //bwTaskPlc.DoWork += TaskPlcDoWork;
                //bwTaskPlc.RunWorkerAsync();
            }
            catch (Exception ex)
            {
                Log("Start Server", ex.Message);
                return SystemCode.ConstCode.ServerStart;
            }
            return SystemCode.ConstCode.Success;
        }

        public static void Stop()
        {
            try
            {
                bRunningThread = false;
                bIOControl = false;
                bIOControlApply = false;
                bManage = false;
                bPlan = false;
                bLED = false;
                Thread.Sleep(1000);
                if (bwTask != null)
                {
                    bwTask.CancelAsync();
                }
                if (bwTaskApply != null)
                {
                    bwTaskApply.CancelAsync();
                }
                if (bwTaskLED != null)
                {
                    bwTaskLED.CancelAsync();
                }
                if (bwTaskInterface != null)
                {
                    bwTaskInterface.CancelAsync();
                }
                if (bwTaskPlc != null)
                {
                    bwTaskPlc.CancelAsync();
                }
                StopService();
                StopWeb();
                Thread.Sleep(2000);
            }
            catch (Exception ex)
            {
                Log("Stop Server", ex.Message);
            }
        }

        #region Web
        private static NancyHost host = null;

        public static void StartWeb()
        {
            try
            {
                StopWeb();
                host = new NancyHost(new WebNancyBootstrapper(), new Uri(AppSettings.WebAPIUrl), new Uri(AppSettings.WebAPIUrl_Android));
                host.Start();
            }
            catch
            {
            }
        }

        public static void StopWeb()
        {
            try
            {
                if (host != null)
                {
                    host.Dispose();
                }
            }
            catch
            {
            }
        }
        #endregion

        #region Service
        public static List<WCFService> lWCFService;

        public static void StartService()
        {
            foreach (WCFService service in lWCFService)
            {
                try
                {
                    service.StartService();
                }
                catch (Exception ex)
                {
                    Log("Start Service", ex.Message);
                }
            }
        }

        public static void StopService()
        {
            foreach (WCFService service in lWCFService)
            {
                try
                {
                    service.StopService();
                }
                catch (Exception ex)
                {
                    Log("Stop Service", ex.Message);
                }
            }
        }
        #endregion

        #region Task
        public static bool bRunningThread = true;
        public static bool bIOControl = false;
        public static bool bIOControlApply = false;
        public static bool bManage = false;
        public static bool bPlan = false;
        public static bool bInterface = false;
        public static bool bLED = false;
        public static bool bPlc = false;
        public static BackgroundWorker bwTask = null;
        public static BackgroundWorker bwTaskApply = null;
        public static BackgroundWorker bwTaskLED = null;
        public static BackgroundWorker bwTaskInterface = null;
        public static BackgroundWorker bwTaskPlc = null;

        private static void TaskDoWork(object sender, DoWorkEventArgs e)
        {
            string sResult = string.Empty;
            while (bRunningThread)
            {
                if (bIOControl)
                {
                    try
                    {
                        if (!S_BaseService._S_ControlService.IOControlTask(out sResult))
                        {
                            Log("Task IO_CONTROL", sResult);
                        }
                    }
                    catch (Exception ex)
                    {
                        Log("Task IO_CONTROL Exception", ex.ToString());
                    }
                }
                if (bManage)
                {
                    try
                    {
                        if (!S_BaseService._S_ManageService.ManageTask(out sResult))
                        {
                            Log("Task MANAGE", sResult);
                        }
                    }
                    catch (Exception ex)
                    {
                        Log("Task MANAGE Exception", ex.ToString());
                    }
                }
                if (bPlan)
                {
                    try
                    {
                        if (!S_BaseService._S_PlanService.PlanTask(out sResult))
                        {
                            Log("Task PLAN", sResult);
                        }
                    }
                    catch (Exception ex)
                    {
                        Log("Task PLAN Exception", ex.ToString());
                    }
                }
                Thread.Sleep(2000);
            }
        }

        private static void TaskLEDDoWork(object sender, DoWorkEventArgs e)
        {
            string sResult = string.Empty;
            while (bRunningThread)
            {
                if (bLED)
                {
                    try
                    {
                        if (!LED.LEDTask(out sResult))
                        {
                            Log("Task LED", sResult);
                        }
                    }
                    catch (Exception ex)
                    {
                        Log("Task LED Exception", ex.ToString());
                    }
                    Thread.Sleep(500);
                }
            }
        }

        private static void TaskApplyDoWork(object sender, DoWorkEventArgs e)
        {
            string sResult = string.Empty;
            while (bRunningThread)
            {
                if (bIOControlApply)
                {
                    try
                    {
                        if (!S_BaseService._S_ControlService.IOControlApplyTask(out sResult))
                        {
                            Log("Task IO_CONTROL_APPLY", sResult);
                        }
                    }
                    catch (Exception ex)
                    {
                        Log("Task IO_CONTROL_APPLY Exception", ex.ToString());
                    }
                }
                Thread.Sleep(500);
            }
        }

        private static void TaskInterfaceDoWork(object sender, DoWorkEventArgs e)
        {
            string sResult = string.Empty;
            while (bRunningThread)
            {
                if (bInterface)
                {
                    try
                    {
                        foreach (RECORD_MAIN rm in S_BaseService._P_RECORD_MAIN.GetListByStatus(SystemCode.MANAGE_STATUS.Interface))
                        {
                            if (!S_BaseService._S_ERPService.ERPInterface(rm, out sResult))
                            {
                                Log("Task Interface", sResult);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Log("Task Interface Exception", ex.ToString());
                    }
                }
                Thread.Sleep(5000);
            }
        }

        private static void TaskPlcDoWork(object sender, DoWorkEventArgs e)
        {
            string sResult = string.Empty;
            while (bRunningThread)
            {
                try
                {
                    if (bPlc)
                    {
                        S7Net.Read();
                    }
                    else
                    {
                        S7Net.Close();
                    }
                }
                catch (Exception ex)
                {
                    Log("Task PLC Exception", ex.ToString());
                }
                Thread.Sleep(2000);
            }
        }
        #endregion
    }
}