using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.IO;
using System.ComponentModel;
using System.Diagnostics;
using System.Data;
using System.Threading;
using System.Collections.Specialized;
using System.Web;
using System.Xml;

namespace Fusion_Control_Centre_UberMDX
{
    public static class RemoteControlClass
    {
        //static const int MAX_CLIENTS = 10;
        public static bool Remote_MasterEnable = false;
        public static bool Remote_web_not_pc = true;
        private static bool NeedToUpdateMySQL = false;

        public static int _port;
        public static string _userName;

        //public AsyncCallback pfnWorkerCallBack;
        //private Socket m_mainSocket;
        //private Socket[] m_workerSocket = new Socket[10];
        //private int m_clientCount = 0;
        //private static string received_data_string = "";
        private static string SECURITY_TOCLIENT = "";
        private static string SECURITY_FROMCLIENT = "";
        private static char[] SECURITY_CHOOSE_FROM_ARRAY = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };

        private static IPAddress localaddr = IPAddress.Parse("0.0.0.0");
        private static TcpListener listener;

        private static Thread THREAD_REMOTE_CONTROL;
        private static MainMDX _MyMommy;

        public class SocketPacket
        {
            public System.Net.Sockets.Socket m_currentSocket;
            public byte[] dataBuffer = new byte[1];
        }

        public static void InitializeRemoteControl(MainMDX Mommy)
        {
            try
            {
                _MyMommy = Mommy;
                //return; //Until Details are ironed out...
                MainMDX.MDX_DebugLogging("Updating Server Information");
                if (Remote_web_not_pc)
                {
                    SECURITY_TOCLIENT = GenerateSecurityString(42);
                }
                THREAD_REMOTE_CONTROL = new Thread(InitializeRemoteControlTHREAD);
                THREAD_REMOTE_CONTROL.IsBackground = true;
                THREAD_REMOTE_CONTROL.Start();
            }
            catch (Exception)
            {
                return;
            }
        }

        private static void InitializeRemoteControlTHREAD()
        {
            try
            {
                if (Remote_UpdateSQL())
                {
                    MainMDX.MDX_DebugLogging("Successfully Connected to MySQL Server");
                    _MyMommy.FormClosing += new FormClosingEventHandler(Mommy_FormClosing);
                    MainMDX.DoneChangingOutputState += new MainMDX.Delegate_DoneChangingOutputState(Mommy_DoneChangingOutputState);
                    MainMDX.MDX_DebugLogging("Start Listening on port " + _port.ToString());
                    //Remote_StartTCP();
                    Remote_Initialize_Threads();
                }
                else
                {
                    Thread.Sleep(300000);
                    InitializeRemoteControlTHREAD();
                }
            }
            catch (Exception e)
            {
                Thread.Sleep(300000);
                InitializeRemoteControlTHREAD();
            }
        }

        private static void Mommy_DoneChangingOutputState()
        {
            if (NeedToUpdateMySQL)
            {
                if (Remote_UpdateSQL())
                {
                    NeedToUpdateMySQL = false;
                }
            }
        }

        #region Index of Channel with Brain
        private static int IndexOfChannelWithBrain(MainMDX.Channel inputChannel)
        {
            for (int i = 0; i < MainMDX.AllBrains.Count; i++)
            {
                if (MainMDX.AllBrains[i].humanName.ToLower() == inputChannel.BrainID.ToLower())
                {
                    return i;
                }
            }
            return -1;
        }
        #endregion

        #region Remote Update SQL
        public static bool Remote_UpdateSQL()
        {
            if (!Remote_web_not_pc)
            {
                //Using a remote computer connection not a web interface
                return true;
            }
            string myUserName = _userName;
            string myIP = GetIP();
            string myPort = _port.ToString();
            string myBrainNameList = ""; foreach (MainMDX.BrainID _brain in MainMDX.AllBrains) { myBrainNameList += _brain.humanName + ";;"; }
            string myDigitalOutputNameList = "", myDigitalOutputPortList = "", myDigitalOutputValueList = "";
            foreach (MainMDX.DigitalOutputChannel _doc in MainMDX.AllDigitalOutputs)
            {
                myDigitalOutputNameList += _doc.id + ";;";
                myDigitalOutputPortList += IndexOfChannelWithBrain((MainMDX.Channel)_doc).ToString() + "." + _doc.Port.ToString() + ";;";
                if (_doc.CurrentEnabledState) { myDigitalOutputValueList += "1;;"; } else { myDigitalOutputValueList += "0;;"; }
            }
            string myAnalogueInputNameList = "", myAnalogueInputPortList = "", myAnalogueInputValueList = "";
            foreach (MainMDX.AnalogueInputChannel _aic in MainMDX.AllAnalogueInputs)
            {
                myAnalogueInputNameList += _aic.id + ";;";
                myAnalogueInputPortList += IndexOfChannelWithBrain((MainMDX.Channel)_aic).ToString() + "." + _aic.Port.ToString() + ";;";
                myAnalogueInputValueList += FormatNumberToString(_aic.CurrentValue, 2) + ";;";
            }
            string myVariableNameList = "", myVariableValueList = "";
            foreach (MainMDX.Variable _var in MainMDX.AllVariables)
            {
                myVariableNameList += _var.variableReferenceName + ";;";
                myVariableValueList += FormatNumberToString(_var.variableValue, 2) + ";;";
            }

            const string _baseURL = "https://www.fusioncontrolcentre.com/tcp/tcp_update_server.php";
            string _userConfigString = _baseURL + "?" + 
                "user_name=" + myUserName + 
                "&ip=" + myIP + 
                "&port=" + myPort +
                "&brains_number=" + MainMDX.AllBrains.Count.ToString() +
                "&brains_name=" + myBrainNameList +
                "&dout_number=" + MainMDX.AllDigitalOutputs.Count.ToString() +
                "&dout_name=" + myDigitalOutputNameList + 
                "&dout_port=" + myDigitalOutputPortList + 
                "&dout_value=" + myDigitalOutputValueList +
                "&ain_number=" + MainMDX.AllAnalogueInputs.Count.ToString() +
                "&ain_name=" + myAnalogueInputNameList +
                "&ain_port=" + myAnalogueInputPortList + 
                "&ain_value=" + myAnalogueInputValueList +
                "&var_name=" + myVariableNameList +
                "&var_value=" + myVariableValueList +
                //"&current_state=" + TCP_CurrentStateStringGenerator() + 
                "&security=" +  SECURITY_TOCLIENT;
            WebRequest TCP_WebRequest = WebRequest.Create(_userConfigString);
            System.Text.StringBuilder TCP_StringBuilder = new System.Text.StringBuilder();
            try
            {
                StreamReader TCP_ReceivedStream = new StreamReader(TCP_WebRequest.GetResponse().GetResponseStream());
                string temp_TCP_ReadLine;
                while ((temp_TCP_ReadLine = TCP_ReceivedStream.ReadLine()) != null)
                {
                    if (temp_TCP_ReadLine.Length > 0)
                    {
                        TCP_StringBuilder.Append(temp_TCP_ReadLine);
                    }
                }
                TCP_ReceivedStream.Close();
            }
            catch (WebException _we)
            {

            }
            string TCP_ReturnedString = TCP_StringBuilder.ToString();
            if (TCP_ReturnedString.Contains("###SEC###"))
            {
                string _passbacksecurity = TCP_ReturnedString.Substring(TCP_ReturnedString.IndexOf("###SEC###") + "###SEC###".Length);
                if (_passbacksecurity.Contains("###SEC###"))
                {
                    _passbacksecurity = _passbacksecurity.Substring(0, _passbacksecurity.IndexOf("###SEC###"));
                    int _tempSecurityPass = -1;
                    if (int.TryParse(_passbacksecurity, out _tempSecurityPass))
                    {
                        SECURITY_FROMCLIENT = _passbacksecurity;
                    }
                }
            }
            int _CODE = -1;
            if (TCP_ReturnedString.Contains("###CODE###"))
            {
                string _passbackcode = TCP_ReturnedString.Substring(TCP_ReturnedString.IndexOf("###CODE###") + "###CODE###".Length);
                if (_passbackcode.Contains("###CODE###"))
                {
                    _passbackcode = _passbackcode.Substring(0, _passbackcode.IndexOf("###CODE###"));
                    int _tempCode = -1;
                    if (int.TryParse(_passbackcode, out _tempCode))
                    {
                        _CODE = _tempCode;
                    }
                }
            }
            if (SECURITY_FROMCLIENT == "")
            {
                return false;
            }
            if (_CODE != 1)
            {
                return false;
            }
            //Evaluate Returned String
            return true;
        }
        #endregion

        #region Remote_StartTCP OLD
        /*
        public void Remote_StartTCP()
        {
            try
            {
                // Create the listening socket...
                m_mainSocket = new Socket(AddressFamily.InterNetwork,
                                          SocketType.Stream,
                                          ProtocolType.Tcp);
                IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, _port);
                // Bind to local IP Address...
                m_mainSocket.Bind(ipLocal);
                // Start listening...
                m_mainSocket.Listen(4);
                // Create the call back for any client connections...
                m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);

            }
            catch (SocketException se)
            {
                MessageBox.Show(se.Message);
            }
        }
        */
        #endregion

        #region Remote Initialize Threads
        private static void Remote_Initialize_Threads()
        {
            //Thread send = new Thread(Remote_sendThread);
            //send.Start();

            Thread read = new Thread(Remote_readThread);
            read.IsBackground = true;
            read.Start();
        }
        #endregion

        private static void Remote_readThread()
        {
            listener = new TcpListener(localaddr, _port);
            listener.Start();

            while (true)
            {
                Socket sock = listener.AcceptSocket();
                if (sock.Connected)
                {
                    listener.Stop();
                    NetworkStream stream = new NetworkStream(sock);
                    StreamReader instream = new StreamReader(stream);

                    string request = instream.ReadLine();
                    string[] srequest = request.Split(' ');

                    if (srequest[0].CompareTo("GET") == 0)
                    {
                        string query = srequest[1];

                        if (query.StartsWith("/"))
                            query = query.Substring(1);

                        /*
                        NameValueCollection qcoll = HttpUtility.ParseQueryString(query);
                        string msg = "<" + qcoll["n"] + "> " + qcoll["m"] + "\n";
                        cur.WPrintW(cmdwin, msg);
                        */    
                        MessageBox.Show(query);
                        Remote_CheckString(query);
                        listener = new TcpListener(localaddr, _port);
                        listener.Start();
                    }
                    
                    //cur.Refresh();
                    //cur.WRefresh(cmdwin);
                    sock.Close();
                }
            }
        }

        /*
        private static void Remote_sendThread()
        {
            while (true)
            {
                cur.WClear(inputwin);
                cur.MVWPrintW(inputwin, 0, 0, ">> ");
                cur.Refresh();
                string str = cur.MVWGetStr(inputwin, 0, 3);
                if (str == "exit")
                {
                    logout();
                    break;
                }
                send(str);
                cur.WRefresh(cmdwin);
            }

            cur.EndWin();
        }
        */

        #region On Client Connect OLD
        /*
        public void OnClientConnect(IAsyncResult asyn)
        {
            try
            {
                m_workerSocket[m_clientCount] = m_mainSocket.EndAccept(asyn);
                WaitForData(m_workerSocket[m_clientCount]);
                m_clientCount = 1;
                m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
            }
            catch (ObjectDisposedException ode)
            {
                Console.WriteLine(ode.ToString());
            }
            catch (SocketException se)
            {
                Console.WriteLine(se.ToString());
            }
        }
        */
        #endregion

        #region Wait for Data OLD
        /*
        public void WaitForData(System.Net.Sockets.Socket soc)
        {
            try
            {
                if (pfnWorkerCallBack == null)
                {
                    pfnWorkerCallBack = new AsyncCallback(OnDataReceived);
                }
                SocketPacket theSocPkt = new SocketPacket();
                theSocPkt.m_currentSocket = soc;

                soc.BeginReceive(theSocPkt.dataBuffer, 0,
                                   theSocPkt.dataBuffer.Length,
                                   SocketFlags.None,
                                   pfnWorkerCallBack,
                                   theSocPkt);
            }
            catch (SocketException se)
            {
                MessageBox.Show(se.Message);
            }
        }
        */
        #endregion

        #region On Data Received OLD
        /*
        public void OnDataReceived(IAsyncResult asyn)
        {
            try
            {
                SocketPacket socketData = (SocketPacket)asyn.AsyncState;

                int iRx = 0;

                iRx = socketData.m_currentSocket.EndReceive(asyn);
                char[] chars = new char[iRx + 1];
                System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
                int charLen = d.GetChars(socketData.dataBuffer,
                                         0, iRx, chars, 0);
                System.String szData = new System.String(chars);
                
                received_data_string += szData;

                WaitForData(socketData.m_currentSocket);
                TCP_CheckString();
            }
            catch (ObjectDisposedException)
            {
            }
            catch (SocketException se)
            {
                MessageBox.Show("FUSION CONTROL CENTRE MDX:  " + se.Message);
            }
        }
        */
        #endregion

        #region TCP Send Message OLD
        /*
        private void TCP_SendMessage(string toSend)
        {
            string _EncryptedString = SECURITY_FROMCLIENT + toSend + SECURITY_TOCLIENT;
            try
            {
                Object objData = _EncryptedString;
                byte[] byData = System.Text.Encoding.ASCII.GetBytes(objData.ToString());
                for (int i = 0; i < m_clientCount; i++)
                {
                    if (m_workerSocket[i] != null)
                    {
                        if (m_workerSocket[i].Connected)
                        {
                            m_workerSocket[i].Send(byData);
                        }
                    }
                }

            }
            catch (SocketException se)
            {
                MessageBox.Show(se.Message);
            }
        }
        */
        #endregion

        #region Get Local IP Address
        private static string GetIP()
        {
            String strHostName = Dns.GetHostName();

            IPHostEntry iphostentry = Dns.GetHostByName(strHostName);

            String IPStr = "";
            foreach (IPAddress ipaddress in iphostentry.AddressList)
            {
                IPStr = ipaddress.ToString();
                return IPStr;
            }
            return IPStr;
        }
        #endregion

        #region Close Sockets OLD
        /*
        private void CloseSockets()
        {
            if (m_mainSocket != null)
            {
                m_mainSocket.Close();
            }
            for (int i = 0; i < m_clientCount; i++)
            {
                if (m_workerSocket[i] != null)
                {
                    m_workerSocket[i].Close();
                    m_workerSocket[i] = null;
                }
            }
        }
        */
        #endregion

        private static void Mommy_FormClosing(object sender, FormClosingEventArgs e)
        {
            //CloseSockets();
        }

        private static void Remote_CheckString(string toCheck)
        {
            if (!Remote_web_not_pc || (
                toCheck.Contains(SECURITY_FROMCLIENT) && 
                toCheck.Contains(SECURITY_TOCLIENT)))
            {
                int i_b = toCheck.IndexOf(SECURITY_TOCLIENT);
                int i_e = toCheck.IndexOf(SECURITY_FROMCLIENT);
                string doWithString = toCheck.Substring(i_b);
                if (i_e >= 0)
                {
                    doWithString = toCheck.Substring(i_b, i_e - i_b + SECURITY_FROMCLIENT.Length);
                }
                toCheck = "";
                //TCP_TranslateReceivedDoString(doWithString);
                //USB_InputSteps();
                //USB_OutputSteps();
                string doWithStringParsed = doWithString.Replace(SECURITY_TOCLIENT, "");
                doWithStringParsed = doWithStringParsed.Replace(SECURITY_FROMCLIENT, "");
                if (doWithStringParsed.StartsWith("%5D")) { doWithStringParsed = doWithStringParsed.Replace("%5D", ""); }
                if (doWithStringParsed.EndsWith("%5B")) { doWithStringParsed = doWithStringParsed.Replace("%5B", ""); }

                Remote_TranslateReceivedDoString(doWithStringParsed);
                Remote_UpdateSQL();

                //TCP_SendMessage(_SendBack);
                //MessageBox.Show("Received Remote Command: " + doWithStringParsed);
            }
            else if (toCheck.Contains(SECURITY_TOCLIENT))
            {
                if (Remote_web_not_pc)
                {
                    Remote_UpdateSQL();
                }
            }
        }

        private static void Remote_TranslateReceivedDoString(string input_do)
        {
            if (input_do.ToLower().StartsWith("update"))
            {
                return;
            }
            else
            {
                string _toDo = input_do.Replace("%7B", "{");
                _toDo = _toDo.Replace("%7D", "}");
                _toDo = _toDo.Replace("%28", "(");
                _toDo = _toDo.Replace("%29", ")");
                _toDo = _toDo.Replace("%26lt%3B", "<");
                _toDo = _toDo.Replace("%26gt%3B", ">");
                while (_toDo.IndexOf('{') >= 0 && _toDo.IndexOf('}') >= 0)
                {
                    string _parseThisTime = _toDo.Substring(_toDo.IndexOf('{'), _toDo.IndexOf('}') - _toDo.IndexOf('{'));
                    _toDo = _toDo.Remove(0, _parseThisTime.Length);
                    _parseThisTime = _parseThisTime.Replace("{", ""); _parseThisTime = _parseThisTime.Replace("}", "");
                    string _parens = _parseThisTime.Substring(_parseThisTime.IndexOf('(') + 1, _parseThisTime.IndexOf(')') - _parseThisTime.IndexOf('(') - 1);
                    _parseThisTime = _parseThisTime.Substring(0, _parseThisTime.IndexOf('('));
                    if (_parseThisTime == "DIGITAL_OUTPUTS")
                    {
                        string[] _doArray = (_parens.Replace("<", "")).Split(new char[] { '>' }, StringSplitOptions.RemoveEmptyEntries);
                        foreach (string _do in _doArray)
                        {
                            string[] _doToArray = _do.Split(new char[] { '.' });
                            int _brain = -1, _port = -1, _value = -1;
                            if (_doToArray.Length == 3 && int.TryParse(_doToArray[0], out _brain) && int.TryParse(_doToArray[1], out _port) && int.TryParse(_doToArray[2], out _value))
                            {
                                if (_brain < MainMDX.AllBrains.Count)
                                {
                                    foreach (MainMDX.DigitalOutputChannel _doc in MainMDX.AllDigitalOutputs)
                                    {
                                        if (_doc.BrainID.ToLower() == MainMDX.AllBrains[_brain].humanName.ToLower())
                                        {
                                            if (_doc.Port == _port)
                                            {
                                                MainMDX.LogicalVote _myVote = new MainMDX.LogicalVote();
                                                if (_value == 1)
                                                {
                                                    _myVote.MyLogicalOpinion = MainMDX.Vote_Opinion.OUI;
                                                }
                                                else
                                                {
                                                    _myVote.MyLogicalOpinion = MainMDX.Vote_Opinion.NON;
                                                }
                                                _myVote.MyLogicalPriority = MainMDX.Vote_Priority.HIGH_PRIORITY;
                                                _doc.ShouldIChangeState.Add(_myVote);
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (Remote_web_not_pc)
                {
                    NeedToUpdateMySQL = true;
                }
            }
        }

        #region TCP Current State String Generator OLD
        /*
        private string TCP_CurrentStateStringGenerator()
        {
            string _return = "";
            for (int i_b = 0; i_b < AllBrains.Count; i_b++)
            {
                _return += "{" + i_b + "[";
                for (int i_c = 0; i_c < AllDigitalOutputs.Count; i_c++)
                {
                    _return += "d" + AllDigitalOutputs[i_c].Port + "(";
                    if (AllDigitalOutputs[i_c].CurrentState)
                    {
                        _return += "1";
                    }
                    else
                    {
                        _return += "0";
                    }
                    _return += ")";
                }
                for (int i_c = 0; i_c < AllAnalogueInputs.Count; i_c++)
                {
                    _return += "a" + AllAnalogueInputs[i_c].Port + "(";
                    _return += AllAnalogueInputs[i_c].CurrentValue.ToString();
                    _return += ")";
                }
                _return += "]}";
            }
            return _return;
        }
        */
        #endregion

        #region Generate Security String
        private static string GenerateSecurityString(int length)
        {
            for (int i = 0; i < MainMDX.MDX_Random.Next(0, 250); i++) { MainMDX.MDX_Random.Next(); }

            string _return = "";
            for (int i = 0; i < length; i++)
            {
                _return += SECURITY_CHOOSE_FROM_ARRAY[(MainMDX.MDX_Random.Next(0, int.MaxValue) % (SECURITY_CHOOSE_FROM_ARRAY.Length - 1))].ToString();
            }
            return _return;
        }
        #endregion

        public static string FormatNumberToString(object input_object, int input_decimals)
        {
            double _varDbl = 0.0f;
            string returnString = "";
            if (input_object != null && double.TryParse(input_object.ToString(), out _varDbl))
            {
                returnString = _varDbl.ToString();
                if (returnString.Contains(".") && returnString.Substring(returnString.IndexOf('.')).Length - 1 > input_decimals)
                {
                    returnString = _varDbl.ToString().Substring(0, _varDbl.ToString().IndexOf('.'));
                    if (input_decimals > 0)
                    {
                        returnString += _varDbl.ToString().Substring(_varDbl.ToString().IndexOf('.'), 1 + input_decimals);
                    }
                }
                else
                {
                    returnString += ".";
                    returnString += "".PadRight(input_decimals, '0');
                }
            }
            else
            {
                returnString = input_object.ToString();
            }
            return returnString;
        }
    }


}