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;



            switch ((string)parameter)
            {

                case "Epl.Prj":
                    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 = GetExeByCmdName("Epl").ExePath,
                    };
                    frmMainEplPrj.Show();
                    return;

                case "Epl.Pdf":
                    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 "Epl.PdfMgt":
                    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;

                case "Rdp.Mgt":
                    Lib.Guis.Rdp.Mgt.FrmMain frmRdpMain = new()
                    {
                        CloseAtLostFocus = true,
                        InputData = Global.AppSettings.Rdps,
                        Exe = GetExeByCmdName("Rdp").ExePath,
                        FrmTitle = "Remotedesktopverbindungen",
                    };
                    frmRdpMain.Show();
                    break;

                case "WebRadio":
                    //Lib.Guis.WebRadio.FrmMain frmWebRadio = new()
                    //{
                    //    CloseAtLostFocus = false,
                    //    InputData = Global.AppSettings.WebRadioUrls,
                    //};
                    //frmWebRadio.Show();
                    break;

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

            if (selectedCmd == null)
                return;

            OpenExe(selectedCmd);
            OpenUrl(selectedCmd);
        }

        public override bool CanExecute(object parameter)
        {
            if (parameter == null)
                return false;

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

            switch ((string)parameter)
            {
                case "Epl.Prj":
                    return true;

                case "Epl.Pdf":
                    return true;

                case "Epl.PdfMgt":
                    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;

                case "Rdp.Mgt":
                    return Global.AppSettings.Rdps != null;

                case "WebRadio":
                    return false;// Global.AppSettings.WebRadioUrls != null;

                default:
                    foreach (ICmd cmd in cmds)
                    {
                        if (String.Equals(parameter.ToString(), cmd.Cmd))
                            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;
                else if (File.Exists(Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), 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
            {
                var selectedFileExePath = string.Empty;
                if (File.Exists(Environment.ExpandEnvironmentVariables(selectedFile.ExePath.Trim())))
                    selectedFileExePath = Environment.ExpandEnvironmentVariables(selectedFile.ExePath.Trim());
                if (File.Exists(Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), selectedFile.ExePath.Trim())))
                    selectedFileExePath = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), selectedFile.ExePath.Trim());

                var abc = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), selectedFileExePath.Trim());
                Process process = new();
                process.StartInfo.FileName = selectedFileExePath;
                process.StartInfo.WorkingDirectory = selectedFile.Path ?? Path.GetDirectoryName(selectedFileExePath);
                process.StartInfo.Arguments = selectedFile.Arguments ?? string.Empty;

                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 IExe GetExeByCmdName(string cmdName)
        {
            foreach (var cmd in Global.AppSettings.Cmds)
            {
                if (string.Equals(cmd.Cmd, cmdName, StringComparison.InvariantCultureIgnoreCase))
                    return GetApp(cmd.Exe);
            }

            return null;
        }

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