///
/// Copyright (c) 2013-2015 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using log4net;
using NHibernate;
using Common;
using Config.Entities;
using SharedDatabase.Entities;

namespace TBF.UiBridge
{ 
    /// <summary>
    /// Provides separation of the UI and the state machine.
    /// </summary>
    static class Bridge
    {
		static readonly ILog log = LogManager.GetLogger(typeof(Bridge));

		public static readonly Queue<UI2BenchCmd> Ui2MachineQueue;

		public static int BatchNr;

        static Bridge()
        {
            Ui2MachineQueue = new Queue<UI2BenchCmd>();
        }

        /// <summary>
        /// This function should be called from the UI
        /// </summary>
        /// <param name="cmd"></param>
        public static void Ui2Bench(UI2BenchCmd cmd)
        {
            lock (Ui2MachineQueue)
            {
                Ui2MachineQueue.Enqueue(cmd);
            }
        }

        /// <summary>
        /// This function should be called from state machine operations
        /// </summary>
        public static void Bench2UI(ButtonsEtc flags)
        {
            if (ButtonsEtcHandler == null) return;
            try  {  ButtonsEtcHandler(null, new ButtonsEtcEventArgs(flags));  }
            catch (Exception e)  {  log.Error("UiEventHandler(...) failed", e);  }
        }
        public static event EventHandler<ButtonsEtcEventArgs> ButtonsEtcHandler;


		/// <summary>
		/// Called from the state machine when a procedure is selected and UI needs to be updated.
		/// </summary>
		public static void OnProcedureSelected(object sender, ProcedureSelectedEventArgs data)
		{
            if (ProcedureSelectedHandler == null) return;
			try { ProcedureSelectedHandler(sender, data); }
			catch (Exception e) { log.Error("ProcedureSelectedHandler(...) failed", e); }
		}
		public static event EventHandler<ProcedureSelectedEventArgs> ProcedureSelectedHandler;


		/// <summary>
		/// Called from the state machine when a test is selected and UI needs to be updated.
		/// </summary>
		public static void OnTestSelected(object sender, TestSelectedEventArgs data)
		{
            TBF.Rig.Sequences.ProcessData.ClearProcessValues();

            if (TestSelectedHandler == null) return;
			try { TestSelectedHandler(sender, data); }
			catch (Exception e) { log.Error("TestSelectedHandler(...) failed", e); }
		}
		public static event EventHandler<TestSelectedEventArgs> TestSelectedHandler;


        /// <summary>
        /// Called from the state machine when a test is selected and UI needs to be updated.
        /// </summary>
        public static void OnFlowDetected(object sender, FlowDetectedEventArgs data)
        {
            TBF.Rig.Sequences.ProcessData.ClearProcessValues();

            if (FlowDetectedHandler == null) return;
            try { FlowDetectedHandler(sender, data); }
            catch (Exception e) { log.Error("FlowDetectedHandler(...) failed", e); }
        }
        public static event EventHandler<FlowDetectedEventArgs> FlowDetectedHandler;


        /// <summary>
        /// Called from the state machine when progress bars need to be updated.
        /// </summary>
        public static void OnTestProgress(object sender, TestProgressEventArgs data)
		{
            if (TestProgressHandler == null) return;
			try { TestProgressHandler(sender, data); }
            catch (Exception e) { log.Error("TestProgressHandler(...) failed", e); }
		}
		public static event EventHandler<TestProgressEventArgs> TestProgressHandler;


		/// <summary>
		/// Called from the state machine when one test of the adjustment process was completed and UI needs to be updated.
		/// </summary>
		public static void OnAdjustmentInProgress(object sender, AdjustmentInProgressEventArgs data)
		{
			if (AdjustmentInProgressHandler == null) return;
			try { AdjustmentInProgressHandler(sender, data); }
			catch (Exception e) { log.Error("AdjustmentInProgressHandler(...) failed", e); }
		}
		public static event EventHandler<AdjustmentInProgressEventArgs> AdjustmentInProgressHandler;


        /// <summary>
        /// Called from the state machine when one test of the pulses test process was completed and UI needs to be updated.
        /// </summary>
        public static void OnPulsesTestInProgress(object sender, PulsesTestInProgressEventArgs data)
        {
            if (PulsesTestInProgressHandler == null) return;
            try { PulsesTestInProgressHandler(sender, data); }
            catch (Exception e) { log.Error("PulsesTestInProgressHandler(...) failed", e); }
        }
        public static event EventHandler<PulsesTestInProgressEventArgs> PulsesTestInProgressHandler;


        /// <summary>
        /// Called from the state machine when 'Activity' information changes.
        /// </summary>
        public static void OnCompoundDetection(object sender, string message)
        {
            if (CompoundDetectionHandler == null) return;
            try { CompoundDetectionHandler(sender, new CompoundDetectionEventArgs(message)); }
            catch (Exception e) { log.Error("CompoundDetectionHandler(...) failed", e); }
        }
        public static event EventHandler<CompoundDetectionEventArgs> CompoundDetectionHandler;


		/// <summary>
		/// Called from the state machine when the test is completed and UI needs to be updated.
		/// </summary>
		public static void OnTestCompleted(object sender, TestCompletedEventArgs data)
		{
            TBF.Rig.Sequences.ProcessData.SaveProcessData();

            if (TestCompletedHandler == null) return;
			try { TestCompletedHandler(sender, data); }
			catch (Exception e) { log.Error("TestCompletedHandler(...) failed", e); }
		}
		public static event EventHandler<TestCompletedEventArgs> TestCompletedHandler;


		/// <summary>
		/// Called from the state machine when the procedure is completed and UI needs to be updated.
		/// </summary>
		public static void OnProcedureCompleted(object sender, ProcedureCompletedEventArgs data)
		{
            if (ProcedureCompletedHandler == null) return;
			try { ProcedureCompletedHandler(sender, data); }
			catch (Exception e) { log.Error("ProcedureCompletedHandler(...) failed", e); }
		}
		public static event EventHandler<ProcedureCompletedEventArgs> ProcedureCompletedHandler;


        /// <summary>
        /// Called from the state machine when 'Activity' information changes.
        /// </summary>
        public static void OnActivity(object sender, string activity)
        {
            if (ActivityHandler == null) return;
			try { ActivityHandler(sender, new ActivityEventArgs(ActivityEventArgs.Update.Activity, activity, null, false)); }
            catch (Exception e) { log.Error("ActivityHandler(...) failed", e); }
        }
		public static void OnMessage(object sender, string message)
		{
			if (ActivityHandler == null) return;
			try { ActivityHandler(sender, new ActivityEventArgs(ActivityEventArgs.Update.Message, null, message, false)); }
			catch (Exception e) { log.Error("ActivityHandler(...) failed", e); }
		}
		public static void OnError(object sender, string message)
		{
			if (ActivityHandler == null) return;
			try { ActivityHandler(sender, new ActivityEventArgs(ActivityEventArgs.Update.Message, null, message, true)); }
			catch (Exception e) { log.Error("ActivityHandler(...) failed", e); }
		}
		public static event EventHandler<ActivityEventArgs> ActivityHandler;


        /// <summary>
        /// 'State machine tick' event handler (typically called in RunDevieAfter() of the control board
        /// </summary>
        public static void OnStateMachineTick(object sender, StateMachineTickEventArgs args)
        {
            if (StateMachineTickHandler != null)  StateMachineTickHandler(sender, args);
        }
        public static event EventHandler<StateMachineTickEventArgs> StateMachineTickHandler;


        /// <summary>
        /// 'State machine state has changed' event handler
        /// </summary>
        public static void OnStateChanged(object sender, string stateChangedMsg)
        {
            if (StateChangedHandler == null) return;
            try { StateChangedHandler(sender, new StateChangedEventArgs(stateChangedMsg)); }
            catch (Exception e) { string s = e.ToString(); }
        }
        public static event EventHandler<StateChangedEventArgs> StateChangedHandler;


		/// <summary>
		/// Called from the state machine when an operation forces a modeless dialog close.
		/// </summary>
		public static void OnCloseModelessForm(object sender, EventArgs args)
		{
			if (CloseModelessFormHandler == null) return;
			try { CloseModelessFormHandler(sender, null); }
			catch (Exception e) { log.Error("CloseModelessFormHandler(...) failed", e); }
		}
		public static event EventHandler<EventArgs> CloseModelessFormHandler;


        /// <summary>
        /// Called from the state machine when a procedure is selected and UI needs to be updated.
        /// </summary>
        public static void OnCameraUICmd(object sender, CameraUICmdEventArgs data)
        {
            if (CameraUICmdHandler == null) return;
            try
            {
	            log.DebugFormat("CameraUICmdHandler: {0}", data.CameraUICmd);
	            foreach (EventHandler<CameraUICmdEventArgs> handler in CameraUICmdHandler.GetInvocationList())
	            {
		            var localHandler = handler;

		            Task.Run(() =>
		            {
			            try
			            {
				            localHandler(sender, data);
			            }
			            catch (Exception e)
			            {
				            log.Error("CameraUICmdHandler(...) failed", e);
			            }
		            });
	            }
            }
            catch (Exception e) { log.Error("CameraUICmdHandler(...) failed", e); }
        }
        public static event EventHandler<CameraUICmdEventArgs> CameraUICmdHandler;

        /// <summary>
        /// Called from a camera when camera state (shown as a caption in PicturesTabPage) changes
        /// </summary>
        public static void OnCameraInfo(int cameraIdx, string info)
        {
            if (CameraInfoHandler == null) return;
            try { CameraInfoHandler(null, new CameraInfoEventArgs(cameraIdx, info)); }
            catch (Exception e) { log.Error("CameraInfoHandler(...) failed", e); }
        }
        public static event EventHandler<CameraInfoEventArgs> CameraInfoHandler;

        /// <summary>
        /// Called from any RTP listener thread (e.g. MJpeg RTP listener thread)
        /// </summary>
        public static void OnImage(int cameraIdx, System.Drawing.Image image)
        {
            if (ImageHandler == null) return;
            try { ImageHandler(null, new ImageEventArgs(cameraIdx, image)); }
            catch (Exception e) { log.Error("ImageHandler(...) failed", e); }
        }
        public static event EventHandler<ImageEventArgs> ImageHandler;

        /// <summary>
        /// Called from TestMethods.Counter component when counters in LocalSettings should be saved.
        /// </summary>
        public static void OnSaveSettings(object sender, SaveSettingsEventArgs data)
        {
            if (SaveSettingsHandler == null) return;
            try { SaveSettingsHandler(sender, data); }
            catch (Exception e) { log.Error("SaveSettingsHandler(...) failed", e); }
        }
        public static event EventHandler<SaveSettingsEventArgs> SaveSettingsHandler;


        public static void TriggerEvent(ISession session, string source, EventClass clss, Severity severity, string message, string moreInfo, SubscriberGroup groups)
        {
            SharedDatabase.Entities.Event evnt = new Event(null, source, clss, severity, message, moreInfo, null);
            SharedDatabase.EventsDB.SaveEvent(session, evnt, groups);
            if (EventHandler != null)
            {
                try { EventHandler(null, new EventEventArgs(evnt)); }
                catch (Exception e) { log.Error("EventHandler(...) failed", e); }
            }
        }
        public static void TriggerEvent(ISession session, SharedDatabase.Entities.Event evnt)
        {
            SharedDatabase.EventsDB.SaveEvent(session, evnt, evnt.SubscriberGroups);
            if (EventHandler != null)
            {
                try { EventHandler(null, new EventEventArgs(evnt)); }
                catch (Exception e) { log.Error("EventHandler(...) failed", e); }
            }
        }
        public static event EventHandler<EventEventArgs> EventHandler;



        public static void OnRouteChange(object sender, RouteChangeArgs args)
        {
            if (RouteChangeHandler == null) return;
            try { RouteChangeHandler(sender, args); }
            catch (Exception e) { log.Error("RouteChangeHandler(...) failed", e); }
        }
        public static event EventHandler<RouteChangeArgs> RouteChangeHandler;

        public static void OnMeasurementRequest(object sender, MeasurementRequestArgs args)
        {
            if (MeasurementRequestHandler == null) return;
            try { MeasurementRequestHandler(sender, args); }
            catch (Exception e) { log.Error("MeasurementRequestHandler(...) failed", e); }
        }
        public static event EventHandler<MeasurementRequestArgs> MeasurementRequestHandler;

        public static void OnSetpointChange(object sender, SetpointChangeArgs args)
        {
            if (SetpointChangeHandler == null) return;
            try { SetpointChangeHandler(sender, args); }
            catch (Exception e) { log.Error("SetpointChangeHandler(...) failed", e); }
        }
        public static event EventHandler<SetpointChangeArgs> SetpointChangeHandler;
    }
}