using Chromium;
using Chromium.Remote;
using Chromium.Remote.Event;
using Chromium.WebBrowser;
using Client.Config;
using Client.Config.SubModels;
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.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" }; 
        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;        

        }

        #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),
                        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),
                            IsDirectory = false
                        });

                }
            }
            catch (Exception ex)
            {
            }            

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


        //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;
            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
    }
}