using System;
using System.Collections.Generic;
using DTS.Common.Interface.DASFactory;
using DTS.Common.Utilities.Logging;
using DTS.DASLib.Service;
using System.Threading;
using System.Linq;
using DTS.Common.SharedResource.Strings;
using DTS.Common.DataModel.Common;
using DTS.Common.Enums.TSRAIRGo;
using DTS.Common.Constant.DASSpecific;
using DTS.Common.DataModel.Classes.TSRAIRGo;

namespace DataPROWin7.DataModel.Classes
{
    public class Arming
    {
        readonly Configuration configuration = new Configuration();
        public Arming()
        {
        }

        public bool SetConfigAndFlashClear(DataModel.TestTemplate currentTest,
            List<IDASCommunication> dasList,
            Dictionary<string, int> dasSampleRateList,
            double duration,
            StatusHelpers.SetProgressValueDelegate setProgressFunction,
            ServiceBase.ServiceCallbackErrorEventHandler onError)
        {
            return SetConfigAndStartFlashClear(currentTest, dasList, dasSampleRateList, duration, false, setProgressFunction, onError);
        }



        private bool SetConfigAndStartFlashClear(DataModel.TestTemplate currentTest,
            List<IDASCommunication> dasList,
            Dictionary<string, int> dasSampleRateList,
            double duration,
            bool diagnosticsVoltage,
            StatusHelpers.SetProgressValueDelegate setProgressFunction,
            ServiceBase.ServiceCallbackErrorEventHandler onError)
        {
            foreach (var das in dasList)
            {
                foreach (var mod in das.ConfigData.Modules)
                {
                    mod.PostTriggerSeconds = duration;
                    mod.PreTriggerSeconds = (double)TSRAIR.TSRAIR_MAX_PRE_TRIGGER_SAMPLES / Convert.ToInt32(dasSampleRateList[das.SerialNumber]);
                    //FB 26980 mod.NumberOfEvents has already a correct value but override it to make sure the value is there
                    mod.NumberOfEvents = currentTest.NumberOfEvents;
                    mod.WakeUpMotionTimeout = currentTest.WakeUpMotionTimeout; //10?
                }
            }
            try
            {
                foreach (var das in dasList)
                {
                    setProgressFunction(das, 0D, TSRAIRGoStatus.StatusTypes.PREPARING_FOR_ARMING);
                }

                configuration.SetConfig(currentTest, dasList, diagnosticsVoltage, setProgressFunction);

                foreach (var das in dasList)
                {
                    setProgressFunction(das, 0D, TSRAIRGoStatus.StatusTypes.PREPARING_DATA_MEMORY);
                }
                return StartFlashClear(dasList, setProgressFunction, currentTest, onError);
            }
            catch (Exception ex)
            {
                onError?.Invoke(this, $"{StringResources.FailedToArm}: {ex.Message}", ex);
                APILogger.Log(ex.Message);
                return false;
            }
        }
        protected bool StartFlashClear(List<IDASCommunication> dasList, StatusHelpers.SetProgressValueDelegate setProgressFunction,
            DataModel.TestTemplate currentTest, ServiceBase.ServiceCallbackErrorEventHandler onError)
        {
            return FlashErase(dasList, setProgressFunction, currentTest, onError);
        }
        protected bool FlashErase(List<IDASCommunication> dasList, StatusHelpers.SetProgressValueDelegate setProgressFunction,
            DataModel.TestTemplate currentTest, ServiceBase.ServiceCallbackErrorEventHandler onError)
        {
            var cancelEvent = new ManualResetEvent(false);
            var resetEvent = new ManualResetEvent(false);
            var bFailed = false;
            var flashDevices = new List<IDASCommunication>(dasList);
            var failureToClearFlashDevices = new List<IDASCommunication>();
            lock (DASHardware.GetArmStatusLock)
            {
                if (flashDevices.Any())
                {
                    using (var armingService = new ArmingService())
                    {
                        armingService.AggregateProgress = false;
                        var done = new ManualResetEvent(false);
                        var timeWaited = 0;
                        armingService.BeginFlashErase(flashDevices, delegate (ServiceBase.CallbackData cbd)
                        {
                            switch (cbd.Status)
                            {
                                case ServiceBase.CallbackData.CallbackStatus.Failure:
                                    bFailed = true;

                                    //39345 Don't hang if Flash Erase fails
                                    cbd.Target.DASArmStatus.FaultMessage = StringResources.ArmSystem_FailedToClearFlash;
                                    cbd.Target.SetDASArmStatus();
                                    onError?.Invoke(this, string.Format(StringResources.ArmSystem_FailedToClearFlash, cbd.Target.SerialNumber), null);
                                    failureToClearFlashDevices.Add(cbd.Target);
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                                    done.Set();
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Success:
                                    break;
                            }
                        }, flashDevices, false);
                        while (!cancelEvent.WaitOne(0, false) && !done.WaitOne(50, false))
                        {
                            timeWaited += 50;
                        }
                    }
                }

                //39345 Don't hang if Flash Erase fails
                if (bFailed)
                {
                    return false;
                }

                if (flashDevices.Any())
                {
                    using (var armingService = new ArmingService())
                    {
                        armingService.AggregateProgress = false;
                        var bDone = false;
                        var flashStatus = new Dictionary<IDASCommunication, bool>();

                        foreach (var das in flashDevices)
                        {
                            flashStatus[das] = false;
                        }
                        while (!bDone)
                        {
                            var done = new ManualResetEvent(false);
                            var timeWaited = 0;
                            armingService.GetFlashEraseStatus(flashDevices, delegate (ServiceBase.CallbackData cbd)
                            {
                                switch (cbd.Status)
                                {
                                    case ServiceBase.CallbackData.CallbackStatus.Failure:
                                        bFailed = true;
                                        flashStatus[cbd.Target] = true;
                                        failureToClearFlashDevices.Add(cbd.Target);
                                        onError?.Invoke(this, string.Format(StringResources.ArmSystem_FailedToClearFlash, cbd.Target.SerialNumber), cbd.ErrorException);
                                        break;
                                    case ServiceBase.CallbackData.CallbackStatus.Success:
                                        flashStatus[cbd.Target] = true;
                                        break;
                                    case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                                        {
                                            using (var enumeratorFlashStatus = flashStatus.GetEnumerator())
                                            {
                                                var b = true;
                                                while (enumeratorFlashStatus.MoveNext())
                                                {
                                                    if (!enumeratorFlashStatus.Current.Value)
                                                    {
                                                        b = false;
                                                    }
                                                }
                                                bDone = b;
                                            }
                                        }
                                        done.Set();
                                        break;
                                    case ServiceBase.CallbackData.CallbackStatus.Progress:
                                        StatusHelpers.SetStatus2(cbd.Target, cbd.ProgressValue, TSRAIRGoStatus.StatusTypes.PREPARING_DATA_MEMORY, setProgressFunction);
                                        if (100 <= cbd.ProgressValue)
                                        {
                                            flashStatus[cbd.Target] = true;
                                        }
                                        break;
                                }
                            }, flashDevices);
                            while (!cancelEvent.WaitOne(0, false) && !done.WaitOne(50, false))
                            {
                                timeWaited += 50;
                            }
                            if (cancelEvent.WaitOne(0, false))
                            {
                                bDone = true;
                            }
                        }
                    }
                    //39345 Don't hang if Flash Erase fails
                    if (bFailed)
                    {
                        return false;
                    }
                }
            }
            if (!cancelEvent.WaitOne(0, false) && !bFailed)
            {
                return PrepareArmFunc(dasList, setProgressFunction, currentTest, onError);
            }
            else if (bFailed)
            {
                resetEvent.Set();
                cancelEvent.Set();
                return false;
            }

            return true;
        }

        protected bool PrepareArmFunc(List<IDASCommunication> dasList, StatusHelpers.SetProgressValueDelegate setProgressFunction, DataModel.TestTemplate currentTest,
            ServiceBase.ServiceCallbackErrorEventHandler onError
            )
        {
            const int ARM_NOW_TIMEOUT = 30000;
            var cancelEvent = new ManualResetEvent(false);
            var g = Guid.NewGuid();

            var bFailedPrepareArm = false;

            lock (DASHardware.GetArmStatusLock)
            {
                if (currentTest.LevelTriggerChannels.Count > 0)
                {
                    using (var armService = new ArmingService())
                    {
                        var mre = new ManualResetEvent(false);
                        armService.CheckAlreadyLevelTriggered(dasList, delegate (ServiceBase.CallbackData cbd)
                        {
                            switch (cbd.Status)
                            {
                                case ServiceBase.CallbackData.CallbackStatus.Failure:
                                    onError(this, $"{StringResources.ArmSystem_FailedArm} {cbd.ErrorMessage} - {cbd.Target.SerialNumber}", cbd.ErrorException);
                                    bFailedPrepareArm = true;
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                                    mre.Set();
                                    break;
                            }
                        }, dasList);
                        mre.WaitOne();
                        var alreadyLevelTriggeredChannels = (from das in dasList where null != das.ConfigData from m in das.ConfigData.Modules from ch in m.Channels where ch is AnalogInputDASChannel let aCh = ch as AnalogInputDASChannel where aCh.AlreadyLevelTriggered select $"{das.SerialNumber} {1 + aCh.Number}").ToList();
                        if (alreadyLevelTriggeredChannels.Count > 0)
                        {
                            bFailedPrepareArm = true;
                            var errors = new List<string>();
                            errors.Add(StringResources.AlreadyLevelTriggeredChannels);
                            errors.AddRange(alreadyLevelTriggeredChannels.ToArray());
                        }
                    }
                }
                if (!bFailedPrepareArm)
                {
                    using (var armService = new ArmingService())
                    {
                        var done = new ManualResetEvent(false);
                        var timeWaited = 0;
                        armService.ReadyForArm(dasList, delegate (ServiceBase.CallbackData cbd)
                        {
                            switch (cbd.Status)
                            {
                                case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                                    done.Set();
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Progress:
                                    StatusHelpers.SetStatus2(cbd.Target, cbd.ProgressValue, TSRAIRGoStatus.StatusTypes.PREPARING_FOR_ARMING, setProgressFunction);
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Success:
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Failure:
                                    bFailedPrepareArm = true;
                                    onError(this, $"{StringResources.ArmSystem_FailedArm} {cbd.ErrorMessage} - {cbd.Target.SerialNumber}", cbd.ErrorException);
                                    break;
                            }
                        }, dasList, 600000, false, currentTest.NumberOfEvents, 0, g, false, dasList.Count > 1);
                        while (!cancelEvent.WaitOne(0, false) && !done.WaitOne(50, false))
                        {
                            timeWaited += 50;
                        }
                    }
                }

                if (!bFailedPrepareArm)
                {
                    using (var armService = new ArmingService())
                    {
                        var done = new ManualResetEvent(false);
                        var timeWaited = 0;
                        armService.PrepareForArmNow(dasList, delegate (ServiceBase.CallbackData cbd)
                        {
                            switch (cbd.Status)
                            {
                                case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                                    done.Set();
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Failure:
                                    onError(this, $"{StringResources.ArmSystem_FailedArm} {cbd.ErrorMessage} - {cbd.Target.SerialNumber}", cbd.ErrorException);
                                    bFailedPrepareArm = true;
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Success:
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Progress:
                                    StatusHelpers.SetStatus2(cbd.Target, cbd.ProgressValue, TSRAIRGoStatus.StatusTypes.PREPARING_FOR_ARMING, setProgressFunction);
                                    break;
                            }
                        }, dasList, ARM_NOW_TIMEOUT, false, currentTest.NumberOfEvents, g, dasList.Count > 1/* && CurrentTest.CommonLine*/);
                        while (!cancelEvent.WaitOne(0, false) && !done.WaitOne(50, false))
                        {
                            timeWaited += 50;
                        }

                        if (!cancelEvent.WaitOne(0, false))
                        {
                            done.Reset();
                        }
                    }
                    if (bFailedPrepareArm)
                    {
                        cancelEvent.Set();
                        return false;
                    }
                }
                else
                {
                    cancelEvent.Set();
                    return false;
                }
            }

            return ArmNowFunc(dasList, setProgressFunction, currentTest, onError);
        }
        protected bool ArmNowFunc(List<IDASCommunication> dasList, StatusHelpers.SetProgressValueDelegate setProgressFunction,
            DataModel.TestTemplate currentTest, ServiceBase.ServiceCallbackErrorEventHandler onError)
        {
            var cancelEvent = new ManualResetEvent(false);

            if (Common.SerializedSettings.StoreTestHistoryInDb)
            {
                //add code here?
            }
            var g = Guid.NewGuid();

            var bFailedArm = false;

            lock (DASHardware.GetArmStatusLock)
            {
                var bSomeoneArmed = false;
                using (var armService = new ArmingService())
                {
                    var done = new ManualResetEvent(false);
                    var timeWaited = 0;

                    done.Reset();
                    var disarmList = new List<IDASCommunication>();
                    PreparedArmNowFunc(dasList, g, ref bSomeoneArmed, ref bFailedArm, ref timeWaited, ref disarmList, setProgressFunction, currentTest,
                        onError);

                    //for safety reasons, make a disarm call to _everybody_ that "failed to arm", incase a module armed but the rack didn't
                    //http://fogbugz/fogbugz/default.asp?4527
                    if (done.WaitOne(0, false) && disarmList.Count > 0)
                    {
                        done.Reset();
                        bSomeoneArmed = false;
                        using (var aService = new ArmingService())
                        {
                            aService.Disarm(dasList, delegate (ServiceBase.CallbackData cbd)
                            {
                                switch (cbd.Status)
                                {
                                    case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                                        done.Set();
                                        break;
                                }
                            }
                                , dasList);
                        }

                        while (!cancelEvent.WaitOne(0, false) && !done.WaitOne(50, false))
                        { }
                    }
                }

                if (bSomeoneArmed)
                {
                    if (!cancelEvent.WaitOne(0, false))
                    {
                        var das = new List<IDASCommunication>(dasList);
                        for (var i = das.Count - 1; i >= 0; i--)
                        {
                            if (null == das[i].DASArmStatus || das[i].DASArmStatus.IsArmed == false)
                            {
                                das.RemoveAt(i);
                            }
                            else
                            {
                                if (null != das[i].ConfigData && das[i].ConfigData.NumberOfConfiguredChannels() == 0 /*&& CareAboutNumberOfConfiguredChannels(das[i])*/)
                                {
                                    das.RemoveAt(i);
                                }
                            }
                        }
                        var bFailedEnableFaultChecking = false;
                        var faultCheckingErrors = new List<string>();
                        //keeps track of whether we need to restore semaphores
                        //15630 limit EnableFaultChecking to single unit at a time for TDAS when there's a rack involved
                        if (das.Count > 1)
                        {
                            using (var armService = new ArmingService())
                            {
                                var done = new ManualResetEvent(false);
                                var timeWaited = 0;
                                armService.EnableFaultChecking(dasList, delegate (ServiceBase.CallbackData cbd)
                                {
                                    switch (cbd.Status)
                                    {
                                        case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                                            done.Set();
                                            break;
                                        case ServiceBase.CallbackData.CallbackStatus.Failure:
                                            bFailedEnableFaultChecking = true;
                                            faultCheckingErrors.Add($"{cbd.Target.SerialNumber} {StringResources.FailedEnableFaultChecking}");
                                            onError(this, $"{StringResources.ArmSystem_FailedArm} {cbd.ErrorMessage} - {cbd.Target.SerialNumber}", cbd.ErrorException);
                                            break;
                                    }
                                }, das);
                                while (!cancelEvent.WaitOne(0, false) && !done.WaitOne(50, false))
                                {
                                    timeWaited += 50;
                                }
                            }
                        }

                        //15267 Stop on ERR response from TDAS ARM RF
                        if (bFailedEnableFaultChecking)
                        {
                            DisarmAll(dasList);
                            cancelEvent.Set();
                            return false;
                        }
                    }
                }
                else if (bFailedArm)
                {
                    cancelEvent.Set();
                    return false;
                }
            }

            return true;
        }
        private void DisarmAll(List<IDASCommunication> das)
        {
            var mre = new ManualResetEvent(false);
            using (var aService = new ArmingService())
            {
                aService.Disarm(das, delegate (ServiceBase.CallbackData cbd)
                {
                    switch (cbd.Status)
                    {
                        case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                            mre.Set();
                            break;
                    }
                }
                    , das);
            }

            mre.WaitOne();
        }
        private void PreparedArmNowFunc(List<IDASCommunication> dasList,
            Guid g,
            ref bool bSomeoneArmed,
            ref bool bFailedArm,
            ref int timeWaited,
            ref List<IDASCommunication> lDisarmList,
            StatusHelpers.SetProgressValueDelegate setProgressFunction,
            DataModel.TestTemplate currentTest,
            ServiceBase.ServiceCallbackErrorEventHandler onError)
        {
            var someoneArmed = false;
            var failedArm = false;
            var disarmList = new List<IDASCommunication>();
            var doneEvent = new ManualResetEvent(false);
            var cancelEvent = new ManualResetEvent(false);
            var done = doneEvent;
            using (var armService = new ArmingService())
            {
                armService.PreparedArmNow(dasList, delegate (ServiceBase.CallbackData cbd)
                {
                    switch (cbd.Status)
                    {
                        case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                            done.Set();
                            break;
                        case ServiceBase.CallbackData.CallbackStatus.Failure:
                            onError(this, $"{StringResources.ArmSystem_FailedArm} {cbd.ErrorMessage} - {cbd.Target.SerialNumber}", cbd.ErrorException);
                            disarmList.Add(cbd.Target);
                            failedArm = true;
                            break;
                        case ServiceBase.CallbackData.CallbackStatus.Success:
                            if (!cbd.Target.IsEthernetDistributor())
                            {
                                someoneArmed = true;
                                try
                                {
                                    if (null == cbd.Target.DASArmStatus) { cbd.Target.DASArmStatus = new ArmStatus(); }
                                    cbd.Target.DASArmStatus.IsArmed = true;
                                    cbd.Target.SetDASArmStatus();
                                }
                                catch (Exception ex)
                                {
                                    APILogger.Log(ex.Message);
                                }
                            }
                            break;
                        case ServiceBase.CallbackData.CallbackStatus.Progress:
                            StatusHelpers.SetStatus2(cbd.Target, cbd.ProgressValue, TSRAIRGoStatus.StatusTypes.PREPARING_FOR_ARMING, setProgressFunction);
                            break;
                    }
                }, dasList, 30000, false, currentTest.NumberOfEvents, g, dasList.Count > 1); ///////////fix the 30000 and 1 (at least)
            }
            while (!cancelEvent.WaitOne(0, false) && !done.WaitOne(50, false))
            {
                timeWaited += 50;
            }
            bSomeoneArmed = bSomeoneArmed || someoneArmed;
            bFailedArm = bFailedArm || failedArm;
            lDisarmList.AddRange(disarmList);
            doneEvent = done;
        }
        public void SoftwareTrigger(List<IDASCommunication> dasList)
        {
            try
            {
                using (var armingService = new ArmingService())
                {
                    lock (DASHardware.GetArmStatusLock)
                    {
                        var mre = new ManualResetEvent(false);
                        armingService.Trigger(dasList, delegate (ServiceBase.CallbackData data)
                        {
                            switch (data.Status)
                            {
                                case ServiceBase.CallbackData.CallbackStatus.AllFinished: mre.Set(); break;
                                case ServiceBase.CallbackData.CallbackStatus.Failure: APILogger.Log(data.ErrorMessage); break;
                            }
                        }, dasList);
                        while (!mre.WaitOne(10, false)) { }

                    }
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failure in Software Trigger");
                APILogger.Log(ex);
            }
        }
        public void DisarmAsync(List<IDASCommunication> dasList)
        {
            Disarm(dasList);
        }
        private void Disarm(List<IDASCommunication> dasList)
        {
            DisarmSync(dasList);
        }
        private void DisarmSync(List<IDASCommunication> dasList)
        {
            var mre = new ManualResetEvent(false);
            using (var armingService = new ArmingService())
            {
                lock (DASHardware.GetArmStatusLock)
                {
                    armingService.Disarm(
                        dasList,
                        delegate (ServiceBase.CallbackData data)
                        {
                            switch (data.Status)
                            {
                                case ServiceBase.CallbackData.CallbackStatus.AllFinished:
                                    mre.Set();
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Canceled:
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Failure:
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Progress:
                                    break;
                                case ServiceBase.CallbackData.CallbackStatus.Success:
                                    break;
                            }
                        },
                        dasList);
                    while (!mre.WaitOne(10, false)) { }
                }
            }
        }
    }
}