//#define jurgen
using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.IO;
using Microsoft.Win32;
using SafeMobileLib;

namespace RegLibDLL
{
    public class RegLib
    {
        private String parola = "ab09ads08asd8080fg09a90g08sfd808bfb08hg0j08f80";
        private Int32 uid = 1738349905;
        private Int32 hid = 0;
        private Int32 handle;
        private String decodedMessage;
        private Boolean validDongle;
        private Boolean existsDongle;
        private Int16 offset = -20;
        private Int16 zonesIndex = 315;
        private Int16 reportsIndex = 316;
        private Int16 telemetryIndex = 317;
        private Int16 voiceIndex = 318;
        private Int16 emailGatewayIndex = 319;
        private Int16 unitCountIndex = 320;
        private Int16 mapType1Index = 325;
        private Int16 mapType2Index = 326;
        private Int16 mapType3Index = 327;
        private Int16 mapType4Index = 328;
        private Int16 safeDispatchIndex = 329;
        private Int16 gatewayIndex = 330;
        private Int16 gpsIndex = 331;
        private Int16 smsIndex = 332;
        private Int16 SDMobileIndex = 333;
        private Int16 jobTicketingIndex = 334;
        private Int16 recordingsIndex = 335;
        private Int16 audibleAlertsIndex = 336;
        private Int16 dbAccessIndex = 337;
        private String msgIPs = "";
        private Boolean oldDongle = false;
        public Boolean demoMode = false;
        private String password = "ab09ads08asd8080fg09a90g08sfd808bfb08hg0j08f80";
        private uint firstRunTime = 0;
        private uint lastRunTime = 0;
        private uint remainingDemoTime = 0;
        private uint demoPeriod30DaysInSec = 2592000;
        private uint demoPeriod14DaysInSec = 1209600;
        private uint demoDuration = 2 * 2592000;
        //private String licenseFileName = "E:\\WorkSpace_cSharp\\SafeDispatch_v4\\AppServerService\\bin\\Debug\\NSpeex2.dll";
        public Boolean AIRTURKEYLIMIT = false;

        //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=--=
        [DllImport("SDX.dll")]
        static extern int SDX_Find();
        [DllImport("SDX.dll")]
        static extern int SDX_Open(int mode, Int32 uid, ref Int32 hid);
        [DllImport("SDX.dll")]
        static extern void SDX_Close(int handle);
        [DllImport("SDX.dll")]
        static extern int SDX_Read(int handle, int block_index, byte[] buffer512);
        [DllImport("SDX.dll")]
        static extern int SDX_Write(int handle, int block_index, String buffer512);

        //public RegLib(String pathToRegFile, bool aaaa)
        //{
        //    if (!pathToRegFile.EndsWith("\\"))
        //        pathToRegFile += "\\";

        //    licenseFileName = pathToRegFile + licenseFileName;
        //}

        public RegLib()
        {
            String msg;
            String safemobilePath = Utils.GetRegValue("Path", "SafeMobile");
            String licenseFileName = safemobilePath + "\\AppServer\\NSpeex2.dll";
            
            if (findDongle())
            {
                applyOffset();
                openDongle();
                msg = readDataFromDongle(0);
                msgIPs = readDataFromDongle(1);
                existsDongle = true;
                //checks that a valid message is written on the dongle
                int index = msg.IndexOf("SafeMobi");
                if (index > 0)
                {
                    String data = msg.Substring(0, index);
                    decodedMessage = DecryptString(data, parola);
                    validDongle = true;
                    remainingDemoTime = 2*2592001;
                }
                else
                {
                    decodedMessage = "";
                    validDongle = false;
                }
            }
            else
            {
                existsDongle = false;
                String data = "";
                try
                {
                    data = File.ReadAllText(licenseFileName);
                    String decryptedData = DecryptString(data, password);
                    demoMode = true;
                    if (decryptedData.Substring(199, 10).Equals("1111111111"))
                    {
                        Console.WriteLine("Demo invalidated");
                        remainingDemoTime = 1;
                        validDongle = false;
                    }
                    else
                    {
                        if (decryptedData.Substring(89, 10).Equals("0000000000"))
                        {
                            uint firstRunTime = DateTo70Format(DateTime.Now);
                            String firstPart = decryptedData.Substring(0, 89);
                            String middlePart = decryptedData.Substring(99, 100);
                            String lastPart = decryptedData.Substring(209);
                            String newData = firstPart + firstRunTime.ToString() + middlePart + firstRunTime.ToString()
                                + lastPart;
                            String encryptedData = EncryptString(newData, password);
                            File.WriteAllText(licenseFileName, encryptedData);
                            remainingDemoTime = demoDuration;
                        }
                        else
                        {
                            firstRunTime = (uint)Int32.Parse(decryptedData.Substring(89, 10));
                            lastRunTime = (uint)Int32.Parse(decryptedData.Substring(199, 10));
                            uint currentRunTime = DateTo70Format(DateTime.Now);
                            if (currentRunTime > firstRunTime + demoDuration)
                            {
                                Console.WriteLine("Demo expired");
                                remainingDemoTime = 0;
                                validDongle = false;
                            }
                            else
                            {
                                String firstPart = decryptedData.Substring(0, 199);
                                String lastPart = decryptedData.Substring(209);
                                String newData = "";
                                if (currentRunTime < lastRunTime)//detected user attempt to cheat, invalidating license for good
                                {
                                    remainingDemoTime = 1;
                                    Console.WriteLine("Detected rollback of system time, disabling demo.");
                                    newData = firstPart + "1111111111" + lastPart;
                                }
                                else
                                {
                                    remainingDemoTime = firstRunTime + demoDuration - currentRunTime;
                                    newData = firstPart + currentRunTime.ToString() + lastPart;
                                }
                                String encryptedData = EncryptString(newData, "ab09ads08asd8080fg09a90g08sfd808bfb08hg0j08f80");
                                File.WriteAllText(licenseFileName, encryptedData);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Invalid dongle AND invalid license file. Exception: " + ex.ToString());
                    validDongle = false;
                    return;
                }
            }
        }

        public RegLib(String dataToWrite)
        {
            applyOffset();
            if (findDongle())
            {
                openDongle();
                writeToDongle(dataToWrite, 0);
                existsDongle = true;
                int index = dataToWrite.IndexOf("SafeMobi"); 
                if (index > 0)
                {
                    String data = dataToWrite.Substring(0, index);
                    decodedMessage = DecryptString(data, parola);
                    validDongle = true;
                }
                else
                {
                    decodedMessage = "";
                    validDongle = false;
                }
            }
        }

        /// <summary>
        /// Returns the remaining demo time, in seconds
        /// </summary>
        /// <returns></returns>
        public uint remainingTime()
        {
            return remainingDemoTime;
        }

        private uint DateTo70Format(DateTime param)
        {
            long nOfSeconds;
            System.DateTime dt70 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
            TimeSpan span = param - dt70;
            nOfSeconds = (long)span.TotalSeconds;
            return ((uint)nOfSeconds);
        }

        private void applyOffset()
        {
            zonesIndex = (Int16)(zonesIndex + offset);
            reportsIndex = (Int16)(reportsIndex + offset);
            telemetryIndex = (Int16)(telemetryIndex + offset);
            voiceIndex = (Int16)(voiceIndex + offset);
            emailGatewayIndex = (Int16)(emailGatewayIndex + offset);
            unitCountIndex = (Int16)(unitCountIndex + offset);
            mapType1Index = (Int16)(mapType1Index + offset);
            mapType2Index = (Int16)(mapType2Index + offset);
            mapType3Index = (Int16)(mapType3Index + offset);
            mapType4Index = (Int16)(mapType4Index + offset);
            safeDispatchIndex = (Int16)(safeDispatchIndex + offset);
            gatewayIndex = (Int16)(gatewayIndex + offset);
            gpsIndex = (Int16)(gpsIndex + offset);
            smsIndex = (Int16)(smsIndex + offset);
            jobTicketingIndex = (Int16)(jobTicketingIndex + offset);
            recordingsIndex = (Int16)(recordingsIndex + offset);
            SDMobileIndex = (Int16)(SDMobileIndex + offset);
            audibleAlertsIndex = (Int16)(audibleAlertsIndex + offset);
            dbAccessIndex = (Int16)(dbAccessIndex + offset);
        }

        private String getDecodedMessage()
        {
            return decodedMessage;
        }

        public Boolean findDongle()
        {
#if jurgen
            return true;
#else
            int ret = SDX_Find();
            if (ret > 1)
            {
                return true;
            }
            else if (ret == 1)
            {
                return true;
            }
            else
            {
                return false;
            }
#endif
        }

        private Boolean openDongle()
        {
#if jurgen
            return true;
#else
            int ret = SDX_Open(1, uid, ref hid);
            if (ret < 0)
            {
                return false;
            }
            handle = ret;
            return true;
#endif
        }

        private String readDataFromDongle(int blockNumber)
        {
            Byte[] retbuff = new byte[512];
            int ret = SDX_Read(handle, blockNumber, retbuff);
            if (ret < 0)
            {
                return "";
            }
            String sReturn = System.Text.ASCIIEncoding.ASCII.GetString(retbuff);
            return sReturn;
        }

        public Int32 writeToDongle(String dataToWrite, Int32 blockIndex)
        {
            int ret = SDX_Write(handle, blockIndex, dataToWrite);
            if (ret < 0)
            {
                return -1;
            }
            return 0;
        }
        private String DecryptString(string Message, string Passphrase)
        {
            byte[] Results;
            System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;
            byte[] DataToDecrypt = Convert.FromBase64String(Message);
            try
            {
                ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
                Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
            }
            finally
            {
                TDESAlgorithm.Clear();
                HashProvider.Clear();
            }
            return UTF8.GetString(Results);
        }

        public static string EncryptString(string Message, string Passphrase)
        {
            byte[] results;
            System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;
            byte[] DataToEncrypt = UTF8.GetBytes(Message);
            try
            {
                ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
                results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
            }
            finally
            {
                TDESAlgorithm.Clear();
                HashProvider.Clear();
            }
            return (Convert.ToBase64String(results));
        }

        /// <summary>
        /// Checks for existence of dongle.
        /// </summary>
        /// <returns>true if dongle exists and false otherwise</returns>
        public Boolean dongleDetected()
        {
#if jurgen
            return true;
#else
            if (existsDongle)
            {
                return true;
            }
            else
            {
                return false;
            }
#endif
        }

        /// <summary>
        /// Checks for validity of data on dongle
        /// </summary>
        /// <returns>true if valid dongle (i.e. data) and false otherwies</returns>
        public Boolean validData()
        {
#if jurgen
            return true;
#else
            if (validDongle)
            {
                return true;
            }
            else
            {
                return false;
            }
#endif
        }

        /// <summary>
        /// Get the customer ID from the dongle
        /// </summary>
        /// <returns>A string with the customer ID or null if incorrect data on dongle</returns>
        public String customerID()
        {
            if (validDongle)
            {
                Int32 length = Convert.ToInt32(decodedMessage.Substring(10, 3));
                return decodedMessage.Substring(13, length);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Get the customer name from the dongle
        /// </summary>
        /// <returns>A string with the customer name or null if incorrect data on dongle</returns>
        public String customerName()
        {
            if (validDongle)
            {
                Int32 length = Convert.ToInt32(decodedMessage.Substring(35, 3));
                return decodedMessage.Substring(38, length);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Get the customer address from the dongle
        /// </summary>
        /// <returns>A string with the customer address or null if incorrect data on dongle</returns>
        public String customerAddress()
        {
            if (validDongle)
            {
                Int32 length = Convert.ToInt32(decodedMessage.Substring(85, 3));
                return decodedMessage.Substring(88, length);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Get the customer contact person from the dongle
        /// </summary>
        /// <returns>A string with the customer contact person name or null if incorrect data on dongle</returns>
        public String customerContactPerson()
        {
            if (validDongle)
            {
                Int32 length = Convert.ToInt32(decodedMessage.Substring(195, 3));
                return decodedMessage.Substring(198, length);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Get the zones count from the dongle
        /// </summary>
        /// <returns>number of registered zones from the dongle, and 0 if dongle not valid</returns>
        public int zonesCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[zonesIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the gps count from the dongle
        /// </summary>
        /// <returns>number of gps licenses from the dongle, and 0 if dongle not valid</returns>
        public int gpsCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[gpsIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the sms count from the dongle
        /// </summary>
        /// <returns>number of sms licenses from the dongle, and 0 if dongle not valid</returns>
        public int smsCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[smsIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the job ticketing count from the dongle
        /// </summary>
        /// <returns>number of job ticketing licenses from the dongle, and 0 if dongle not valid</returns>
        public int jobTicketingCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[jobTicketingIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the recordings count from the dongle
        /// </summary>
        /// <returns>number of recordings licenses from the dongle, and 0 if dongle not valid</returns>
        public int recordingsCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[recordingsIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the voip count from the dongle
        /// </summary>
        /// <returns>number of voip licences from the dongle, and 0 if dongle not valid</returns>
        public int voiceCount()
        {
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[voiceIndex]);
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        /// Get the Audible Alerts count from the dongle
        /// </summary>
        /// <returns> 1 if user has audible alerts or 0 if user doesn't have audible alerts</returns>
        public int audibleAlertsCount()
        {
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[audibleAlertsIndex]);
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        /// Get the DB Access count from the dongle
        /// </summary>
        /// <returns>number of voip licences from the dongle, and 0 if dongle not valid</returns>
        public int dbAccessCount()
        {
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[dbAccessIndex]);
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        /// Get the email gateway count status from the dongle
        /// </summary>
        /// <returns>number of email licences from the dongle, and 0 if dongle not valid</returns>
        public int emailGatewayCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[emailGatewayIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the number of units from the dongle
        /// </summary>
        /// <returns>The number of units from the dongle data, or 0 if no dongle is detected</returns>
        public int getNumberOfUnits()
        {
#if jurgen
            return 45;
#else
            if (demoMode)
            {
                return 12; //10
            }
            if (oldDongle)
            {
                return 12;  //10
            }
            int numberOfUnits = 0;
            if (validDongle)
            {
                String numbersString = decodedMessage.Substring(unitCountIndex, 5);
                numberOfUnits = Convert.ToInt32(numbersString);
                if (numberOfUnits == 12345)
                {
                    AIRTURKEYLIMIT = true;
                    return 150;
                }
                else return numberOfUnits;
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the reports count from the dongle
        /// </summary>
        /// <returns>number of reports licences from the dongle, and 0 if dongle not valid</returns>
        public int reportsCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[reportsIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the telemetry count from the dongle
        /// </summary>
        /// <returns>number of telemetry licences from the dongle, and 0 if dongle not valid</returns>
        public int telemetryCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[telemetryIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the map type 1 count (initially Google only) from the dongle
        /// </summary>
        /// <returns>number of map type 1 licences from the dongle, and 0 if dongle not valid</returns>
        public int mapType1Count()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[mapType1Index]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the map type 2 count from the dongle
        /// </summary>
        /// <returns>number of map type 2 licences from the dongle, and 0 if dongle not valid</returns>
        public int mapType2Count()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[mapType2Index]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the map type 3 count from the dongle
        /// </summary>
        /// <returns>number of map type 3 licences from the dongle, and 0 if dongle not valid</returns>
        public int mapType3Count()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[mapType3Index]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the map type 4 count from the dongle
        /// </summary>
        /// <returns>number of map type 4 licences from the dongle, and 0 if dongle not valid</returns>
        public int mapType4Count()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[mapType4Index]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the SafeDispatch activation count from the dongle
        /// </summary>
        /// <returns>number of SafeDispatch licences from the dongle, and 0 if dongle not valid</returns>
        public int safeDispatchCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            if (validDongle)
            {
                return ((int)decodedMessage[safeDispatchIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the gateway activation status from the dongle
        /// </summary>
        /// <returns>true if gateway is enabled and false if gateway not enabled or incorrect data on dongle</returns>
        public Boolean enabledGateway()
        {
#if jurgen
            return true;
#else
            if (demoMode)
            {
                return true;
            }
            if (validDongle)
            {
                if (decodedMessage[342].CompareTo('y') == 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
#endif
        }

        /// <summary>
        /// Get the gateway activation count from the dongle
        /// </summary>
        /// <returns>number of gateway licences from the dongle, and 0 if dongle not valid</returns>
        public int gatewayCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
          /*if (enabledGateway())
            {
                oldDongle = true;
                return 1;
            }
            oldDongle = false;*/
            if (validDongle)
            {
                return ((int)decodedMessage[gatewayIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Get the SDMobile activation count from the dongle
        /// </summary>
        /// <returns>number of SDMobile licences from the dongle, and 0 if dongle not valid</returns>
        public int SDMobileCount()
        {
#if jurgen
            return 2;
#else
            if (demoMode)
            {
                return 1;
            }
            /*if (enabledGateway())
              {
                  oldDongle = true;
                  return 1;
              }
              oldDongle = false;*/
            if (validDongle)
            {
                return ((int)decodedMessage[SDMobileIndex]);
            }
            else
            {
                return 0;
            }
#endif
        }

        /// <summary>
        /// Detects if the HID in the dongle data corresponds with the HID of the dongle itself
        /// </summary>
        /// <returns>true if HID checks out and false if HID is different or incorrect data on dongle</returns>
        public Boolean isCorrectHID()
        {
#if jurgen
            return true;
#else
            if (demoMode)
            {
                return true;
            }
            if (validDongle)
            {
                Int32 length = Convert.ToInt32(decodedMessage.Substring(320, 3));
                String HID_READ = decodedMessage.Substring(323, length);
                if (HID_READ.CompareTo(hid.ToString()) == 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
#endif
        }
        
    }
}