using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Timers;

namespace Tango.Integration.Emergency
{
    /// <summary>
    /// Represents a USB serial port emergency switch notification provider.
    /// </summary>
    /// <seealso cref="Tango.Integration.Emergency.IEmergencyNotificationProvider" />
    public class UsbEmergencyNotificationProvider : IEmergencyNotificationProvider
    {
        private Timer _timer;
        private bool _busy;

        /// <summary>
        /// Gets or sets a value indicating whether to enable emergency detection and notification.
        /// </summary>
        public bool IsEnabled { get; set; }

        /// <summary>
        /// Gets or sets the current emergency status.
        /// </summary>
        public EmergencyStatus Status { get; set; }

        /// <summary>
        /// Gets or sets the address/port of the detection device.
        /// </summary>
        public string Address { get; set; }

        /// <summary>
        /// Gets or sets the read timeout for the loop-back signal.
        /// </summary>
        public TimeSpan ReadTimeout { get; set; }

        /// <summary>
        /// Gets or sets the signal output.
        /// </summary>
        public String SignalOutput { get; set; }

        /// <summary>
        /// Occurs when the emergency status has changed.
        /// </summary>
        public event EventHandler<EmergencyStatusChangedEventArgs> StatusChanged;

        /// <summary>
        /// Initializes a new instance of the <see cref="UsbEmergencyNotificationProvider"/> class.
        /// </summary>
        /// <param name="port">The port.</param>
        public UsbEmergencyNotificationProvider(String port)
        {
            SignalOutput = "1";
            Address = port;
            ReadTimeout = TimeSpan.FromMilliseconds(500);
            _timer = new Timer(2000);
            _timer.Elapsed += _timer_Elapsed;
            _timer.Start();
        }

        /// <summary>
        /// Called when the status has been changed.
        /// </summary>
        /// <param name="status">The status.</param>
        /// <param name="errorException">The error exception.</param>
        protected virtual void OnStatusChanged(EmergencyStatus status, Exception errorException = null)
        {
            if (Status != status)
            {
                Status = status;
                StatusChanged?.Invoke(this, new EmergencyStatusChangedEventArgs()
                {
                    Status = status,
                    ErrorException = errorException,
                });
            }
        }

        /// <summary>
        /// Handles the Elapsed event of the _timer.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ElapsedEventArgs"/> instance containing the event data.</param>
        [DebuggerNonUserCode]
        private void _timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            if (IsEnabled && !_busy)
            {
                _busy = true;

                SerialPort serial = new SerialPort(Address);
                try
                {
                    serial.ReadTimeout = (int)ReadTimeout.TotalMilliseconds;
                    serial.Open();

                    serial.Write(SignalOutput + "\n");

                    try
                    {
                        string output = serial.ReadLine();

                        if (output == SignalOutput)
                        {
                            OnStatusChanged(EmergencyStatus.On);
                        }
                        else
                        {
                            OnStatusChanged(EmergencyStatus.Off);
                        }
                    }
                    catch (TimeoutException)
                    {
                        OnStatusChanged(EmergencyStatus.Off);
                    }
                    catch (Exception ex)
                    {
                        OnStatusChanged(EmergencyStatus.Error, ex);
                    }
                }
                catch (Exception ex)
                {
                    OnStatusChanged(EmergencyStatus.Error, ex);
                }
                finally
                {
                    try
                    {
                        serial.Dispose();
                        _busy = false;
                    }
                    catch { }
                }
            }
        }
    }
}