using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows;
using static FSI.BT.Tools.Settings.Cmd;
using static FSI.BT.Tools.Settings.Exe;

namespace FSI.BT.Tools.Commands
{
    /// <summary>
    /// Shows the main window.
    /// </summary>
    public class CmdCommand : CommandBase<CmdCommand>
    {
        public override void Execute(object parameter)
        {
            if (parameter is not string)
            {
                Global.Log.Error("Parameter ist kein String");
                return;
            }

            var cmds = Global.AppSettings.Cmds.ToList();
            ICmd selectedCmd = null;

            // IEnumerable<Settings.Exe.IExe> files = new List<Settings.Exe.IExe>();
            IExe selectedFile;

            switch ((string)parameter)
            {
               
                case "EplPrj":
                    //selectedFile = GetApp(Global.AppSettings.Apps.Epl);
                    //Lib.Guis.Prj.Mgt.FrmMain frmMainEplPrj = new()
                    //{
                    //    ShowPdf = false,
                    //    CloseAtLostFocus = true,
                    //    WindowStartupLocation = WindowStartupLocation.CenterScreen,
                    //    Path = FSI.BT.Tools.Settings.AppSettings.GetFolderByName(Global.AppSettings.Folders, "EplPrj").path,
                    //    EplExe = selectedFile.ExePath,
                    //};
                    //frmMainEplPrj.Show();
                    return;

                case "EplPdf":
                    Lib.Guis.Prj.Mgt.FrmMain frmMainEplPdf = new()
                    {
                        ShowPdf = true,
                        CloseAtLostFocus = true,
                        WindowStartupLocation = WindowStartupLocation.CenterScreen,
                        Path = FSI.BT.Tools.Settings.AppSettings.GetFolderByName(Global.AppSettings.Folders, "EplPdf").path
                    };
                    frmMainEplPdf.Show();
                    return;

                case "EplPdfMgt":
                    Lib.Guis.Pdf.Mgt.FrmMain frmMainEplPdfMgt = new()
                    {
                        CloseAtLostFocus = true
                    };
                    frmMainEplPdfMgt.Show();
                    return;

                case "DeEncrypt":
                    Lib.Guis.DeEncryptMessage.FrmMain frmMainDeEnCrypt = new()
                    {
                        Password = AppDomain.CurrentDomain.FriendlyName,
                        CloseAtLostFocus = true,
                        WindowStartupLocation = WindowStartupLocation.CenterScreen,
                    };
                    frmMainDeEnCrypt.Show();
                    return;

                case "StarterCsvExporter":
                    Lib.Guis.SieStarterCsvExporter.FrmMain frmMain = new();
                    frmMain.Show();
                    return;

                case "Folder":
                    Lib.Guis.Folder.Mgt.FrmMain frmFolderMgtMain = new()
                    {
                        CloseAtLostFocus = true,
                        Data = Global.AppSettings.Folders
                    };
                    frmFolderMgtMain.Show();
                    return;

                case "TxtToClip":
                    Lib.Guis.TxtToClip.Mgt.FrmMain frmTxtToClipMain = new()
                    {
                        CloseAtLostFocus = true,
                        InputData = Global.AppSettings.TxtToClip
                    };
                    frmTxtToClipMain.Show();
                    return;
      
                default:
                    foreach (ICmd cmd in cmds)
                    {
                        if (String.Equals(parameter.ToString().ToLower(), cmd.Cmd.ToLower()))
                        {
                            selectedCmd = cmd;
                        }
                    }
                    break;
            }

            if (selectedCmd == null)
                return;

            OpenExe(selectedCmd);
            OpenUrl(selectedCmd);
        }

        public override bool CanExecute(object parameter)
        {
            var cmds = Global.AppSettings.Cmds.ToList();
            ICmd selectedCmd = null;

            switch ((string)parameter)
            {                       
                case "EplPrj":
                    return true;

                case "EplPdf":
                    return true;

                case "EplPdfMgt":
                    return Global.AdminRights;

                case "DeEncrypt":
                    return Global.AdminRights;

                case "StarterCsvExporter":
                    return Global.AdminRights;

                case "Folder":
                    return Global.AppSettings.Folders != null;

                case "TxtToClip":
                    return Global.AppSettings.TxtToClip != null;

                default:
                    foreach (ICmd cmd in cmds)
                    {
                        if (String.Equals(parameter.ToString().ToLower(), cmd.Cmd.ToLower()))
                        {
                            selectedCmd = cmd;
                        }
                    }
                    break; 

            }

            if (selectedCmd == null)
                return false;

            foreach (var file in selectedCmd.Exe.ToList())
            {
                if (File.Exists(Environment.ExpandEnvironmentVariables(file.ExePath.Trim())))
                {
                    return true;
                }
            }

            foreach (var url in selectedCmd.Urls)
            {
                if (url != String.Empty)
                {
                    return true;
                }
            }

            return false;
        }


        private static void  OpenExe(ICmd selectedCmd)
        {             
            IExe selectedFile = GetApp(selectedCmd.Exe);

            if (selectedFile == null)
                return;

            if (selectedFile.ExePath == String.Empty)
                return;

            if (ProgramIsRunning(selectedFile.ExePath))
            {
                ProgramToFront(selectedFile.ExePath);
                Global.Log.Info("Anwendung \"{0}\" wurde in den Vordergrund gebracht", selectedFile.ExePath);
            }
            else
            {
                Process process = new();
                process.StartInfo.FileName = selectedFile.ExePath;
                process.StartInfo.WorkingDirectory = selectedFile.Path == null ? selectedFile.Path : Path.GetDirectoryName(selectedFile.ExePath);
                process.StartInfo.Arguments = selectedFile.Arguments;

                try
                {

                    process.Start();
                    Global.Log.Info("Anwendung \"{0}\" wurde gestartet", selectedFile.ExePath);
                }
                catch (System.ComponentModel.Win32Exception ex) when (ex.NativeErrorCode == 740)
                {
                    try
                    {
                        process.StartInfo.UseShellExecute = true;
                        process.StartInfo.Verb = "runas";
                        process.Start();
                        Global.Log.Info("Anwendung \"{0}\" wurde als Admin gestartet", selectedFile.ExePath);
                    }
                    catch (Exception ex2)
                    {
                        Global.Log.Info("Anwendung konnte durch folgenden Fehler \"{0}\" nicht gestartet werden.", ex2.Message);
                    }
                }
            }
        }

        private static void OpenUrl(ICmd selectedCmd)
        {

            foreach (var url in selectedCmd.Urls)
            {

                if (url == String.Empty)
                    return;

                Process.Start(new ProcessStartInfo(url.Replace("&", "^&")) { UseShellExecute = true });
                Global.Log.Info("Link \"{0}\" wurde geföffnet.", url.Replace("&", "^&"));
                Thread.Sleep(100);
            }
        }
      
        private static bool ProgramIsRunning(string FullPath)
        {
            string FilePath = Path.GetDirectoryName(FullPath);
            string FileName = Path.GetFileNameWithoutExtension(FullPath).ToLower();
            bool isRunning = false;

            Process[] pList = Process.GetProcessesByName(FileName);

            foreach (Process p in pList)
            {
                if (p.MainModule.FileName.StartsWith(FilePath, StringComparison.InvariantCultureIgnoreCase))
                {
                    isRunning = true;
                    break;
                }
            }

            return isRunning;
        }

        private static IExe GetApp(IEnumerable<IExe> files)
        {
            if(files.ToList().Count == 0)          
                return null;

            var selectedFile = files.ToList()[0];

            foreach (var file in files.ToList())
            {
                if (File.Exists(Environment.ExpandEnvironmentVariables(file.ExePath.Trim())))
                    selectedFile = (IExe)file;
                else
                    continue;
            }

            return selectedFile;
        }

        [System.Runtime.InteropServices.DllImport("User32.dll")]
        private static extern bool SetForegroundWindow(IntPtr handle);
        [System.Runtime.InteropServices.DllImport("User32.dll")]
        private static extern bool ShowWindow(IntPtr handle, int nCmdShow);
        [System.Runtime.InteropServices.DllImport("User32.dll")]
        private static extern bool IsIconic(IntPtr handle);

        private static void ProgramToFront(string FullPath)
        {
            string FilePath = Path.GetDirectoryName(FullPath);
            string FileName = Path.GetFileNameWithoutExtension(FullPath).ToLower();

            Process[] pList = Process.GetProcessesByName(FileName);

            foreach (Process p in pList)
            {
                if (p.MainModule.FileName.StartsWith(FilePath, StringComparison.InvariantCultureIgnoreCase))
                {
                    IntPtr handle = p.MainWindowHandle;
                    if (IsIconic(handle))
                    {
                        ShowWindow(handle, 9);
                    }
                    SetForegroundWindow(handle);
                    break;
                }
            }
        }
    }
}