using CalAmp_API;
using CalAmp_API.Classes;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Windows.Forms;

namespace CalAmp_API
{
    public partial class MainWindow : Form
    {
        string urlDevice = "https://testpuls.calamp.com/service/device/";
        string urlGroups = "https://testpuls.calamp.com/service/group";
        string urlConfig = "https://testpuls.calamp.com/service/config";
        string urlFirmware = "https://testpuls.calamp.com/service/firmware";
        string urlVBusDevice = "https://testpuls.calamp.com/service/vbus/";

        string API_KEY = "?apikey=ZTKwt2SJ_NL1EK6UEhhwXB3TCoqOaOOLxX6TyJeRyMUcCX00Mr4zHfR3UoDKYBzm";

        string user = "fts-testpuls";
        string password = "23FTS6test";
        string userAndPassword = "fts-testpuls:23FTS6test";

        //TODO: TEST

        //TODO: END TEST

        internal Device dev;
        internal Firmware actualFirm;
        internal VBus vbdev;
        List<VBusFile> vbf = new List<VBusFile>();
        List<Config> configs = new List<Config>();
        List<Group> groups = new List<Group>();
        List<Firmware> firmwaresHistory = new List<Firmware>();
        List<newFirmware> newfirmwares = new List<newFirmware>();

        public MainWindow()
        {
            InitializeComponent();
            CenterToScreen();
            GetListOfConfigs();
            GetListOfFirmwares();
            GetListOfGroups();
        }

        public void GetDevice_Click(object sender, EventArgs e)
        {

            Device device = new Device(deviceESNbox.Text);
            device.Update();

           /*
            ServicePointManager.ServerCertificateValidationCallback = ((sender2, certificate, chain, sslPolicyErrors) => true);
            ServicePointManager.Expect100Continue = false;

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlDevice + deviceESNbox.Text);
            request.ContentLength = 0;
            request.ContentType = "application/json";
            request.MediaType = "application/json";

            byte[] authBytes = Encoding.UTF8.GetBytes(userAndPassword.ToCharArray());
            request.Headers.Add(HttpRequestHeader.Authorization, String.Format("Basic {0}", Convert.ToBase64String(authBytes)));

            try
            {
                var webresponse = request.GetResponse();
                string content = CreateStringContent(webresponse);
                if (!content.Contains("Device Not Found"))
                {
                    if (!content.Contains("Unable"))
                    {
                        ParserJson parser = new ParserJson(dev, configs, groups, firmwaresHistory, newfirmwares, vbdev, vbf);
                        dev = parser.ParseJsonDevice(content);
                        //actualFirm = firmwaresHistory[0];
                        actualFirm = dev.firmwareHistorys[0];
                        scripTextBox.Text = dev.scriptVersion.ToString();
                        configTextBox.Text = dev.configVersion.ToString();
                        sonfigStatusTextBox.Text = dev.configStatus.ToString();
                        firmStatusText.Text = actualFirm.status;
                        //firmVersionTextBox.Text = actualFirm.newFirmware.versionNumber + " - " + actualFirm.newFirmware.appId;
                        groupTextBox.Text = dev.group.ToString();
                    }
                    else
                    {
                        MessageBox.Show(this, "Device not found.", "Error");
                    }
                }
                else
                {
                    MessageBox.Show(this, "Device not found.", "Error");
                }
            }
            catch (WebException ex)
            {
                Console.WriteLine(ex.Response);
                MessageBox.Show(this, "Device not found.", "Error");
            }
            */
        }

        public void updateDeviceConfig_Click(object sender, EventArgs e)
        {
            Config newConfig = configs.Find(x => x.configVersion.Equals(int.Parse(ConfigList.SelectedItem.ToString())));
            newConfig.setDevice(dev);
            newConfig.Update();
        }

        private void updateFirmware_Click(object sender, EventArgs e)
        {
            Firmware firmWere = new Firmware();
            firmWere.setDevice(dev);
            firmWere.Update();
        }

        private void updateGroup_Click(object sender, EventArgs e)
        {
            Group newGroup = new Group();
            newGroup.name = GroupList.SelectedItem.ToString();
            newGroup.setDevice(dev);
            newGroup.Update();
        }

        private void updateFileVersion_Click(object sender, EventArgs e)
        {
            if (vbdev != null)
            {
                VBusFile newVBusFile = new VBusFile();
                newVBusFile.versionNumber = VBusVersionList.SelectedItem.ToString();

                DeviceJson devJson = new DeviceJson();
                VBusFile vbfile = new VBusFile();
                devJson.vBusFile = vbfile;

                List<VBusFile> temp = vbdev.vBusDeviceFiles.Where(x => x.vbusFileType.Equals(2)).ToList();
                devJson.vBusFile.vbusFileType = temp[0].vbusFileType;

                devJson.esn = vbdev.esn;
                devJson.mobileId = vbdev.mobileId;

                string json = JsonConvert.SerializeObject(devJson);
                //File.WriteAllText("SerializedVbusJson.json", json);

                ServicePointManager.ServerCertificateValidationCallback = ((sender2, certificate, chain, sslPolicyErrors) => true);
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3;
                ServicePointManager.Expect100Continue = false;

                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlDevice + vbdev.mobileId);
                request.ContentLength = json.Length;
                request.ContentType = "application/json";
                request.Method = "POST";
                request.AllowWriteStreamBuffering = true;

                using (var streamWriter = new StreamWriter(request.GetRequestStream()))
                {
                    streamWriter.Write(json);
                    streamWriter.Close();
                }

                CredentialCache mycache = new CredentialCache();
                mycache.Add(new Uri(urlDevice + vbdev.mobileId), "Basic", new NetworkCredential(user, password));
                request.Credentials = mycache;

                try
                {
                    var webresponse = request.GetResponse();
                    MessageBox.Show(this, "Updated VBus.", "Success");
                }
                catch (WebException ex)
                {
                    MessageBox.Show(this, "Cannot update VBus, please try again later.", "Error");
                }
            }
            else
            {
                MessageBox.Show(this, "Please, load VBus first.", "Error");
            }

        }


        internal void GetListOfConfigs()
        {
            ServicePointManager.ServerCertificateValidationCallback = ((sender, certificate, chain, sslPolicyErrors) => true);
            ServicePointManager.Expect100Continue = false;
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlConfig + API_KEY);

            request.ContentLength = 0;
            request.ContentType = "application/json";
            request.MediaType = "application/json";

            byte[] authBytes = Encoding.UTF8.GetBytes(userAndPassword.ToCharArray());
            request.Headers.Add(HttpRequestHeader.Authorization, String.Format("Basic {0}", Convert.ToBase64String(authBytes)));

            try
            {
                var webresponse = request.GetResponse();
                string content = CreateStringContent(webresponse);
                ParserJson parser = new ParserJson(dev, configs, groups, firmwaresHistory, newfirmwares, vbdev, vbf);
                List<string> conf = parser.ParseJsonConfigs(content);
                if (conf.Count != 0)
                {
                    ConfigList.DataSource = conf;
                }
            }
            catch (WebException ex)
            {
                Console.WriteLine(ex.Response);
                MessageBox.Show(this, "Server error - no configs.", "Error");
            }
        }

        private void GetListOfFirmwares()
        {

            ServicePointManager.ServerCertificateValidationCallback = ((sender2, certificate, chain, sslPolicyErrors) => true);
            ServicePointManager.Expect100Continue = false;

            //sprawdzić url
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlFirmware + API_KEY);
            request.ContentLength = 0;
            request.ContentType = "application/json";
            request.MediaType = "application/json";

            byte[] authBytes = Encoding.UTF8.GetBytes(userAndPassword.ToCharArray());
            request.Headers.Add(HttpRequestHeader.Authorization, String.Format("Basic {0}", Convert.ToBase64String(authBytes)));

            try
            {
                var webresponse = request.GetResponse();
                string content = CreateStringContent(webresponse);
                ParserJson parser = new ParserJson(dev, configs, groups, firmwaresHistory, newfirmwares, vbdev, vbf);

                List<newFirmware> firms = parser.ParseJsonFirmware(content);

                newFirmware n1 = new newFirmware();
                newFirmware n2 = new newFirmware();

                n1.versionNumber = "10e";
                n2.versionNumber = "10f";

                firms.Add(n1);
                firms.Add(n2);

                List<string> verNumbList = new List<string>();

                foreach (newFirmware firm in firms)
                {
                    verNumbList.Add(firm.versionNumber);
                }

                if (verNumbList != null)
                {

                    FirmList.DataSource = verNumbList;
                }
                else
                {
                    MessageBox.Show(this, "Server error - no firmware.", "Error");
                }
            }
            catch (WebException ex)
            {
                Console.WriteLine(ex.Response);
                MessageBox.Show(this, "Server error - no firmware.", "Error");
            }

        }

        private void GetListOfGroups()
        {
            ServicePointManager.ServerCertificateValidationCallback = ((sender2, certificate, chain, sslPolicyErrors) => true);
            ServicePointManager.Expect100Continue = false;

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlGroups + API_KEY);
            request.ContentLength = 0;
            request.ContentType = "application/json";
            request.MediaType = "application/json";

            byte[] authBytes = Encoding.UTF8.GetBytes(userAndPassword.ToCharArray());
            request.Headers.Add(HttpRequestHeader.Authorization, String.Format("Basic {0}", Convert.ToBase64String(authBytes)));

            try
            {
                var webresponse = request.GetResponse();
                string content = CreateStringContent(webresponse);
                ParserJson parser = new ParserJson(dev, configs, groups, firmwaresHistory, newfirmwares, vbdev, vbf);

                List<Group> grps = parser.ParseJsonGroups(content);

                List<string> nameList = new List<string>();

                foreach (Group gr in grps)
                {
                    nameList.Add(gr.name);
                }

                if (nameList != null)
                {

                   GroupList.DataSource = nameList;
                }
                else
                {
                    MessageBox.Show(this, "Server error - no groups.", "Error");
                }
            }
            catch (WebException ex)
            {
                Console.WriteLine(ex.Response);
                MessageBox.Show(this, "Server error - no groups.", "Error");
            }
        }

        private void GetListOfVBusFiles()
        {
            ServicePointManager.ServerCertificateValidationCallback = ((sender2, certificate, chain, sslPolicyErrors) => true);
            ServicePointManager.Expect100Continue = false;

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlVBusDevice.Remove(urlVBusDevice.Length - 1) + "file/" + vbusPlatformTextBox.Text + "/2" +  API_KEY);
            request.ContentLength = 0;
            request.ContentType = "application/json";
            request.MediaType = "application/json";

            byte[] authBytes = Encoding.UTF8.GetBytes(userAndPassword.ToCharArray());
            request.Headers.Add(HttpRequestHeader.Authorization, String.Format("Basic {0}", Convert.ToBase64String(authBytes)));

            try
            {
                var webresponse = request.GetResponse();
                string content = CreateStringContent(webresponse);
                ParserJson parser = new ParserJson(dev, configs, groups, firmwaresHistory, newfirmwares, vbdev, vbf);

                List<VBusFile> vbfiles = parser.ParseJsonVBusFiles(content);

                List<string> versionList = new List<string>();

                foreach (VBusFile v in vbfiles)
                {
                    versionList.Add(v.versionNumber);
                }

                if (versionList != null)
                {

                    VBusVersionList.DataSource = versionList;
                }
                else
                {
                    MessageBox.Show(this, "Server error - no file versions.", "Error");
                }
            }
            catch (WebException ex)
            {
                Console.WriteLine(ex.Response);
                MessageBox.Show(this, "Server error - no file versions.", "Error");
            }
        }

        internal void deviceDetails_Click(object sender, EventArgs e)
        {
            if (dev != null)
            {
                DeviceWindow details = new DeviceWindow(dev);
                details.Show();
            }
            else
                MessageBox.Show(this, "Please, load device first.", "Error");
        }



        internal void getGroups_Click(object sender, EventArgs e)
        {
            groupBox.DataSource = null;
            groupBox.Items.Clear();

            ServicePointManager.ServerCertificateValidationCallback = ((sender2, certificate, chain, sslPolicyErrors) => true);
            ServicePointManager.Expect100Continue = false;

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlGroups + API_KEY);
            request.ContentLength = 0;
            request.ContentType = "application/json";
            request.MediaType = "application/json";

            byte[] authBytes = Encoding.UTF8.GetBytes(userAndPassword.ToCharArray());
            request.Headers.Add(HttpRequestHeader.Authorization, String.Format("Basic {0}", Convert.ToBase64String(authBytes)));

            try
            {
                var webresponse = request.GetResponse();
                string content = CreateStringContent(webresponse);
                if (!content.Contains("Unable"))
                {
                    ParserJson parser = new ParserJson(dev, configs, groups, firmwaresHistory, newfirmwares, vbdev, vbf);
                    List<Group> gr = parser.ParseJsonGroups(content);
                    List<string> grName = new List<string>();
                    foreach (Group g in gr)
                    {
                        if (grName.Contains(g.name) == true) { }
                        else
                        {
                            grName.Add(g.name);
                        }
                    }
                    groupBox.DataSource = grName;
               }
               else
               {
                    MessageBox.Show(this, "Groups not found.", "Error");
               }
            }
            catch (WebException ex)
            {
                Console.WriteLine(ex.Response);
                MessageBox.Show(this, "Groups not found.", "Error");
            }
        }

        private void showDivButton_Click(object sender, EventArgs e)
        {

            ServicePointManager.ServerCertificateValidationCallback = ((sender2, certificate, chain, sslPolicyErrors) => true);
            ServicePointManager.Expect100Continue = false;

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlDevice.Remove(urlDevice.Length - 1) + "?group=" + groupBox.SelectedItem + API_KEY.Replace('?', '&'));
            request.ContentLength = 0;
            request.ContentType = "application/json";
            request.MediaType = "application/json";

            byte[] authBytes = Encoding.UTF8.GetBytes(userAndPassword.ToCharArray());
            request.Headers.Add(HttpRequestHeader.Authorization, String.Format("Basic {0}", Convert.ToBase64String(authBytes)));

            try
            {
                var webresponse = request.GetResponse();
                string content = CreateStringContent(webresponse);
                if (!content.Contains("Unable"))
                {
                    ParserJson parser = new ParserJson(dev, configs, groups, firmwaresHistory, newfirmwares, vbdev, vbf);
                    List<Device> dv = parser.ParseJsonDevices(content);
                    List<string> dvName = new List<string>();

                  foreach (Device d in dv)
                    {
                        if (dvName.Contains(d.mobileId) == true) { }
                        else
                        {
                            dvName.Add("modile Id: " + d.mobileId + "  (" + d.group + ")");
                        }
                    }
                    divBox.DataSource = dvName;
                }
                else
                {
                    MessageBox.Show(this, "Devices not found.", "Error");
                }
            }
            catch (WebException ex)
            {
                Console.WriteLine(ex.Response);
                MessageBox.Show(this, "Devices not found.", "Error");
            }
        }


        private void groupDetails_Click(object sender, EventArgs e)
        {
            if (groupBox.SelectedItem.ToString() != null)
            {
                string name = groupBox.SelectedItem.ToString();
                Group gr = groups.Find(x => x.name.Equals(name));
                idText.Text = gr.id.ToString();
                nameText.Text = gr.name;
                detailsBox.Visible = true;
            }
            else
                MessageBox.Show(this, "Please, select group to show the details.", "Error");
        }

        private void getInfoButton_Click(object sender, EventArgs e)
        {
            if (deviceESNbox_2.Text != null && deviceESNbox_2.Text != "")
            {
                ServicePointManager.ServerCertificateValidationCallback = ((sender2, certificate, chain, sslPolicyErrors) => true);
                ServicePointManager.Expect100Continue = false;

                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlVBusDevice + deviceESNbox_2.Text + API_KEY);
                request.ContentLength = 0;
                request.ContentType = "application/json";
                request.MediaType = "application/json";

                byte[] authBytes = Encoding.UTF8.GetBytes(userAndPassword.ToCharArray());
                request.Headers.Add(HttpRequestHeader.Authorization, String.Format("Basic {0}", Convert.ToBase64String(authBytes)));

                try
                {
                    var webresponse = request.GetResponse();
                    string content = CreateStringContent(webresponse);
                    if (content != "")
                    {
                        if (!content.Contains("Device Not Found"))
                        {
                            if (!content.Contains("Unable"))
                            {
                                ParserJson parser = new ParserJson(dev, configs, groups, firmwaresHistory, newfirmwares, vbdev, vbf);

                                vbdev = parser.ParseJsonVBus(content);
                                esnTextBox.Text = vbdev.esn;
                                mobileIdTextBox.Text = vbdev.mobileId;
                                vbusPlatformTextBox.Text = vbdev.vbusPlatform;
                                boardIdTextBox.Text = vbdev.boardId;
                                brdSerialNrTextBox.Text = vbdev.boardSerialNumber.ToString();
                                lastErrorTextBox.Text = vbdev.lastError.ToString();
                                deviceTypeTextBox.Text = vbdev.deviceType.ToString();
                                creationDateTextBox.Text = vbdev.creationDate.ToString();
                                lastReportTimeTextBox.Text = vbdev.lastIDReportTime.ToString();
                                lastReportTextBox.Text = vbdev.lastIDReport;

                                GetListOfVBusFiles();

                            }
                            else
                            {
                                MessageBox.Show(this, "VBus not found.", "Error");
                            }
                        }
                        else
                        {
                            MessageBox.Show(this, "VBus not found.", "Error");
                        }
                    }
                    else
                    {
                        MessageBox.Show(this, "VBus not found.", "Error");
                    }
                }
                catch (WebException ex)
                {
                    Console.WriteLine(ex.Response);
                    MessageBox.Show(this, "VBus not found.", "Error");
                }
               }
            else
            {
                MessageBox.Show(this, "Incorrect Device ID.", "Error");
            }

        }

        // uzupełnić o klasę VehicleBus - porównać z VBus
        private void getHistoryButton_Click(object sender, EventArgs e)
        {
            if (deviceESNbox_3.Text != null && deviceESNbox_3.Text != "")
            {
                ServicePointManager.ServerCertificateValidationCallback = ((sender2, certificate, chain, sslPolicyErrors) => true);
                ServicePointManager.Expect100Continue = false;

                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlVBusDevice + deviceESNbox_3.Text + API_KEY);
                request.ContentLength = 0;
                request.ContentType = "application/json";
                request.MediaType = "application/json";

                byte[] authBytes = Encoding.UTF8.GetBytes(userAndPassword.ToCharArray());
                request.Headers.Add(HttpRequestHeader.Authorization, String.Format("Basic {0}", Convert.ToBase64String(authBytes)));

                try
                {
                    var webresponse = request.GetResponse();
                    string content = CreateStringContent(webresponse);
                    if (content != "")
                    {
                        if (!content.Contains("Device Not Found"))
                        {
                            if (!content.Contains("Unable"))
                            {
                                ParserJson parser = new ParserJson(dev, configs, groups, firmwaresHistory, newfirmwares, vbdev, vbf);

                                dev = parser.ParseJsonDevice(content);

                                List<VBusFileHistory> filehistory = new List<VBusFileHistory>();
                                dev.vbusFileHistories = filehistory;

                                statusTextBox.Text = dev.vbusFileHistories[0].status.ToString();
                                fileTypeTexBox.Text = dev.vbusFileHistories[0].fileType.ToString();
                                downloadTextBox.Text = dev.vbusFileHistories[0].downloadFailure.ToString();
                                updateTextBox.Text = dev.vbusFileHistories[0].lastUpdateTime.ToString();

                            }
                            else
                            {
                                MessageBox.Show(this, "VBus not found.", "Error");
                            }
                        }
                        else
                        {
                            MessageBox.Show(this, "VBus not found.", "Error");
                        }
                    }
                    else
                    {
                        MessageBox.Show(this, "VBus not found.", "Error");
                    }
                }
                catch (WebException ex)
                {
                    Console.WriteLine(ex.Response);
                    MessageBox.Show(this, "VBus not found.", "Error");
                }
            }
            else
            {
                MessageBox.Show(this, "Incorrect Device ID.", "Error");
            }


    }
    }
}