using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MotoTRBO_GW;
using System.Net.Sockets;
using SafeMobileLib;
using System.Net;
using System.Threading;
using System.Diagnostics;

namespace MotoTrbo_GW
{
    class SMSSendThread
    {
        private byte WAIT_SMS_SEC = 5;              // max no of seconds to wait for SMS ack
        private int MAX_SMS_SIZE = 140;       // max SMS allowed size
        private Int32 smsPort = 0;
        private String mIP;
        private Int32 mPort;

        int sms_seq_id;
        public UdpClient udpClientSMS = null;
        private UdpMulticast udpMulticastBusConnection = null;

        public static List<String> acknowledgedMessagesSeqNo = new List<string>();

        /* Send sms thread worker and queue */
        private Thread SendSMSThreadobj;
        private static InterthreadMessageQueue<String> sendSMSQueue = new InterthreadMessageQueue<String>();

        public DBsmsManager DBSms = null;

        public SMSSendThread(Int32 port, String multicastID, String multicastPort)
        {
            // register for the event when a message needs to be removed from the ACK queue 
            // because we need a new seqID for sending a new message
            SMSConfirm.OnRemoveFromQueue += delegate (Int32 radioID, string seqNo)
            {
                SafeMobileLib.Utils.WriteLine("OnRemoveFromQueue", ConsoleColor.Red, ConsoleType.SMS);

                // encode a fake ack message
                System.Text.Encoding enc = System.Text.Encoding.ASCII;
                byte[] buf = enc.GetBytes(SMSReceiveThread.GetAck4MessagebusForSequence(seqNo + ""));

                //send SMS ack
                udpMulticastBusConnection.Send(buf, buf.Length);

                // add message to the acknowledged ones
                SMSSendThread.acknowledgedMessagesSeqNo.Add(seqNo);
            };

            smsPort = port;
            mIP = multicastID;
            mPort = Int32.Parse(multicastPort);

            SendSMSThreadobj = new Thread(new ThreadStart(SendSMSWorker));
            SendSMSThreadobj.IsBackground = true;
            SendSMSThreadobj.Start();
        }

        public void handleConnection()
        {
            SafeMobileLib.Utils.WriteLine("SMSSend Thread started", ConsoleType.SMS);
            try
            {
                udpClientSMS = new UdpClient();
                udpClientSMS.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                udpClientSMS.Client.Bind(new IPEndPoint(IPAddress.Any, smsPort));
            }
            catch (Exception ex)
            {
                SafeMobileLib.Utils.WriteLine("SMSSendThread handleConnection exception while creating udpClient: " + ex.ToString(), ConsoleColor.Red, ConsoleType.SMS);
            }

            try
            {
                udpMulticastBusConnection = new UdpMulticast(mIP, mPort);
                udpMulticastBusConnection.OnNewDataRecv += new UdpMulticast.newData4Send(udp_OnNewDataReceived);
                udpMulticastBusConnection.StartListen(Main.LocalIP);
                //SafeMobileLib.Utils.WriteLine("SMSSendThread successfully registered to multicast group");
            }
            catch (Exception ex)
            {
                SafeMobileLib.Utils.WriteLine("SMSSendThread exception while joining the multicast group: " + ex.ToString(), ConsoleColor.Red, ConsoleType.SMS);
            }
            while (true) 
            {
                Thread.Sleep(100);
            }
        }

        

        private void SendSMSWorker()
        {
            while (Program.isRunning)
            {
                try
                {
                    //MotoTRBOcmdMsg msg = MotoTRBOGW.locationQueue.GetItem(100);
                    String msg = sendSMSQueue.GetItem(-1);//block until message is in queue
                    string opCode = "";
                    bool wasSent = DecodeMessageBusMsg(msg, out opCode);

                    // sleep only if sms and if it was sent
                    if (opCode.Equals((int)MessageBusCmds.SendSMSRequest + "") || opCode.Equals((int)MessageBusCmds.SendSMSRequest2 + "")
                            || opCode.Equals((int)MessageBusCmds.SendGroupSMSRequest + "") || opCode.Equals((int)MessageBusCmds.SendGroupSMSRequest2 + ""))
                    {
                        if (wasSent)
                        {
                            Thread.Sleep(Main.sms_sending_interval);  //minimum interval between SMS as per MotoTRBO specs is 1200
                            //SafeMobileLib.Utils.WriteLine("WAIT ", ConsoleColor.Red);
                        }
                        else
                            Thread.Sleep(1);
                    }
                    // don't need to sleep the thread more than 1 ms because the queue is blocking already 
                    else
                        Thread.Sleep(1);
                }
                catch (Exception ex)
                {
                    SafeMobileLib.Utils.WriteLine("SendSMSWorkerException: " + ex.ToString(), ConsoleType.SMS);
                }
            } // end while (true)
        }

        

        void udp_OnNewDataReceived(byte[] data, int dataLen)
        {
            bool shouldAddAgain = true;

            try
            {
                string str = Encoding.ASCII.GetString(data, 0, dataLen);

                //SafeMobileLib.Utils.WriteLine("RECEIVED " + str, ConsoleColor.Yellow);

                String[] tempArray = str.Trim().Split('#');
                if (tempArray.Length > 3)
                {

                    DecodeMessageBusMsg(str, out tempArray[3]);
                    /*

                    if (tempArray[3].Equals((int)MessageBusCmds.SendSMSRequest + "") || tempArray[3].Equals((int)MessageBusCmds.SendSMSRequest2 + ""))
                    {
                        // skip message if already acknowledged 
                        if (acknowledgedMessagesSeqNo.Contains(tempArray[2]))
                            return;

                        // get the radio imei and then parse the radioID
                        String IMEI = (tempArray[4].Split('.'))[2];
                        Int32 radioID = 0;
                        Int32.TryParse(IMEI, out radioID);

                        // add an entity into the smsConfirmation queue
                        if (!Main.smsConfirmForUnits.ContainsKey(radioID))
                            Main.smsConfirmForUnits.Add(radioID, new SMSConfirm(radioID));


                        // skip this message because it already exists in the sending queue
                        int nr_of_retries = Main.smsConfirmForUnits[radioID].GetNumberOfRetries(tempArray[2]);

                        bool exists = Main.smsConfirmForUnits[radioID].ExistsSequenceInQueue(tempArray[2]);
                        if (exists && nr_of_retries <= Main.number_of_retries)
                        {
                            shouldAddAgain = false;

                            //SafeMobileLib.Utils.WriteLine("MESSAGE [" + str + "] is waiting for ACK [" + nr_of_retries + "]", ConsoleColor.Yellow);
                        }
                        // send fake ack and remove it from the confirmation queue if send for more than number of retries
                        else if (exists && nr_of_retries > Main.number_of_retries)
                        {
                            shouldAddAgain = false;

                            // encode a fake ack message
                            System.Text.Encoding enc = System.Text.Encoding.ASCII;
                            byte[] buf = enc.GetBytes(SMSReceiveThread.GetAck4MessagebusForSequence(sms_seq_id + ""));

                            SafeMobileLib.Utils.WriteLine("MESSAGE [" + str + "] is expired [" + nr_of_retries + "]", ConsoleColor.DarkCyan, ConsoleType.SMS);

                            //send SMS ack
                            udpMulticastBusConnection.Send(buf, buf.Length);
                        }

                        // add message to queue
                        if (shouldAddAgain)
                        {
                            //SafeMobileLib.Utils.WriteLine("ADDED TO sendSMSQueue " + str, ConsoleColor.Blue);
                            sendSMSQueue.PostItem(str);
                        }
                        
                    }*/
                }


            }
            catch (Exception ex)
            {
                SafeMobileLib.Utils.WriteLine(ex.ToString());
            }
        }


        /// <summary>
        /// Decode a message received from the message bus
        /// </summary>
        /// <param name="msg"></param>
        private bool DecodeMessageBusMsg(String msg, out String opCode)
        {
            bool wasSent = false;

            String[] tempArray = msg.Trim().Split('#');

            if (tempArray.Length > 3)
            {
                opCode = tempArray[3];

                if (opCode.Equals((int)MessageBusCmds.SendSMSRequest + "") || opCode.Equals((int)MessageBusCmds.SendSMSRequest2 + ""))
                {
                    // skip message if already acknowledged 
                    if (acknowledgedMessagesSeqNo.Contains(tempArray[2]))
                        return false;


                    int sched_timeGMT = 0;
                    if (tempArray.Length > 6)
                        sched_timeGMT = Convert.ToInt32(tempArray[6]);
                    // SafeMobileLib.Utils.WriteLine("SMS sched time={0} and current time ={1}",sched_timeGMT, DBmanager.DateTo70Format(DateTime.Now.ToUniversalTime()));
                    int gwid_recv = Convert.ToInt32((tempArray[4].Split('.'))[0]);
                    int radio_gwid_recv = Convert.ToInt32((tempArray[4].Split('.'))[1]);

                    // detect if the message is for this gateway (the radio gateway will be selected by the route management)
                    if (gwid_recv == Main.GWID)
                    {
                        if (sched_timeGMT <= (DateTime.Now.ToUniversalTime().Subtract(new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds))
                        {
                            // SafeMobileLib.Utils.WriteLine("SCHED " + sched_timeGMT + " [" + msg.Trim() + "]", ConsoleColor.White);
                            // SafeMobileLib.Utils.WriteLine("TIME " + (DBmanager.DateTo70Format(DateTime.Now.ToUniversalTime())), ConsoleColor.White);
                            // get the radio imei and then parse the radioID
                            String IMEI = (tempArray[4].Split('.'))[2];
                            Int32 radioID = 0;
                            Int32.TryParse(IMEI, out radioID);


                            // add an entity into the smsConfirmation queue
                            if (!Main.smsConfirmForUnits.ContainsKey(radioID))
                                Main.smsConfirmForUnits.Add(radioID, new SMSConfirm(radioID));


                            // get the sequence number that was used previously
                            if (Main.smsConfirmForUnits[radioID].ExistsSequenceInQueue(tempArray[2]))
                                sms_seq_id = Main.smsConfirmForUnits[radioID].getFromConfirmationQueueBySeq(tempArray[2]);

                            // add message to the queue only if requires ack
                            else if (Main.wait4ack)
                                sms_seq_id = Main.smsConfirmForUnits[radioID].addToConfirmationQueue(tempArray[2]);


                            // sometimes I receive a message with 0.0, used only when waiting for ack
                            if ((sms_seq_id == 0 || tempArray[2].StartsWith("0.0")) && Main.wait4ack)
                            {
                                SafeMobileLib.Utils.WriteLine("COULD NOT FOUND SMS SEQUENCE ID " + tempArray[2], ConsoleColor.Red, ConsoleType.SMS);
                                return false;
                            }

                            // do not send again the message if already ack
                            if (SMSSendThread.acknowledgedMessagesSeqNo.Contains(tempArray[2]))
                            {
                                SafeMobileLib.Utils.WriteLine("SMS already ACK" + tempArray[2], ConsoleColor.Red, ConsoleType.SMS);
                                return false;
                            }

                            if (Main.wait4ack)
                            {
                                // increment number of sendings and last sending
                                Main.smsConfirmForUnits[radioID].UpdateNumberOfRetries(tempArray[2]);

                            }


                            int lastSent = Main.smsConfirmForUnits[radioID].GetLastSchedTime(tempArray[2]); ;
                            int nr_of_retries = Main.smsConfirmForUnits[radioID].GetNumberOfRetries(tempArray[2]);



                            if (DateTime.Now.ToUniversalTime().DateTo70Format() - lastSent < 60)
                            {
                                SafeMobileLib.Utils.WriteLine("GOT AN 143 THAT SHOULDN'T EXIST HERE" + msg, ConsoleColor.Red, ConsoleType.SMS);
                                return false;
                            }


                            if (Main.wait4ack)
                            {
                                Main.smsConfirmForUnits[radioID].UpdateLastSchedTime(tempArray[2],
                                    (int)DateTime.Now.ToUniversalTime().DateTo70Format());
                            }

                            // SafeMobileLib.Utils.WriteLine("SMSSendThread received from multicast bus: " + str.Trim());
                            if ((sms_seq_id != -1) && Main.wait4ack)
                            {
                                //SafeMobileLib.Utils.WriteLine("Sending SMS with ACK");
                                if (nr_of_retries <= Main.number_of_retries)
                                {
                                    SendSMS(IMEI, tempArray[5], 1, sms_seq_id);

                                    wasSent = true;
                                }
                            }
                            else
                            {
                                //SafeMobileLib.Utils.WriteLine("Sending SMS without ACK");
                                SendSMS(IMEI, tempArray[5], -1, sms_seq_id);
                                wasSent = true;

                                if (!Main.wait4ack)
                                {
                                    // encode a fake ack message
                                    System.Text.Encoding enc = System.Text.Encoding.ASCII;
                                    byte[] buf = enc.GetBytes(SMSReceiveThread.GetAck4MessagebusForSequence(tempArray[2] + ""));

                                    //send SMS ack
                                    udpMulticastBusConnection.Send(buf, buf.Length);
                                }
                            }

                            // add message back to queue in case the ack is not received to be sent again
                            if (Main.wait4ack)
                            {
                                //SafeMobileLib.Utils.WriteLine(tempArray[2] + " - Number of retries is " + nr_of_retries, ConsoleColor.Magenta);

                                if (nr_of_retries > Main.number_of_retries)
                                {
                                    // remove the message from the confirmation queue
                                    Main.smsConfirmForUnits[radioID].getFromConfirmationQueue(sms_seq_id);
                                    // add message to the acknowledged ones
                                    acknowledgedMessagesSeqNo.Add(tempArray[2]);


                                    SafeMobileLib.Utils.WriteLine("Message failed to be delivered " + nr_of_retries + " times. Sending fake ack." + msg, ConsoleColor.Yellow, ConsoleType.SMS);

                                    // encode a fake ack message
                                    System.Text.Encoding enc = System.Text.Encoding.ASCII;
                                    byte[] buf = enc.GetBytes(SMSReceiveThread.GetAck4MessagebusForSequence(tempArray[2] + ""));

                                    //send SMS ack
                                    udpMulticastBusConnection.Send(buf, buf.Length);

                                    // flag that no mmesage was sent
                                    wasSent = false;
                                }
                                else
                                {

                                    // change the scheduleACK time to force the message to be send after 'nr_of_retries * 60 sec'
                                    //tempArray[6] = (DBmanager.DateTo70Format(DateTime.Now.ToUniversalTime()) + (nr_of_retries * 60)) + "";
                                    tempArray[6] = (DateTime.Now.ToUniversalTime().DateTo70Format() + (Main.retry_interval_sec)) + "";
                                    msg = String.Join("#", tempArray);

                                    sendSMSQueue.PostItem(msg);

                                    SafeMobileLib.Utils.WriteLine("[" + nr_of_retries + "] Added message back to queue " + msg, ConsoleColor.Green, ConsoleType.SMS);
                                }
                            }
                        }
                        else
                        {
                            // add again message to the queue to be sent later
                            sendSMSQueue.PostItem(msg);

                            // flag that no mmesage was sent
                            wasSent = false;
                        }
                    }
                }
                else if (tempArray[3].Equals("144") || tempArray[3].Equals("145"))
                {
                    //#60#3.1562590094636981976945036122#144#2.4.1#asd#1562590094#
                    
                    // SafeMobileLib.Utils.WriteLine("SMSSendThread received from multicast bus: " + str.Trim());
                    int sched_timeGMT = 0;
                    if (tempArray.Length > 6)
                        sched_timeGMT = Convert.ToInt32(tempArray[6]);
                    // SafeMobileLib.Utils.WriteLine("SMS sched time={0} and current time ={1}",sched_timeGMT, DBmanager.DateTo70Format(DateTime.Now.ToUniversalTime()));
                    int gwid_recv = Convert.ToInt32((tempArray[4].Split('.'))[0]);
                    if (gwid_recv == Main.GWID)
                    {
                        if (sched_timeGMT <= (DateTime.Now.ToUniversalTime().DateTo70Format()))
                        {
                            DBSms = new DBsmsManager(Main.DBServer, Main.DBSchema, Main.DBUser, Main.DBPass, Main.DBPort);
                            bool alreadySent = DBSms.Get_Group_SMS_Status(tempArray[5], tempArray[2]);
                            if (alreadySent)
                            {
                                Thread.Sleep(500);
                                return wasSent = true;
                            }

                            SafeMobileLib.Utils.WriteLine("Send group SMS without ACK " + tempArray[5] + " for " + tempArray[4] + " received... sending it to radio", ConsoleType.SMS);
                            String cpsID = (tempArray[4].Split('.'))[2];
                            //Thread.Sleep(2000);
                            //Boolean RetSMS = gw.SendSMS(radioID, tempArray[5]);
                            //SMShandle.Add2QueueCPS(tempArray[2], cpsID, tempArray[5]);
                            SendSMSGroup(cpsID, tempArray[5], -1, sms_seq_id);
                            string test = "#244#1#";
                            String cmdok = "#" + tempArray[2] + test;
                            Int32 tmp = cmdok.Length + 1; tmp += tmp.ToString().Length; cmdok = "#" + tmp.ToString() + cmdok;
                            System.Text.Encoding enc = System.Text.Encoding.ASCII;
                            byte[] buf = enc.GetBytes(cmdok);
                            //send SMS ack
                            udpMulticastBusConnection.Send(buf, buf.Length);
                            SafeMobileLib.Utils.WriteLine("TX:" + cmdok);
                            wasSent = true;
                        }
                        else
                        {
                            // add again message to the queue to be sent later
                            sendSMSQueue.PostItem(msg);

                            // flag that no mmesage was sent
                            wasSent = false;
                        }
                    }
                }

                return wasSent;
            }
            else
            {
                opCode = "0";
                return wasSent;
            }
        }



        Byte[] PackSMS(string msg_body, bool confirm, int p_sms_seq_id)
        {
           
            int msg_len = msg_body.Length;
            if (msg_len > MAX_SMS_SIZE)
            {
                msg_len = MAX_SMS_SIZE;
                SafeMobileLib.Utils.WriteLine("Warning: SMS truncated to " + msg_len + " characters", ConsoleType.SMS);
            }

            if (msg_len > msg_body.Length)
            {
                msg_body = msg_body.Remove(MAX_SMS_SIZE);
            }
            // compute the len
            int len = msg_len;

            len *= 2; // each character is encoded on 2B            
            len += 4; // this is for the headers            
            Byte[] data = new Byte[len + 2]; //+2 for the msg size

            int msb = (len & 0xff00) >> 8;
            data[0] = (byte)(msb & 0x00ff);
            data[1] = (byte)(len & 0x00ff);

            // put the headers
            if (confirm)
            {
                data[2] = 0xe0; // first header
            }
            else
            {
                data[2] = 0xa0; // first header
            }

            data[3] = 0x00; // addr size

            byte lsb_id = (byte)(p_sms_seq_id & 0x1f);
            data[4] = (byte)(0x80 | lsb_id);
            byte msb_id = (byte)(p_sms_seq_id & 0x60); // keep bits 6:5
            data[5] = (byte)(msb_id | 0x04);

            for (int i = 0; i < msg_len; i++)
            {
                data[6 + i * 2] = (byte)msg_body[i];
                data[6 + i * 2 + 1] = 0;
            }

            return data;
        }

        public void SendSMS(string SUID, string msg, int msg_idx, int p_sms_seq_id)
        {
            
            try
            {
                // detect if ticketing message
                if (msg.Contains("<JTS>") == true && msg.Contains("\r\n") == true)
                {
                    string[] TicketString = msg.Split('^');
                    msg = TicketString[0];
                    //comment or message body
                    if (TicketString.Length > 1)
                    {
                        if (TicketString[1] != "") msg += string.Format("({0})", TicketString[1]);
                    }
                    if (TicketString.Length > 3)
                    {
                        if (TicketString[4] != "")
                        {
                            msg += " until ";
                            msg += (Convert.ToInt32(TicketString[4])).GetDTLocalFromSeconds().ToString("dd/MM/yyyy HH:mm:ss, ddd");
                        }
                    }
                }
                int wait_confirm_sec = 0;
                if (msg_idx > 0)
                    wait_confirm_sec = WAIT_SMS_SEC;

                if (msg_idx == -1)
                    wait_confirm_sec = 0;


                if (wait_confirm_sec != 0)
                {
                    Byte[] sendBytes = PackSMS(msg, true, p_sms_seq_id);
                    SafeMobileLib.Utils.WriteLine("««« SMS with confirmation [" + msg + "] to " + SUID, ConsoleType.SMS);
                    udpClientSMS.Send(sendBytes, sendBytes.Length, (new RadioID2IP("12", SUID)).GetIP(), smsPort);//12
                }
                else
                {
                    Byte[] sendBytes = PackSMS(msg, false, p_sms_seq_id);
                    SafeMobileLib.Utils.WriteLine("««« SMS without confirmation [" + msg + "] to " + SUID, ConsoleType.SMS);
                    udpClientSMS.Send(sendBytes, sendBytes.Length, (new RadioID2IP("12", SUID)).GetIP(), smsPort);//12
                }
            }
            catch (Exception exc)
            {
                SafeMobileLib.Utils.WriteLine(exc.ToString(), ConsoleColor.Red);
            }
        }

        public void SendSMSGroup(string SUID, string msg, int msg_idx, int p_sms_seq_id)
        {
            try
            {
                if (!MotoTrbo_GW.Main.capacityPlus)
                {
                    foreach (GatewayID_IP gatewayRadio in MotoTrbo_GW.Main.gatewayRadios)
                    {                        
                        String commandGRP = "route delete 225.0.0.0";
                        ExecuteCommand(commandGRP);                        
                        Thread.Sleep(200);
                        commandGRP = "route add 225.0.0.0 mask 255.0.0.0 " + gatewayRadio.remoteIP + " metric 80 IF " + gatewayRadio.ID;
                        SafeMobileLib.Utils.WriteLine("**** Add groups IP\n" + commandGRP, ConsoleType.SMS);
                        ExecuteCommand(commandGRP);
                        Thread.Sleep(1000);
                        Byte[] sendBytes = PackSMS(msg, true, p_sms_seq_id);
                        udpClientSMS.Send(sendBytes, sendBytes.Length, (new RadioID2IP("225", SUID)).GetIP(), smsPort);
                    }
                }
                else
                {
                    Byte[] sendBytes = PackSMS(msg, true, p_sms_seq_id);
                    udpClientSMS.Send(sendBytes, sendBytes.Length, (new RadioID2IP("225", SUID)).GetIP(), smsPort);
                }
            }
            catch (Exception exc)
            {
                SafeMobileLib.Utils.WriteLine(exc.ToString());
            }
        }

        private static void ExecuteCommand(String command)
        {
            Process p = new Process();
            p = new Process();
            p.StartInfo.FileName = "cmd.exe";
            String arguments = "/c " + command;
            p.StartInfo.Arguments = arguments;
            p.StartInfo.UseShellExecute = false;
            p.Start();
        }
    }
}