using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO.Ports;
using System.Windows.Forms;
using System.Threading;
using System.Text.RegularExpressions;
using FTD2XX_NET;

namespace ministream_control
{
    public partial class Form1 : Form
    {
        internal delegate void SerialDataReceivedEventHandlerDelegate(object sender, SerialDataReceivedEventArgs e);
        delegate void SetTextCallback(string text);
        System.Threading.Timer t;
        string InputData = String.Empty;
        string reply = String.Empty;

        private EventWaitHandle DataReceived = new EventWaitHandle(false, EventResetMode.AutoReset);    // Handle for data received events
        BackgroundWorker DataHandler = new BackgroundWorker();  // Second thread for processing data received

        UInt32 ftdiDeviceCount = 0;
        FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;

        // Create new instance of the FTDI device class
        FTDI myFtdiDevice = new FTDI();

        int powerShutdown = 0;
        int activeroute = 0;
        int activeUSB = 0;
        int calType = 0;
        bool com_closed = false;
        bool ftdi_inited = false;

        public Form1()
        {
            InitializeComponent();
            this.FormBorderStyle = FormBorderStyle.FixedDialog;
            //serialPort1.DataReceived += new System.IO.Ports.SerialDataReceivedEventHandler(port_DataReceived_1);
            t = new System.Threading.Timer(new TimerCallback(callback));
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            label2.MaximumSize = new Size(120, 0);
            label2.AutoSize = true;

            //Get_FTDI_connected();
            //   timer2.Interval = 500;
            //  timer2.Enabled = true;


            t.Change(0, 500);
        }
        void DataHandler_DoWork(object sender, DoWorkEventArgs e)
        {
            FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
            string readData;
            UInt32 numBytes = 0;

            // Loop forever
            for (; ; )
            {
                // Wait for a FT_EVENT_RXCHAR event
                if (DataReceived.WaitOne(100))
                {
                    // Find out how many bytes have been received
                    if ((ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytes)) != FTDI.FT_STATUS.FT_OK)
                    {
                        continue;
                    }

                    // Read the bytes out
                    if ((ftStatus = myFtdiDevice.Read(out readData, numBytes, ref numBytes)) != FTDI.FT_STATUS.FT_OK)
                    {
                        continue;
                    }
                   //handle  readData);
                }

                if (DataHandler.CancellationPending)
                    break;
            }
        }


        private async void Init_FTDI()
        {
            byte[] dataToWrite = new byte[1];
            dataToWrite[0] = 0x00;
            UInt32 numBytesWritten = 0;

            ftStatus = myFtdiDevice.OpenBySerialNumber("B"); //port B
            ftStatus = myFtdiDevice.SetBitMode(0xff, 0x1); //set async bitbang, all outputs
            ftStatus = myFtdiDevice.SetBaudRate(9600);
            dataToWrite[0] = 0x01; //set D0 to H (MCU reset)
            ftStatus = myFtdiDevice.Write(dataToWrite, 1, ref numBytesWritten); //set all pins on port B to 0

            myFtdiDevice.Close(); //Close port B

            ftStatus = myFtdiDevice.OpenBySerialNumber("D"); //port D
            ftStatus = myFtdiDevice.SetBitMode(0x37, 0x1); //set async bitbang
            ftStatus = myFtdiDevice.SetBaudRate(9600);
            dataToWrite[0] = 0x15;
            ftStatus = myFtdiDevice.Write(dataToWrite, 1, ref numBytesWritten); //set all pins on port D to 0

            myFtdiDevice.Close(); //close port D

            ftStatus = myFtdiDevice.OpenBySerialNumber("C"); //port C - actual UART
            ftStatus = myFtdiDevice.SetBaudRate(115200);
            ftStatus = myFtdiDevice.SetDataCharacteristics(
                FTDI.FT_DATA_BITS.FT_BITS_8,
                FTDI.FT_STOP_BITS.FT_STOP_BITS_1,
                FTDI.FT_PARITY.FT_PARITY_NONE);
            ftStatus = myFtdiDevice.SetTimeouts(0, 0);
          /*  // Start the received data thread
            if (!DataHandler.IsBusy)
                DataHandler.RunWorkerAsync();

            // Subscribe to FT_EVENT_RXCHAR events
            ftStatus = myFtdiDevice.SetEventNotification(FTDI.FT_EVENTS.FT_EVENT_RXCHAR, DataReceived);
            //ftStatus = myFtdiDevice.Write(dataToWrite, 1, ref numBytesWritten); */

            if (ftStatus != FTDI.FT_STATUS.FT_OK)
            {
                this.Invoke((Action)(() => { label2.Text = "Initializing board Error!"; }));
                this.Invoke((Action)(() => { label2.ForeColor = System.Drawing.Color.Red; }));
            }
            else
            {
                this.Invoke((Action)(() => { label2.Text = "LakeWest Emulator Initialized"; }));
                this.Invoke((Action)(() => { label2.ForeColor = System.Drawing.Color.Green; }));
            }

            ftdi_inited = true;
            t.Change(0, 500);
        }

        //separate backround timer thread
        private void callback(object state)
        {
            ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);

            if (ftStatus == FTDI.FT_STATUS.FT_OK && ftdiDeviceCount == 4)
            {
                if (!ftdi_inited)
                {
                    t.Change(0, 0xffff);
                    this.Invoke((Action)(() => { label2.Text = "Initializing..."; }));
                    this.Invoke((Action)(() => { label2.ForeColor = System.Drawing.Color.Green; }));

                    //Update();
                    //Thread.Sleep(2000);
                    Init_FTDI();
                }
            }
            else
            {
                this.Invoke((Action)(() => { label2.Text = "No LakeWest board found!"; }));
                this.Invoke((Action)(() => { label2.ForeColor = System.Drawing.Color.Red; }));
                ftdi_inited = false;
            }
        }

    /*    private async void Get_FTDI_connected() //ping FTDI driver
        {
            ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);

            if (ftStatus == FTDI.FT_STATUS.FT_OK && ftdiDeviceCount == 4)
            {
                if(!ftdi_inited)
                {
                    label2.Text = "Initializing...";
                    label2.ForeColor = System.Drawing.Color.Green;
                    Update();
                    Thread.Sleep(2000);
                    Init_FTDI();
                }
            }
            else
            {
                label2.Text = "No LakeWest board found!";
                label2.ForeColor = System.Drawing.Color.Red;
                ftdi_inited = false;
            }
        }
        */

        private async void refresh_USB_ADC()
        {
            for (int i = 0; i < 5; i++)
            {
                activeUSB = i;
                com_write("[getADC]{port:" + i.ToString() + "}\n");
                await Task.Delay(250);
            }
        }


        private async void button1_Click(object sender, EventArgs e)
        {

            for (int i = 0; i < 3; i++)
            {
                activeUSB = i;
                calType = 0;
                com_write("[setADCcal]{port:" + i.ToString() + ",type:0}\n");
                await Task.Delay(200);
                com_write("[getADCcal]{port:" + i.ToString() + ",type:0}\n");
                await Task.Delay(200);
            }

         /*   for (int i = 0; i < 3; i++)
            {
                activeUSB = i;

                calType = 0;
                com_write("[getADCcal]{port:" + i.ToString() + ",type:0}\n");
                await Task.Delay(300);
                calType = 1;
                com_write("[getADCcal]{port:" + i.ToString() + ",type:1}\n");
                await Task.Delay(300);
            } */

        }

        private void port_DataReceived_1(object sender, SerialDataReceivedEventArgs e)
        {
            dataReceived_callback();

        }

        private void dataReceived_callback()
        {
            InputData = serialPort1.ReadLine();
            if (InputData != String.Empty)
            {

                this.BeginInvoke(new SetTextCallback(SetText), new object[] { InputData });

            }
        }

        private void SetText(string text)
        {
            this.console.Text += text + "\n";
            decode_protocol(text);
        }

        private void com_write(string text)
        {
            string serial;
            UInt32 numBytesWritten = 0;

            myFtdiDevice.GetSerialNumber(out serial);

            if (serial != "C")
            {
                handle_closed_com();
            }
            else
            {
                this.console.Text += text;
                myFtdiDevice.Write(text, text.Length, ref numBytesWritten);
            }
        }

        private void handle_closed_com()
        {
            if (!com_closed)
            {
                MessageBox.Show("MiniStreamer not connected!");
                com_closed = true;
            }
        }

        private void decode_protocol(string input)
        {
            var regex = new Regex(@"\[(.*)\]\{(.*?)(:([-0-9]*))?(\,(.*?):([-0-9]*))?(\,(.*?):([-0-9]*))?(\,(.*?):([-0-9]*))?\}");

            var matches = regex.Matches(input);
            int param = 0;

            int voltage = 0; //3
            int power = 0; //9
            int current = 0; //6
            int portUSB = 0;
            int board_revision = 0;
            int firmware_version = 0;
            int board_type = 0;
            float voltage_float = 0;


            switch (matches[0].Groups[1].Value)
            {
                case "pushBoardVersion":
                    if (!int.TryParse(matches[0].Groups[4].Value, out board_revision)) { }
                    if (!int.TryParse(matches[0].Groups[7].Value, out firmware_version)) { }
                    if (!int.TryParse(matches[0].Groups[10].Value, out board_type)) { }
                    float fw_version = (float)firmware_version / 100;
                    float brd_version = (float)board_revision / 10;
                    label27.Text = "v" + fw_version.ToString();
                    label26.Text = "A" + brd_version.ToString();
                    switch(board_type)
                    {
                        case 0: label25.Text = "LW Mini"; break;
                        case 1: label25.Text = "ProJect"; break;
                        case 2: label25.Text = " Stack "; break;
                    }


                    break;
                case "pushUSB":
                    if (!int.TryParse(matches[0].Groups[4].Value, out param)) { }

                    if (param == 1)
                    {
                        radioButton1.Checked = false;
                        radioButton2.Checked = true;
                    }
                    else
                    {
                        radioButton1.Checked = true;
                        radioButton2.Checked = false;
                    }

                    if (!int.TryParse(matches[0].Groups[7].Value, out param)) { }

                    powerShutdown = param;
                    if (param == 1)
                    {
                        radioButton4.Checked = false;
                        radioButton3.Checked = true;
                    }
                    else
                    {
                        radioButton4.Checked = true;
                        radioButton3.Checked = false;
                    }

                    break;
                case "pushADC":

                    if (!int.TryParse(matches[0].Groups[4].Value, out portUSB)) { }
                    if (!int.TryParse(matches[0].Groups[7].Value, out voltage)) { }
                    if (!int.TryParse(matches[0].Groups[10].Value, out current)) { }
                    voltage_float = (float) voltage;
                    voltage_float /= 100;
                    switch (portUSB)
                    {
                        case 0:
                            label_v0.Text = voltage_float.ToString() + "V";
                            label_c0.Text = current.ToString() + "mA";
                            break;
                        case 1:
                            label_v1.Text = voltage_float.ToString() + "V";
                            label_c1.Text = current.ToString() + "mA";
                            break;
                        case 2:
                            label_v2.Text = voltage_float.ToString() + "V";
                            label_c2.Text = current.ToString() + "mA";
                            break;
                        case 3:
                            label1.Text = voltage_float.ToString() + "V";
                            label11.Text = current.ToString() + "mA";
                            break;
                        case 4:
                            label12.Text = voltage_float.ToString() + "V";
                            break;
                    }
                    break;
                case "pushADCcal":
                    if(matches[0].Groups[2].Value == "confirmCalibrationStart")
                    {
                        com_write("[replyADCcal]{y}\n");
                    }
                    else
                    {
                        if (int.TryParse(matches[0].Groups[4].Value, out param))
                        {
                            if (calType == 0)
                            {
                                switch (activeUSB)
                                {
                                    case 0: label_calO0.Text = param.ToString(); break;
                                    case 1: label_calO1.Text = param.ToString(); break;
                                    case 2: label_calO2.Text = param.ToString(); break;
                                }
                            }
                            else
                            {
                                param *= 2;
                                switch (activeUSB)
                                {
                                    case 0: label_calI0.Text = param.ToString() + "mR"; break;
                                    case 1: label_calI1.Text = param.ToString() + "mR"; break;
                                    case 2: label_calI2.Text = param.ToString() + "mR"; break;
                                }
                            }
                        }
                    }
                    break;
                case "pushADCfactory":
                    if (matches[0].Groups[2].Value == "confirmCalibrationDefaults")
                    {
                        com_write("[replyADCfactory]{y}\n");
                    }
                    break;
                case "pushADCdefaults":
                    if (!int.TryParse(matches[0].Groups[4].Value, out voltage)) { }
                    if (!int.TryParse(matches[0].Groups[7].Value, out current)) { }
                    current *= 2;
                    switch (activeUSB)
                    {
                        case 0:
                            label_cal_fO0.Text = voltage.ToString();
                            label_cal_fI0.Text = current.ToString() + "mR";
                            break;
                        case 1:
                            label_cal_fO1.Text = voltage.ToString();
                            label_cal_fI1.Text = current.ToString() + "mR";
                            break;
                        case 2:
                            label_cal_fO2.Text = voltage.ToString();
                            label_cal_fI2.Text = current.ToString() + "mR";
                            break;
                    }
                    break;
            }
        }

        private void timer1_Tick(object sender, EventArgs e) //1s timer
        {
            refresh_USB_ADC();

        }

        private void timer2_Tick(object sender, EventArgs e) //500ms timer
        {
            //Get_FTDI_connected();
        }

        private void label1_Click(object sender, EventArgs e)
        {

        }

        private void label7_Click(object sender, EventArgs e)
        {

        }

        private void label22_Click(object sender, EventArgs e)
        {

        }

        private void button9_Click(object sender, EventArgs e) //refresh usb values
        {
            refresh_USB_ADC();
        }

        private void button10_Click(object sender, EventArgs e) //force bootloader
        {
            com_write("[setBoot]{boot:1}\n");
        }

        private void button11_Click(object sender, EventArgs e) //power off the unit
        {
            com_write("[setTurnOff]{cmd:1}\n");
        }

        private void radioButton1_CheckedChanged(object sender, EventArgs e) //CM3
        {

            if(radioButton1.Checked)
            {
                com_write("[setUSB]{activeRoute:0,powerShutdown:" + powerShutdown.ToString() + "}\n");
                activeroute = 0;
            }
            else
            {
                com_write("[setUSB]{activeRoute:1,powerShutdown:" + powerShutdown.ToString() + "}\n");
                activeroute = 1;
            }
        }

        private void button12_Click(object sender, EventArgs e)
        {
            console.Clear();
        }

        private void radioButton4_CheckedChanged(object sender, EventArgs e) //POWER ON
        {
            if (radioButton4.Checked)
            {
                powerShutdown = 0;
            }
            else
            {
                powerShutdown = 1;
            }
            com_write("[setUSB]{activeRoute:" + activeroute.ToString() + ",powerShutdown:" + powerShutdown.ToString() + "}\n");
        }

        private void radioButton3_CheckedChanged(object sender, EventArgs e) //POWER OFF
        {
            if (radioButton4.Checked)
            {
                powerShutdown = 0;
            }
            else
            {
                powerShutdown = 1;
            }
            com_write("[setUSB]{activeRoute:" + activeroute.ToString() + ",powerShutdown:" + powerShutdown.ToString() + "}\n");
        }

        private void radioButton2_CheckedChanged(object sender, EventArgs e) //DAC
        {
            if (radioButton1.Checked)
            {
                com_write("[setUSB]{activeRoute:0,powerShutdown:" + powerShutdown.ToString() + "}\n");
                activeroute = 0;
            }
            else
            {
                com_write("[setUSB]{activeRoute:1,powerShutdown:" + powerShutdown.ToString() + "}\n");
                activeroute = 1;
            }
        }

        private async void button4_Click(object sender, EventArgs e) //calibrate USB DAC
        {
            com_write("[setADCcal]{port:0,type:1}\n");
            await Task.Delay(300);
            com_write("[getADCcal]{port:0,type:1}\n");
            calType = 1;
            activeUSB = 0;
        }

        private async void button5_Click(object sender, EventArgs e)
        {
            com_write("[setADCcal]{port:1,type:1}\n");
            await Task.Delay(300);
            com_write("[getADCcal]{port:1,type:1}\n");
            calType = 1;
            activeUSB = 1;
        }

        private async void button6_Click(object sender, EventArgs e)
        {
            com_write("[setADCcal]{port:2,type:1}\n");
            await Task.Delay(300);
            com_write("[getADCcal]{port:2,type:1}\n");
            calType = 1;
            activeUSB = 2;
        }

        private async void button7_Click(object sender, EventArgs e)
        {
            DialogResult dialogResult = MessageBox.Show("Are you sure you want to set new calibration factory defaults?", "Factory Defaults", MessageBoxButtons.YesNo);

            if (dialogResult == DialogResult.Yes)
            {
                com_write("[setADCfactory]{lake768}\n");
                await Task.Delay(500);

                for (int i = 0; i < 3; i++)
                {
                    activeUSB = i;
                    com_write("[getADCdefaults]{port:" + i.ToString() + "}\n");
                    await Task.Delay(300);
                }
                for (int i = 0; i < 3; i++)
                {
                    activeUSB = i;
                    com_write("[getADCdefaults]{port:" + i.ToString() + "}\n");
                    await Task.Delay(300);
                }
            }
        }

        private async void button8_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < 3; i++)
            {
                activeUSB = i;

                com_write("[setADCdefaults]{port:" + i.ToString() + "}\n");
                await Task.Delay(300);

            }
            for (int i = 0; i < 3; i++)
            {
                activeUSB = i;
                calType = 0;
                com_write("[getADCcal]{port:" + activeUSB.ToString() + ",type:0}\n");
                await Task.Delay(300);
                calType = 1;
                com_write("[getADCcal]{port:" + activeUSB.ToString() + ",type:1}\n");
                await Task.Delay(300);
            }
            for (int i = 0; i < 3; i++)
            {
                activeUSB = i;
                calType = 0;
                com_write("[getADCcal]{port:" + activeUSB.ToString() + ",type:0}\n");
                await Task.Delay(300);
                calType = 1;
                com_write("[getADCcal]{port:" + activeUSB.ToString() + ",type:1}\n");
                await Task.Delay(300);
            }
        }

        private void checkBox1_CheckedChanged(object sender, EventArgs e)
        {
            if(checkBox1.Checked)
            {
                timer1.Interval = 1500;
                timer1.Enabled = true;
            }
            else
            {
                timer1.Enabled = false;
            }
        }

        private void label_calI0_Click(object sender, EventArgs e)
        {

        }

        private async void button14_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < 3; i++)
            {
                activeUSB = i;
                calType = 0;
                com_write("[getADCcal]{port:" + activeUSB.ToString() + ",type:0}\n");
                await Task.Delay(300);
                calType = 1;
                com_write("[getADCcal]{port:" + activeUSB.ToString() + ",type:1}\n");
                await Task.Delay(300);
            }
            for (int i = 0; i < 3; i++)
            {
                activeUSB = i;
                calType = 0;
                com_write("[getADCcal]{port:" + activeUSB.ToString() + ",type:0}\n");
                await Task.Delay(300);
                calType = 1;
                com_write("[getADCcal]{port:" + activeUSB.ToString() + ",type:1}\n");
                await Task.Delay(300);
            }
        }

        private async void button13_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < 3; i++)
            {
                activeUSB = i;
                com_write("[getADCdefaults]{port:" + activeUSB.ToString() + "}\n");
                await Task.Delay(300);
            }

            for (int i = 0; i < 3; i++)
            {
                activeUSB = i;
                com_write("[getADCdefaults]{port:" + activeUSB.ToString() + "}\n");
                await Task.Delay(300);
            }
        }

        private void console_TextChanged(object sender, EventArgs e)
        {

            // set the current caret position to the end
            console.SelectionStart = console.Text.Length;
            // scroll it automatically
            console.ScrollToCaret();

        }

        private void label11_Click(object sender, EventArgs e)
        {

        }

        private void label16_Click(object sender, EventArgs e)
        {

        }

        private async void button15_Click(object sender, EventArgs e)
        {
            com_write("[getBoardVersion]{}\n");
        }

        private void label9_Click(object sender, EventArgs e)
        {

        }

        private void label20_Click(object sender, EventArgs e)
        {

        }

        private void groupBox19_Enter(object sender, EventArgs e)
        {

        }

        private void label24_Click(object sender, EventArgs e)
        {

        }

        private void label25_Click(object sender, EventArgs e)
        {

        }

        /*    private void refresh_com_ports( )
    {
        string[] ArrayComPortsNames = null;
        int index = -1;
        string ComPortName = null;

       // comboBox1.Items.Clear();

        //Com Ports
        ArrayComPortsNames = SerialPort.GetPortNames();

        if(ArrayComPortsNames.Length > 0)
        {
            do
            {
                index += 1;
               // comboBox1.Items.Add(ArrayComPortsNames[index]);
            } while (!((ArrayComPortsNames[index] == ComPortName) ||
                    (index == ArrayComPortsNames.GetUpperBound(0))));

            Array.Sort(ArrayComPortsNames);

            if (index == ArrayComPortsNames.GetUpperBound(0))
            {
                ComPortName = ArrayComPortsNames[0];
            }

            //get first item print in text
            //comboBox1.Text = ArrayComPortsNames[0];
        }

    }
    private async void button3_Click(object sender, EventArgs e)
    {
        if (button3.Text == "Connect")
        {
            if(serialPort1.IsOpen)
            {
                serialPort1.Close();
            }

            try
            {
               // serialPort1.PortName = comboBox1.Text;
            }
            catch (ArgumentException)
            {
                MessageBox.Show("No COM selected.");
            }
            serialPort1.BaudRate = 115200;
            serialPort1.DataBits = 8;
            serialPort1.StopBits = (StopBits)Enum.Parse(typeof(StopBits), "One");
            serialPort1.Handshake = (Handshake)Enum.Parse(typeof(Handshake), "None");
            serialPort1.Parity = (Parity)Enum.Parse(typeof(Parity), "None");

            try
            {
                serialPort1.Open();
                button3.Text = "Disconnect";
                com_closed = false;
               /* refresh_USB_ADC();
                await Task.Delay(200);
                com_write("[getUSB]{}\n");
                await Task.Delay(200);
                refresh_calibration();
            }
            catch (UnauthorizedAccessException)
            {
                MessageBox.Show(serialPort1.PortName + " is probably already in use.");
            }
            catch (ArgumentOutOfRangeException)
            {
                MessageBox.Show(serialPort1.PortName + " port doesn't support 115200 baudrate.");
            }

        }
        else if (button3.Text == "Disconnect")
        {
            button3.Text = "Connect";
            serialPort1.Close();
        }
    }
    */


    }



    /*
    public class ProtocolMessage
    {
        public enum Command
        {
            pushUSB,
            pushADC,
            pushADCcal,
            pushADCdefaults,
            pushADCfactory,
            pushPowerStatus,
            pushBoot,
            pushTurnOff,
            pushBoardVersion
        }

        public Command cmd;

        private Dictionary<string, int> parameter_list;

        public ProtocolMessage(string message)
        {
            parameter_list = new Dictionary<string, int>();
            parseString(message);
        }

        public int this[string key]
        {
            get
            {
                return parameter_list[key];
            }

            set
            {
                parameter_list[key] = value;
            }
        }

        public string[] getNames()
        {
            return parameter_list.Keys.ToArray();
        }

        public int[] getValues()
        {
            return parameter_list.Values.ToArray();
        }

        public override string ToString()
        {
            string result = "[" + Enum.GetName(typeof(Command), cmd) + "]{";

            foreach (KeyValuePair<string, int> d in parameter_list)
            {
                result += d.Key + ":" + d.Value.ToString() + ",";

            }
            result = result.TrimEnd(',') + "}";
            return result;
        }

        private void parseString(string msg)
        {
            var res = msg.Split(new char[] { '{', '}', '[', ']' }, StringSplitOptions.RemoveEmptyEntries);//[pushADCdefaults]{offset:xxxx,senseR:80}  [pushADCfactory]{confirmCalibrationDefaults}

            if (res.Length <= 1)
                return;

            cmd = (Command)Enum.Parse(typeof(Command), res[0]);

            foreach (string s in res[1].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
            {
                var pram = s.Split(':');

                if (pram.Length > 1)
                    parameter_list.Add(pram[0], int.Parse(pram[1]));
                else
                    parameter_list.Add(pram[0], 0);

            }
        }
    } */
}