using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ElmoMotionControlComponents.Drive.EASComponents;
using System.ComponentModel;
using ElmoMotionControlComponents.Drive.EASComponents.Recording;
using System.Threading;
using ElmoMotionControlComponents.Drive.EASComponents.Personality;

namespace DriveDotNetRecording
{
    public class RecordingOperator
    {
        IDriveCommunication _communication;
        IDriveRecording _recordingObj;
        BackgroundWorker _recWaiting = null;
        public EventHandler RecordingCompleteEvent;
        RecordingData _recordingData = null;

        public RecordingOperator(IDriveCommunication communication)
        {
            _communication = communication;
        }

        public RecordingSetup SetupRecording()
        {
            Console.WriteLine("Building recording setup");
            RecordingSetup setup = new RecordingSetup();
            string response;
            if (!Utils.SendCommand(_communication, "TS", out response))
                return null;
            int tsVal = 0;
            if (!int.TryParse(response, out tsVal))
            {
                Console.WriteLine(string.Format("Error in TS value ({0})", response));
                return null;
            }
            setup.SamplingTime = tsVal;
            setup.TimeResolution = 4; // Gap between samples is 4 * TS
            setup.RecordingLength = 2000; // Record 2000 samples
            double resolutionTime = (double)(setup.TimeResolution * tsVal) / 1000;
            Console.WriteLine(string.Format("Drive TS = {0} usec, recording resolution = {1} msec and recording time = {2} sec", tsVal, resolutionTime, setup.RecordingDuration / 1000));

            TriggerSetup triggerSetup = new TriggerSetup();
            triggerSetup.TriggerMode = TriggerMode.Manual;
            Console.WriteLine("Please select trigger type: 1. Immediate, 2. Begin Motion (10% delay), 3. Velocity Rising Edge on 500 (15% delay)");
            int result = int.Parse(Console.ReadLine());
            switch (result)
            {
                case 1:
                    triggerSetup.SetupType = TriggerSetupType.Immediate;
                    break;
                case 2:
                    triggerSetup.SetupType = TriggerSetupType.Begin;
                    triggerSetup.Delay = 10;
                    break;
                case 3:
                    triggerSetup.SetupType = TriggerSetupType.Analog;
                    triggerSetup.TriggerSignal = _communication.PersonalityModel.SignalsMetaData[1]; // Velocity
                    triggerSetup.Delay = 15;
                    triggerSetup.SlopeType = TriggerSlope.Positive;
                    triggerSetup.High = 500;
                    break;
            }
            setup.TriggerSetup = triggerSetup;

            RecordingSignalSetup signalSetup = _communication.PersonalityModel.SignalsMetaData[1]; // Velocity
            setup.SignalData.Add(signalSetup);
            Console.WriteLine(string.Format("Adding signal {0} ({1}) to recording", signalSetup.SignalIndex, signalSetup.Name));
            signalSetup = _communication.PersonalityModel.SignalsMetaData[2]; // Position
            setup.SignalData.Add(signalSetup);
            Console.WriteLine(string.Format("Adding signal {0} ({1}) to recording", signalSetup.SignalIndex, signalSetup.Name));
            signalSetup = _communication.PersonalityModel.SignalsMetaData[10]; // Active Current
            setup.SignalData.Add(signalSetup);
            Console.WriteLine(string.Format("Adding signal {0} ({1}) to recording", signalSetup.SignalIndex, signalSetup.Name));

            return setup;
        }

        public bool StartRecording()
        {
            RecordingSetup setup = SetupRecording();
            if (setup == null)
            {
                Console.WriteLine("Failed to setup recording, aborting");
                return false;
            }
            _recordingObj = _communication.GetRecordingObject();
            try
            {
                if (!_recordingObj.ConfigureRecording(setup))
                    return false;
            }
            catch (RecorderAPIException rex)
            {
                Console.WriteLine("Failed to setup recording, aborting. Got Exception " + rex.Message);
                return false;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed to setup recording, aborting. Got Exception " + ex.Message);
                return false;
            }

            if (!_recordingObj.StartRecording())
            {
                Console.WriteLine("Failed to start recording, aborting");
                return false;
            }

            InitRecordingWorker();

            return BeginMotion();
        }

        void InitRecordingWorker()
        {
            if (_recWaiting == null)
            {
                _recWaiting = new BackgroundWorker();
                _recWaiting.DoWork += WaitForRecodingFinish;
                _recWaiting.WorkerSupportsCancellation = true;
                _recWaiting.RunWorkerCompleted += RecordingComplete;
                _recWaiting.WorkerReportsProgress = true;
                _recWaiting.ProgressChanged += RecordingProgressChanged;
            }

            _recWaiting.RunWorkerAsync(this);
        }

        bool BeginMotion()
        {
            string response;
            if (!Utils.SendCommand(_communication, "PX=0", out response))
                return false;
            if (!Utils.SendCommand(_communication, "UM=5", out response))
                return false;
            if (!Utils.MotorEnable(_communication, true))
                return false;
            if (!Utils.SendCommand(_communication, "AC=1e7", out response))
                return false;
            if (!Utils.SendCommand(_communication, "DC=1e7", out response))
                return false;
            if (!Utils.SendCommand(_communication, "SP=1e5", out response))
                return false;
            if (!Utils.SendCommand(_communication, "PR=1e5", out response))
                return false;
            if (!Utils.SendCommand(_communication, "BG", out response))
                return false;

            return true;
        }

        private void WaitForRecodingFinish(object sender, DoWorkEventArgs e)
        {
            try
            {
                BackgroundWorker worker = sender as BackgroundWorker;
                RecordingStatus status = RecordingStatus.RWait;
                do
                {
                    status = _recordingObj.GetRecordingStatus();

                    switch (status)
                    {
                        case RecordingStatus.RWait:
                            Console.WriteLine("Waiting for trigger...");
                            break;
                        case RecordingStatus.RProgress:
                            Console.WriteLine("Recording in progress...");
                            break;
                        case RecordingStatus.ROff:
                            Console.WriteLine("Recording stopped or error");
                            return;
                    }
                    Thread.Sleep(500);
                } while (status != RecordingStatus.REnd);

                Console.WriteLine("Recording completed, uploading data...");

                _recordingData = _recordingObj.UploadRecordingData();
                if (_recordingData != null)
                {
                    Console.WriteLine("Uploading data success");
                    foreach (var item in _recordingData.Data)
                    {
                        Console.WriteLine("Signal "+item.Key+" has "+item.Value.Length+ " data values");
                    }
                }
                else
                {
                    Console.WriteLine("Uploading data error");
                }
            }
            catch (RecorderAPIException rex)
            {
                Console.WriteLine("Recording failed, Exception received: " + rex.Message);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Recording failed, Exception received: " + ex.Message);
            }
        }

        private void RecordingProgressChanged(object sender, ProgressChangedEventArgs e)
        {
        }

        public void RecordingComplete(Object sender, RunWorkerCompletedEventArgs e)
        {
            if (RecordingCompleteEvent != null)
                RecordingCompleteEvent(this, EventArgs.Empty);
        }
    }
}