using Chromium;
using Chromium.Remote;
using Chromium.Remote.Event;
using Chromium.WebBrowser;
using Client.Config;
using Client.Config.SubModels;
using Client.Utils;
using CMS_Client.Browser_Tools.Models;
using CMS_Client.View;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using static Client.Utils.Constants;

namespace CMS_Client.Browser_Tools
{
    public class BrowserJSObject : JSObject
    {
        //The first letter of All PUBLIC Variables and Methods must be Lower-Case (CEF Settings)

        private MainForm mainForm;
        private static readonly string[] _validExtensions = { "",".txt", ".cnc", ".ini", ".mpf", ".spf" };
        private static readonly string[] _validImages = { ".jpg", ".jpeg", ".png" };

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        #region CONSTRUCTOR_METHOD
        //Constructor Method
        public BrowserJSObject(MainForm f)
        {
            mainForm = f;

            AddFunction("minimizeForm").Execute += minimizeForm;
            AddFunction("maximizeForm").Execute += maximizeForm;
            AddFunction("closeForm").Execute += closeForm;
            AddFunction("forceStepFocus").Execute += forceStepFocus;
            AddFunction("reloadBrokenPage").Execute += reloadBrokenPage;

            AddFunction("setNcWindowState").Execute += setNcWindowState;
            AddFunction("getNcWindowState").Execute += getNcWindowState;
            AddFunction("getScreenBase64").Execute += getScreenBase64;
            AddFunction("getChromiumVersion").Execute += getChromiumVersion;
            AddFunction("getClientID").Execute += getClientID;
            AddFunction("getConfiguredProcesses").Execute += getConfiguredProcesses;
            AddFunction("startNewProcess").Execute += startNewProcess;
            AddFunction("openOrStartProcess").Execute += openOrStartProcess;
            AddFunction("isVirtualKeybConfigured").Execute += isVirtualKeybConfigured;
            AddFunction("sendHMICommand").Execute += sendHMICommand;
            AddFunction("getHMICommandCount").Execute += getHMICommandCount;
            AddFunction("getOSdriveList").Execute += getOSdriveList;
            AddFunction("getFileList").Execute += getFileList;
            AddFunction("getProgramInfo").Execute += getProgramInfo;

            AddFunction("uploadAndActivateProgram").Execute += uploadAndActivateProgram;
            AddFunction("uploadAndAddToQueue").Execute += uploadAndAddToQueue;

        }

        #endregion

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        #region FORM_BEHAVIOUR_METHODS

        //Minimize Main Window
        public void minimizeForm(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            //Invoke method if is needed or call the method in STD mode
            if (mainForm.InvokeRequired)
                mainForm.Invoke((MethodInvoker)delegate ()
                {
                    mainForm.WindowState = FormWindowState.Minimized;
                });

            else
            {
                mainForm.WindowState = FormWindowState.Minimized;
            }
        }



        //Maximize Main Window
        public void maximizeForm(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            //Invoke method if is needed or call the method in STD mode
            if (mainForm.InvokeRequired)
                mainForm.Invoke((MethodInvoker)delegate ()
                {
                    mainForm.WindowState = FormWindowState.Maximized;
                });

            else
            {
                mainForm.WindowState = FormWindowState.Maximized;
            }
        }



        //Close Main Window
        public void closeForm(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            //If the mainform is disposed do nothing
            if (mainForm.IsDisposed)
                return;

            //Invoke method if is needed or call the method in STD mode
            mainForm.Close();
        }

        //Reload Broken Page
        private void reloadBrokenPage(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            //Invoke method if is needed or call the method in STD mode
            mainForm.reloadBrokenPage();
        }

        #endregion

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        #region NC_BEHAVIOUR_METHODS

        public void setNcWindowState(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            if (e.Arguments.Count() == 0)
                return;

            NcWindow.SetState((NcState)e.Arguments[0].IntValue);

            if (NcWindow.State == NcState.SHOW)
                mainForm.ShowNCWindow();
            else
                mainForm.HideNCWindow();
        }

        public void getNcWindowState(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            e.SetReturnValue((int)NcWindow.State);
        }

        public void getScreenBase64(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            if (e.Arguments.Count() > 0 && e.Arguments[0].BoolValue)
                NcWindow.CaptureHMI();
            e.SetReturnValue(NcWindow.NcCapture);
        }

        //Send a command to HMI
        public void sendHMICommand(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            if (e.Arguments.Count() == 0)
                return;

            int val = e.Arguments[0].IntValue - 1;

            if (val < 0 || val > (NcWindow.NcWindowCommand.Count - 1))
                return;

            NcWindow.SendCommandKey(NcWindow.NcWindowCommand[val]);

            if (NcWindow.State == NcState.SHOW)
            {
                Thread.Sleep(1000);
                mainForm.HideNCWindow();
                mainForm.ShowNCWindow();
                NcWindow.ActivateNcWindow();
            }
        }

        //Get command vounts to HMI
        public void getHMICommandCount(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            e.SetReturnValue(NcWindow.NcWindowCommand.Count);
        }

        #endregion

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        #region CHROMIUM_METHODS

        //Get the Version of Chromium
        public void getChromiumVersion(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            e.SetReturnValue(CfxRuntime.GetChromeVersion());
        }

        #endregion

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        #region STEP_METHODS

        //Get the ID of STEP Client
        public void getClientID(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            e.SetReturnValue((int)Config.ConnectionConfig.Id);
        }

        public void forceStepFocus(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            NcWindow.ForceStepFocus();
        }

        //Get the option of virtual Keyb configured
        private void isVirtualKeybConfigured(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            e.SetReturnValue((Boolean)Config.ClientConfig.ShowVirtualKeyboard);
        }
        #endregion

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        #region PROCESSES_METHODS

        //Read all configured processes
        public void getConfiguredProcesses(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            e.SetReturnValue(JsonConvert.SerializeObject(Config.ExtSoftwaresConfig));
        }



        //Start a new process
        public void startNewProcess(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            if (e.Arguments.Count() == 0)
                return;

            Thread t = new Thread(new ParameterizedThreadStart(OpenNew));
            t.Start(e.Arguments[0].StringValue);
        }



        //Open the last window or Start a new process
        public void openOrStartProcess(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            if (e.Arguments.Count() == 0)
                return;

            Thread t = new Thread(new ParameterizedThreadStart(OpenStartNew));
            t.Start(e.Arguments[0].StringValue);
        }


        //Function used in Thread
        private void OpenStartNew(object id)
        {
            Software sft = Config.ExtSoftwaresConfig.FirstOrDefault(X => X.id == (string)id);

            if (sft != null)
            {
                Process[] p = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(sft.path)).OrderByDescending(X => X.StartTime).ToArray();

                if (p.Count() > 0 && p[0].MainWindowHandle != IntPtr.Zero)
                    NcWindow.ForceExtFocus(p[0].MainWindowHandle);
                else
                    Process.Start(sft.path, sft.arguments);
            }
        }


        //Function used in Thread
        private void OpenNew(object id)
        {
            Software sft = Config.ExtSoftwaresConfig.FirstOrDefault(X => X.id == (string)id);
            if (sft != null)
                Process.Start(sft.path, sft.arguments);
        }
        #endregion


        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        #region FILESYSTEM_METHODS

        //Read all drives in Operating System
        public void getOSdriveList(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            List<Drive> drivelist = new List<Drive>();

            foreach (var drive in DriveInfo.GetDrives())
            {
                if (drive.IsReady)
                    drivelist.Add(new Drive()
                    {
                        Name = ElaborateName(drive.VolumeLabel, drive.DriveType),
                        Path = drive.RootDirectory.ToString(),
                        Type = ElaborateType(drive.DriveType)
                    });
            }

            drivelist.Add(new Drive()
            {
                Name = ElaborateName("Desktop", DriveType.Unknown),
                Path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\",
                Type = "SPFO"
            });
            e.SetReturnValue(JsonConvert.SerializeObject(drivelist));
        }


        //Read all files in directory
        public void getFileList(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            List<Models.File> filelist = new List<Models.File>();
            if (e.Arguments.Count() == 0)
            {
                e.SetReturnValue(JsonConvert.SerializeObject(new List<Models.File>()));
                return;
            }

            String p = e.Arguments[0].StringValue;
            if (!Directory.Exists(p))
            {
                e.SetReturnValue(JsonConvert.SerializeObject(new List<Models.File>()));
                return;
            }

            try
            {
                foreach (String item in Directory.GetDirectories(p))
                {

                    filelist.Add(new Models.File
                    {
                        Name = Path.GetFileName(item),
                        AbsolutePath = Path.GetFullPath(item),
                        Path = Path.GetFullPath(item),
                        IsDirectory = true
                    });

                }
            }
            catch (Exception ex)
            {
            }
            try
            {
                foreach (String item in Directory.GetFiles(p))
                {
                    if (_validExtensions.Contains(Path.GetExtension(item).ToLower()))
                        filelist.Add(new Models.File
                        {
                            Name = Path.GetFileName(item),
                            AbsolutePath = Path.GetFullPath(item),
                            Path = Path.GetFullPath(item),
                            IsDirectory = false
                        });

                }
            }
            catch (Exception ex)
            {
            }

            e.SetReturnValue(JsonConvert.SerializeObject(filelist));
        }


        //Upload and activate the program
        public async void uploadAndActivateProgram(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            String fileToUpload = "";
            Byte[] filecontent = null, imagecontent = null;
            String fileNameNoExt;
            String imageName = "";
            String fileName;
            String imageDirectory;

            //Check the arguments numbers
            if (e.Arguments.Length < 1 || e.Arguments[0] == null)
            {
                e.SetReturnValue(Constants.Uploadpage +"INVALID_ARGUMENTS");
                return;
            }

            //Check if the file exists
            fileToUpload = e.Arguments[0].StringValue;
            if (!System.IO.File.Exists(fileToUpload))
            {
                e.SetReturnValue(Constants.Uploadpage+";FILE_NOT_FOUND");
                return;
            }

            //Get names and content of the file
            fileNameNoExt = Path.GetFileNameWithoutExtension(fileToUpload);
            fileName = Path.GetFileName(fileToUpload); ;
            filecontent = System.IO.File.ReadAllBytes(fileToUpload);

            //Get all bytes of the image (if exists)
            imageDirectory = Path.GetDirectoryName(fileToUpload);
            foreach (string ext in _validImages)
            {
                if (System.IO.File.Exists(imageDirectory + "/" + fileNameNoExt + ext))
                {
                    imageName = fileNameNoExt + ext;
                    imagecontent = System.IO.File.ReadAllBytes(imageDirectory + "/" + fileNameNoExt + ext);
                    break;
                }
            }

            //Send all to the server
            using (HttpClient httpClient = new HttpClient())
            {
                //Create the new FORM
                MultipartFormDataContent form = new MultipartFormDataContent();

                //Add the content to the form
                form.Add(new ByteArrayContent(filecontent), "file", fileName);
                if(imagecontent != null)
                    form.Add(new ByteArrayContent(imagecontent), "image", imageName);

                //Send them
                HttpResponseMessage response = httpClient.PostAsync(
                                                                          "http://" + Config.ConnectionConfig.ServerUrl + ":" + Config.ConnectionConfig.ServerPort + "/" + Constants.Uploadpage,
                                                                          form).Result;
                //Wait the answer
                if(response.StatusCode == System.Net.HttpStatusCode.BadRequest)
                    e.SetReturnValue(Constants.Uploadpage + ";" + await response.Content.ReadAsStringAsync());
                else if(response.StatusCode != System.Net.HttpStatusCode.OK)
                    e.SetReturnValue(Constants.Uploadpage + ";" + response.ReasonPhrase);
                else
                    e.SetReturnValue("");
            }

        }

        //Upload and add to queue
        public async void uploadAndAddToQueue(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            string fileToUpload = "";
            Byte[] filecontent = null, imagecontent = null;
            string fileNameNoExt;
            string imageName = "";
            string fileName;
            string imageDirectory;
            int reps = 0;

            //Check the arguments numbers
            if (e.Arguments.Length < 1 || e.Arguments[0] == null)
            {
                e.SetReturnValue(Constants.UPLOAD_ADD_QUEUE + "INVALID_ARGUMENTS");
                return;
            }

            //Check if the file exists
            fileToUpload = e.Arguments[0].StringValue;
            reps = e.Arguments[1].IntValue;

            if (!System.IO.File.Exists(fileToUpload))
            {
                e.SetReturnValue(Constants.UPLOAD_ADD_QUEUE + ";FILE_NOT_FOUND");
                return;
            }

            //Get names and content of the file
            fileNameNoExt = Path.GetFileNameWithoutExtension(fileToUpload);
            fileName = Path.GetFileName(fileToUpload); ;
            filecontent = System.IO.File.ReadAllBytes(fileToUpload);

            //Get all bytes of the image (if exists)
            imageDirectory = Path.GetDirectoryName(fileToUpload);
            foreach (string ext in _validImages)
            {
                if (System.IO.File.Exists(imageDirectory + "/" + fileNameNoExt + ext))
                {
                    imageName = fileNameNoExt + ext;
                    imagecontent = System.IO.File.ReadAllBytes(imageDirectory + "/" + fileNameNoExt + ext);
                    break;
                }
            }

            //Send all to the server
            using (HttpClient httpClient = new HttpClient())
            {
                //Create the new FORM
                MultipartFormDataContent form = new MultipartFormDataContent();

                //Add the content to the form
                form.Add(new ByteArrayContent(filecontent), "file", fileName);
                if (imagecontent != null)
                    form.Add(new ByteArrayContent(imagecontent), "image", imageName);

                form.Add(new StringContent(reps.ToString()), "reps");

                //Send them
                HttpResponseMessage response = httpClient
                    .PostAsync("http://" + Config.ConnectionConfig.ServerUrl + ":" + Config.ConnectionConfig.ServerPort + "/" + Constants.UPLOAD_ADD_QUEUE,
                               form)
                               .Result;
                //Wait the answer
                if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
                    e.SetReturnValue(Constants.UPLOAD_ADD_QUEUE + ";" + await response.Content.ReadAsStringAsync());
                else if (response.StatusCode != System.Net.HttpStatusCode.OK)
                    e.SetReturnValue(Constants.UPLOAD_ADD_QUEUE + ";" + response.ReasonPhrase);
                else
                    e.SetReturnValue("");
            }

        }


        //Read info of a file
        public void getProgramInfo(object sender, CfrV8HandlerExecuteEventArgs e)
        {
            InfoFile file = new InfoFile();
            string line, imagePath, imageDirectory;
            int counter = 0;

            if (e.Arguments.Count() == 0)
            {
                e.SetReturnValue(JsonConvert.SerializeObject(new InfoFile()));
                return;
            }

            String p = e.Arguments[0].StringValue;
            if (!System.IO.File.Exists(p))
            {
                e.SetReturnValue(JsonConvert.SerializeObject(new InfoFile()));
                return;
            }

            FileInfo f = new FileInfo(p);
            file.Name = f.Name;
            file.CreationDate = f.CreationTime;
            file.LastModDate = f.LastAccessTime;
            file.AbsolutePath = p;
            imagePath = Path.GetFileNameWithoutExtension(p);
            imageDirectory = Path.GetDirectoryName(p);

            file.Content = new List<string>();
            try
            {

                StreamReader fileRead = new StreamReader(p);
                while ((line = fileRead.ReadLine()) != null && counter < 10)
                {
                    file.Content.Add(line);
                    counter++;
                }
                fileRead.Close();

                foreach (string ext in _validImages)
                {
                    if (System.IO.File.Exists(imageDirectory + "/" + imagePath + ext))
                    {
                        file.PreviewBase64 = "data:image/" + ext + ";base64," + Convert.ToBase64String(System.IO.File.ReadAllBytes(imageDirectory + "/" + imagePath + ext));
                        break;
                    }
                }

            }
            catch (Exception ex)
            {
            }

            e.SetReturnValue(JsonConvert.SerializeObject(file));
        }


        //Private functions...
        private String ElaborateName(String name, DriveType type)
        {
            if (!String.IsNullOrWhiteSpace(name))
                return name;
            else
            {
                switch (type)
                {
                    case DriveType.Fixed: return "Hard_Disk";
                    case DriveType.Removable: return "Usb_Disk";
                    case DriveType.Network: return "Netword_Disk";
                }
                return "Undefined Drive";
            }

        }

        private String ElaborateType(DriveType type)
        {
            switch (type)
            {
                case DriveType.Fixed: return "HD";
                case DriveType.Removable: return "USB";
                case DriveType.Network: return "NTW";
            }
            return "SPFO";

        }

        #endregion
    }
}