using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.IO.Ports;
using System.Windows.Forms;
using System.IO;

using System.Collections;
using NationalInstruments.DAQmx;
using System.Text.RegularExpressions;


//CodeProjectSerialComms program 
//23/04/2013   16:29

namespace CPFConsole
{
    public partial class Form1 : Form
    {
        public GlobalVars Globals = new GlobalVars();

        SerialPort ComPort = new SerialPort("COM1", 115200);

        internal delegate void SerialDataReceivedEventHandlerDelegate(object sender, SerialDataReceivedEventArgs e);
        internal delegate void SerialPinChangedEventHandlerDelegate(object sender, SerialPinChangedEventArgs e);
        //private SerialPinChangedEventHandler SerialPinChangedEventHandler1;
        delegate void SetTextCallback(string text);
        string InputData = String.Empty;

        private StreamWriter logFile;
        private DynamicModel dynamicModel;

        public Form1()
        {
            ComPort.Open();
            InitializeComponent();
            dynamicModel = new DynamicModel(this);
            CheckBoxToAutomate.Checked = true;

            InitLiveChart();

            //DAQ set up
            physicalChannelComboBox.Items.AddRange(DaqSystem.Local.GetPhysicalChannels(PhysicalChannelTypes.AO, PhysicalChannelAccess.External));
            if (physicalChannelComboBox.Items.Count > 0)
                physicalChannelComboBox.SelectedIndex = 0;

            //SerialPinChangedEventHandler1 = new SerialPinChangedEventHandler(PinChanged);
            ComPort.DataReceived += new System.IO.Ports.SerialDataReceivedEventHandler(port_DataReceived_1);

            using (var fbd = new FolderBrowserDialog())
            {
                System.Windows.Forms.MessageBox.Show("Select Folder for Data Log");
                DialogResult result = fbd.ShowDialog();

               // try
                {
                    //logFile = new StreamWriter("\\Pierre\\ConsoleData\\" + DateTime.Now.ToString("yyyyMMMddTHH-mm-ss"));
                    logFile = new StreamWriter(fbd.SelectedPath +"\\" + DateTime.Now.ToString("yyyyMMMddTHH-mm-ss"));
                }
                //catch (DirectoryNotFoundException)
                {
                  //  logFile = new StreamWriter("\\CPF\\Pierre\\ConsoleData\\" + DateTime.Now.ToString("yyyyMMMddTHH-mm-ss"));
                }
            }
        }



        #region Form Events
        private void port_DataReceived_1(object sender, SerialDataReceivedEventArgs e)
        {
            InputData = ComPort.ReadExisting();
            if (InputData != String.Empty)
            {
                try
                {
                    this.BeginInvoke(new SetTextCallback(SetText), new object[] { InputData });
                }
                catch (InvalidOperationException)
                { }
                //Catches Exception when data is received before window has been generated
            }
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            rtbDepthCommand.Text = "0";
            ComPort.Close();
            Console.Write("Closing ComPort");
            logFile.Flush();
            logFile.Close();
            //Application.Exit();
        }



        private void DepthCommandButton_Click(object sender, EventArgs e)
        {
            Cursor.Current = Cursors.WaitCursor;
            try
            {
                using (Task myTask = new Task())
                {
                    myTask.AOChannels.CreateCurrentChannel(
                        physicalChannelComboBox.Text,
                        "GenCurrent",
                        Convert.ToDouble(minValue.Text) * 0.001,
                        Convert.ToDouble(maxValue.Text) * 0.001,
                        AOCurrentUnits.Amps);

                    AnalogSingleChannelWriter myChannelWriter = new AnalogSingleChannelWriter(myTask.Stream);
                    myChannelWriter.WriteSingleSample(true, ((Convert.ToDouble(rtbDepthCommand.Text) * 1.45038 + 36.789) / 9.2927) * 0.001);
                    pressureCommand.Text = Convert.ToString(Math.Round(Convert.ToDouble(rtbDepthCommand.Text) * 1.45038, 2));

                }
            }
            catch (DaqException exception)
            {
                MessageBox.Show(exception.Message);
            }
            Cursor.Current = Cursors.Default;
        }

        private void beginDescent_Click(object sender, EventArgs e)
        {
            DescentSimulationTimer.Enabled = true;
            DescentSimulationTimer.Start();
            CheckBoxToAutomate.Checked = false;
        }

        private void stopDescent_Click(object sender, EventArgs e)
        {
            DescentSimulationTimer.Stop();
            CheckBoxToAutomate.Checked = false;
        }

        private void SimulateAscentButton_Click(object sender, EventArgs e)
        {
            AscentSimulationTimer.Enabled = true;
            AscentSimulationTimer.Start();
            CheckBoxToAutomate.Checked = false;
        }
        private void StopAscentButton_Click(object sender, EventArgs e)
        {
            AscentSimulationTimer.Stop();
            CheckBoxToAutomate.Checked = false;
        }

        private void DescentSimulationTimer_Tick(object sender, EventArgs e)
        {
            //called every 500 ms
            Cursor.Current = Cursors.WaitCursor;
            try
            {
                using (Task myTask = new Task())
                {
                    myTask.AOChannels.CreateCurrentChannel(
                        physicalChannelComboBox.Text,
                        "GenCurrent",
                        Convert.ToDouble(minValue.Text) * 0.001,
                        Convert.ToDouble(maxValue.Text) * 0.001,
                        AOCurrentUnits.Amps);

                    rtbDepthCommand.Text = Convert.ToString(Convert.ToDouble(rtbDepthCommand.Text) + ((Convert.ToDouble(rtbDescendRate.Text) / 100) / 2));
                    AnalogSingleChannelWriter myChannelWriter = new AnalogSingleChannelWriter(myTask.Stream);
                    myChannelWriter.WriteSingleSample(true, ((Convert.ToDouble(rtbDepthCommand.Text) * 1.45038 + 36.789) / 9.2927) * 0.001);
                    pressureCommand.Text = Convert.ToString(Math.Round(Convert.ToDouble(rtbDepthCommand.Text) * 1.45038, 2));

                }
            }
            catch (DaqException exception)
            {
                MessageBox.Show(exception.Message);
            }
            Cursor.Current = Cursors.Default;

        }

        private void AscentSimulationTimer_Tick(object sender, EventArgs e)
        {
            //called every 500 ms
            Cursor.Current = Cursors.WaitCursor;
            try
            {
                using (Task myTask = new Task())
                {
                    myTask.AOChannels.CreateCurrentChannel(
                        physicalChannelComboBox.Text,
                        "GenCurrent",
                        Convert.ToDouble(minValue.Text) * 0.001,
                        Convert.ToDouble(maxValue.Text) * 0.001,
                        AOCurrentUnits.Amps);

                    rtbDepthCommand.Text = Convert.ToString(Convert.ToDouble(rtbDepthCommand.Text) - ((Convert.ToDouble(rtbAscendRate.Text) / 100) / 2));
                    AnalogSingleChannelWriter myChannelWriter = new AnalogSingleChannelWriter(myTask.Stream);
                    myChannelWriter.WriteSingleSample(true, ((Convert.ToDouble(rtbDepthCommand.Text) * 1.45038 + 36.789) / 9.2927) * 0.001);
                    pressureCommand.Text = Convert.ToString(Math.Round(Convert.ToDouble(rtbDepthCommand.Text) * 1.45038, 2));

                }
            }
            catch (DaqException exception)
            {
                MessageBox.Show(exception.Message);
            }
            Cursor.Current = Cursors.Default;

        }

        private void rtbCPFState_TextChanged(object sender, EventArgs e)
        {
            try
            {
                if (rtbCPFState.Text == "Descend" && !(Convert.ToDouble(rtbCTDPressure.Text) >= Convert.ToDouble(rtbAnchorDepth.Text))) ;
                //beginDescent_Click(sender, e);

                else if (rtbCPFState.Text == "Anchor") ;
                //stopDescent_Click(sender, e);

                else if (rtbCPFState.Text == "Ascend") ;
                //SimulateAscentButton_Click(sender, e);

                else ;
                {
                    //stopDescent_Click(sender, e);
                    //StopAscentButton_Click(sender, e);
                }
            }
            catch(FormatException)
            { }
        }

        private void rtbDepthCommand_TextChanged(object sender, EventArgs e)
        {
            if (CheckBoxToAutomate.Checked == true) DepthCommandButton_Click(sender, e);

            try
            {
                Globals.GlobalModelPressure = Convert.ToDouble(rtbDepthCommand.Text);
            }
            catch (FormatException)
            { }
        }

        private void btnGo_Click(object sender, EventArgs e)
        {
            DepthCommandButton_Click(sender, e);
            ComPort.Write("$go\r\n");
        }

        private void btnRecoveryTrue_Click(object sender, EventArgs e)
        {
            ComPort.Write("$recoveryTrue\r\n");
        }

        private void btnRecoveryFalse_Click(object sender, EventArgs e)
        {
            ComPort.Write("$recoveryFalse\r\n");
        }

        private void btnSendExit_Click(object sender, EventArgs e)
        {
            ComPort.Write("$exit\r\n");
        }

        private void CheckBoxToAutomate_CheckedChanged(object sender, EventArgs e)
        {
            if (CheckBoxToAutomate.Checked == true)
            {
                DynamicModelTimer.Enabled = true;
                DynamicModelTimer.Start();
            }
            else
                DynamicModelTimer.Stop();
        }

        private void DynamicModelTimer_Tick(object sender, EventArgs e)
        {
            dynamicModel.CalculateBuoyantForce();
            //DepthCommandButton_Click(sender, e);
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }
        #endregion

        private void DataLogCheck_CheckedChanged(object sender, EventArgs e)
        {
            if (DataLogCheck.Checked == false)
                logFile.Flush();
        }
















    }
}