using DeviceId;
using EgwControlCenter.Core.DTO;
using EgwControlCenter.Core.Models;
using EgwCoreLib.Utils;
using Newtonsoft.Json;
using NLog;
using System.Diagnostics;
using System.IO.Compression;
using System.Reflection;

namespace EgwControlCenter.Core
{
    public class AppControlService : IAppControlService
    {
        #region Public Fields

        /// <summary>
        /// DataOra ultimo controllo effettuato
        /// </summary>
        private DateTime lastCheckDone = DateTime.Today.AddMonths(-1);

        #endregion Public Fields

        #region Public Constructors

        public AppControlService()
        {
            try
            {
                Assembly assembly = Assembly.GetExecutingAssembly();
                string startDir = Path.GetDirectoryName(assembly.Location)!;
                ConfDir = startDir;
                //DataDir = Environment.GetEnvironmentVariable("ClickOnce_DataDirectory") ?? startDir;
                string appData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
                if (string.IsNullOrEmpty(appData))
                {
                    appData = "C:\\ProgramData";
                }
                DataDir = Path.Combine(appData, "EgalWare", "AppControlCenter");
                Log.Trace($"appData: {appData} | EnvData: {Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData)}");
                // verifico esistenza directory...
                Directory.CreateDirectory(DataDir);
                CurrCheck = new ReleaseChecker(ConfDir, DataDir);
                Log.Trace($"Folder Setup | {ConfDir} | {DataDir}");
            }
            catch (Exception exc)
            {
                Log.Error($"Error in AppControlService.init:{Environment.NewLine}{exc}");
            }
        }

        #endregion Public Constructors

        #region Public Events

        /// <summary>
        /// Evento update configurazione
        /// </summary>
        public event Action EA_ConfigUpdated = null!;

        /// <summary>
        /// Evento calling a remote in corso
        /// </summary>
        public event Action EA_RemoteCalling = null!;

        /// <summary>
        /// Evento udpate status controlli
        /// </summary>
        public event Action EA_StatusUpdated = null!;

        #endregion Public Events

        #region Public Properties

        public string AppKey
        {
            get => CurrCheck.CurrPatrolCont.AppKey;
            set
            {
                if (CurrCheck.CurrPatrolCont.AppKey != value)
                {
                    // verifico ammissibilità
                    CurrCheck.CurrPatrolCont.AppKey = value;
                    ReportConfigUpd();
                }
            }
        }

        /// <summary>
        /// verifica autorizzazione al canale, ovvero
        /// - deve avere tutte le chiavi/registri di comunicazione
        /// - CodImpiego e AppKey devono essere validate
        /// </summary>
        public bool ChannelAuth
        {
            get
            {
                // in primis deve avere i dati di configurazione
                bool answ = CurrCheck.CurrPatrolCont.HasCommData;
                if (answ)
                {
                    // verifico CodImpiego locale sia valido
                    answ = CurrCheck.CurrPatrolCont.CodImpiego == SubLicManager.CodImpiego();
                    // verifica sia valida (scadenza a tempo da ultimo controllo) chiave auth in remoto
                    if (answ)
                    {
                    }
                }
                return answ;
            }
        }

        public bool CloudCallActive
        {
            get => cloudCallActive;
            set
            {
                if (cloudCallActive != value)
                {
                    cloudCallActive = value;
                    ReportRemoteCall();
                }
            }
        }

        public string CodApp
        {
            get => CurrCheck.CurrPatrolCont.CodApp;
            set
            {
                if (CurrCheck.CurrPatrolCont.CodApp != value)
                {
                    // verifico ammissibilità
                    CurrCheck.CurrPatrolCont.CodApp = value;
                    ReportConfigUpd();
                }
            }
        }

        public string CodImpiego
        {
            get => CurrCheck.CurrPatrolCont.CodImpiego;
            set
            {
                if (CurrCheck.CurrPatrolCont.CodImpiego != value)
                {
                    // verifico ammissibilità
                    CurrCheck.CurrPatrolCont.CodImpiego = value;
                    ReportConfigUpd();
                }
            }
        }

        /// <summary>
        /// Dir applicazione
        /// </summary>
        public string DataDir { get; set; } = "";

        public List<VersStatusDTO> ListAppStatus
        {
            get => CurrCheck.ListAppStatus;
            set
            {
                CurrCheck.ListAppStatus = value;
                ReportStatusUpd();
            }
        }

        public string MainKey
        {
            get => CurrCheck.CurrPatrolCont.MainKey;
            set
            {
                if (CurrCheck.CurrPatrolCont.MainKey != value)
                {
                    // verifico ammissibilità
                    CurrCheck.CurrPatrolCont.MainKey = value;
                    ReportConfigUpd();
                }
            }
        }

        public int RefreshPeriod
        {
            get => CurrCheck.CurrPatrolCont.RefreshIntSec;
            set
            {
                if (CurrCheck.CurrPatrolCont.RefreshIntSec != value)
                {
                    // verifico ammissibilità
                    CurrCheck.CurrPatrolCont.RefreshIntSec = value < refPMin ? refPMin : value > refPMax ? refPMax : value;
                    ReportConfigUpd();
                }
            }
        }

        public List<ControlTarget> TargetList
        {
            get => CurrCheck.CurrPatrolCont.TargetList;
            set
            {
                CurrCheck.CurrPatrolCont.TargetList = value;
                ReportConfigUpd();
            }
        }

        /// <summary>
        /// num minuti veto controllo COMPLETO
        /// </summary>
        public int VetoCheck
        {
            get => CurrCheck.CurrPatrolCont.VetoCheckMinutes;
            set
            {
                if (CurrCheck.CurrPatrolCont.VetoCheckMinutes != value)
                {
                    // verifico ammissibilità
                    CurrCheck.CurrPatrolCont.VetoCheckMinutes = value < vetoPMin ? vetoPMin : value > vetoPMax ? vetoPMax : value;
                    ReportConfigUpd();
                }
            }
        }

        /// <summary>
        /// num minuti veto controllo refresh
        /// </summary>
        public int VetoRefresh
        {
            get => CurrCheck.CurrPatrolCont.VetoRefreshMinutes;
        }

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Verifica se sia stato assegnato il codice licenza x una richiesta di enroll e nel caso recupera licenza e restituisce il codice da salvare in conf
        /// </summary>
        /// <returns></returns>
        public async Task<string> CheckAssignIdxLic()
        {
            string tVal = "";
            // verifico dati richeista enroll, altrimenti faccio refresh richiesta...
            if (CurrEnrollData.IdReq == 0)
            {
                int newCode = await GetAuthPassocde();
            }

            CloudCallActive = true;
            // recupero info
            EnrollRequestDTO updRec = await CurrCheck.CheckCurrEnroll();
            if (updRec.IdReq > 0)
            {
                CurrEnrollData = updRec;
                // se la licenza è valida --> procedo!
                if (updRec.IdxLic > 0)
                {
                    LicenzaDTO currLic = await CurrCheck.GetEnrollLic();
                    // se licenza valida --> restituisco e salvo!
                    if (currLic.IsValid && currLic.IsActive && !string.IsNullOrEmpty(currLic.Chiave))
                    {
                        tVal = currLic.Chiave;
                        CurrCheck.CurrPatrolCont.MainKey = currLic.Chiave;
                        // Ricalcolo valori subLic...
                        ResetSubLic(true, true);
                        await Task.Delay(10);
                        // verifico attivazioni
                        bool fatto = await CheckAttivazioni();
                        // ... e salvo
                        DoSaveConfig();
                    }
                }
            }
            CloudCallActive = false;
            return tVal;
        }

        public async Task<bool> CheckAttivazioni()
        {
            bool fatto = await CurrCheck.CheckAttivazioni();
            return fatto;
        }

        /// <summary>
        /// Effettua un controllo completo (loacele remoto)
        /// </summary>
        /// <param name="doForce">se true esegue anche prima della scadenza veto</param>
        public async Task DoFullCheckAsync(bool doForce)
        {
            DateTime adesso = DateTime.Now;
            if (lastCheckDone.AddMinutes(VetoRefresh) < adesso || doForce)
            {
                lastCheckDone = adesso;
                //se non è forzato controllo ultimo check
                CloudCallActive = true;
                // in primis controllo se il remote è ok sennò mi fermo...
                bool remoteOk = await CurrCheck.CheckRemote();
                if (remoteOk)
                {
                    // effettua un refresh del controllo status...
                    bool locCheckOk = CurrCheck.UpdateLocalStatus(doForce);
                    bool remCheckOk = false;
                    bool critCheckOk = false;
                    if (locCheckOk)
                    {
                        remCheckOk = await CurrCheck.CheckRemoteReleases();
                    }
                    // infine effettua una verifica dello status "release critiche"
                    critCheckOk = await CurrCheck.CheckCriticalReport();
                    if (remCheckOk || critCheckOk)
                    {
                        ReportStatusUpd();
                    }
                }
                CloudCallActive = false;
            }
        }

        /// <summary> Effettua rilettura configurazione e setup controlli... </summary
        public void DoReloadConfig()
        {
            try
            {
                CurrCheck = new ReleaseChecker(ConfDir, DataDir);
                Log.Trace($"Riletta config Setup | {ConfDir} | {DataDir}");
            }
            catch (Exception exc)
            {
                Log.Equals($"Eccezione in DoReloadConfig{Environment.NewLine}{exc}");
            }
            ReportConfigUpd();
        }

        /// <summary>
        /// Effettua salvataggio configurazione
        /// </summary>
        public void DoSaveConfig()
        {
            try
            {
                var rawData = JsonConvert.SerializeObject(CurrCheck.CurrPatrolCont, Formatting.Indented);
                if (rawData != null && rawData.Length > 2)
                {
                    File.WriteAllText(CurrCheck.ConfPath, rawData);
                    Log.Trace($"Effettuato salvataggio Config Setup! | {ConfDir} | {DataDir}");
                }
            }
            catch (Exception exc)
            {
                Log.Equals($"Eccezione in DoSaveConfig{Environment.NewLine}{exc}");
            }
            ReportConfigUpd();
        }

        /// <summary>
        /// Restituisce un codice di auth temporaneo INT da impiegare x autorizzare
        /// </summary>
        /// <returns></returns>
        public async Task<int> GetAuthPassocde()
        {
            int tVal = 0;
            //verifico che NON ci sia una richiesta già in corso...
            if (CurrEnrollData.IdReq == 0)
            {
                // in primis preparo dizionario dei dati da allegare alla richiesta
                Dictionary<string, string> reqInfo = new Dictionary<string, string>();
                // preparo dati DeviceId da allegare in coda
                string deviceId = new DeviceIdBuilder()
                            .AddMachineName()
                            .AddUserName()
                            .AddOsVersion()
                            .OnWindows(windows => windows
                                .AddMacAddressFromWmi(excludeWireless: true, excludeNonPhysical: true)
                                .AddProcessorId()
                                .AddMotherboardSerialNumber()
                                .AddSystemDriveSerialNumber())
                            .ToString();
                // aggiungo dati MachineInfo...
                reqInfo = MachineDataValidator.userInfo;
                foreach (var item in MachineDataValidator.netInfo)
                {
                    if (!reqInfo.ContainsKey(item.Key))
                    {
                        reqInfo.Add(item.Key, item.Value);
                    }
                }
                // raggiungo DevideID
                reqInfo.Add("DeviceID", deviceId);

                CloudCallActive = true;
                // faccio la chiamata rest e salvo risposta...
                CurrEnrollData = await CurrCheck.GetNewEnroll(reqInfo);
                CloudCallActive = false;
            }

            // risposta valida se trovo un id richeista > 0...
            if (CurrEnrollData.IdReq > 0)
            {
                tVal = CurrEnrollData.Passcode;
            }
            return tVal;
        }

        /// <summary>
        /// Metodo update specifico x app IobWin a step
        /// </summary>
        /// <param name="reqApp"></param>
        /// <param name="step">Step richiesto: 1=backup conf, 2=download, 3=unzip, $=fix conf e close</param>
        /// <returns></returns>
        public async Task IobWinUpdateStep(VersStatusDTO reqApp, int step)
        {
            // eseguo step secondo richiesta...
            switch (step)
            {
                case 1:
                    await IobWinDoBackup(reqApp);
                    break;

                case 2:
                    await IobWinDownload(reqApp);
                    break;

                case 3:
                    await IobWinUnzip(reqApp);
                    break;

                case 4:
                    await IobWinRestoreConf(reqApp);
                    break;

                default:
                    break;
            }
        }

        public void ResetConf()
        {
            bool fatto = CurrCheck.ResetConf();
            if (fatto)
            {
                ReportConfigUpd();
                ReportStatusUpd();
            }
        }

        /// <summary>
        /// Reimposta CodImpiego / AppKey da librerie Egw secondo richiesta...
        /// </summary>
        /// <param name="resCodImpiego"></param>
        /// <param name="resAppKey"></param>
        public void ResetSubLic(bool resCodImpiego, bool resAppKey)
        {
            if (resCodImpiego)
            {
                CurrCheck.CurrPatrolCont.CodImpiego = SubLicManager.CodImpiego();
            }
            if (resAppKey)
            {
                CurrCheck.CurrPatrolCont.AppKey = SubLicManager.GenKey(CodApp);
            }
            ReportConfigUpd();
        }

        #endregion Public Methods

        #region Protected Fields

        protected UpdateMan updateMan = new UpdateMan();
        protected UpdateMan updateManAuth = new UpdateMan("SWDownloader", "viaD@nte16");

        #endregion Protected Fields

        #region Protected Properties

        protected SubLicManager SubLicManager { get; set; } = new SubLicManager();

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Helper copia directory + contenuto
        /// </summary>
        /// <param name="sourceDir"></param>
        /// <param name="destDir"></param>
        protected void CopyDirectory(string sourceDir, string destDir)
        {
            // Create the destination directory if it doesn't exist
            if (!Directory.Exists(destDir))
            {
                Directory.CreateDirectory(destDir);
            }

            // copio SOLO SE ho la dir di partenza
            if (Directory.Exists(sourceDir))
            {
                // Copy all files
                foreach (var file in Directory.GetFiles(sourceDir))
                {
                    string destFile = Path.Combine(destDir, Path.GetFileName(file));
                    File.Copy(file, destFile, true);
                }

                // Copy all subdirectories
                foreach (var dir in Directory.GetDirectories(sourceDir))
                {
                    string destSubDir = Path.Combine(destDir, Path.GetFileName(dir));
                    CopyDirectory(dir, destSubDir);
                }
            }
        }

        #endregion Protected Methods

        #region Private Fields

        /// <summary>
        /// Classe logger
        /// </summary>
        private static Logger Log = LogManager.GetCurrentClassLogger();

        /// <summary>
        /// Directory di backup x IobWin
        /// </summary>
        private string backupDir = @"C:\Steamware\backup";

        /// <summary>
        /// Valore massimo ammesso refresh sec
        /// </summary>
        private int refPMax = 3600;

        /// <summary>
        /// Valore minimo ammesso refresh sec
        /// </summary>
        private int refPMin = 1;

        private Random rnd = new Random();

        /// <summary>
        /// Directory temp di appoggio
        /// </summary>
        private string tempDir = @"C:\Steamware\temp";

        /// <summary>
        /// File segnaposto x lock fasi di update
        /// </summary>
        private string updFilePath = @"c:\Steamware\IOB-MAN\update.run";

        /// <summary>
        /// Valore massimo ammesso veto minuti
        /// </summary>
        private int vetoPMax = 14400;

        /// <summary>
        /// Valore minimo ammesso veto minuti
        /// </summary>
        private int vetoPMin = 30;

        /// <summary>
        /// Ms di attesa x uscita processo (std)
        /// </summary>
        private int waitForExitMsec = 250;

        #endregion Private Fields

        #region Private Properties

        private bool cloudCallActive { get; set; } = false;

        private string ConfDir { get; set; } = "";

        private ReleaseChecker CurrCheck { get; set; } = null!;

        /// <summary>
        /// Richiesta enroll corrente (se presente come file oppure nuova...)
        /// </summary>
        private EnrollRequestDTO CurrEnrollData
        {
            get => CurrCheck.CurrEnrollData;
            set => CurrCheck.CurrEnrollData = value;
        }

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Elimina contenuto directory
        /// </summary>
        /// <param name="directoryPath"></param>
        private void DeleteDirectoryContents(string directoryPath)
        {
            // recupero info dir
            DirectoryInfo directory = new DirectoryInfo(directoryPath);
            // elimina file
            foreach (FileInfo file in directory.GetFiles())
            {
                file.Delete();
            }
            // elimina ulteriori directory
            foreach (DirectoryInfo subDirectory in directory.GetDirectories())
            {
                subDirectory.Delete(true);
            }
        }

        /// <summary>
        /// Effettua un force kill dato nome processo
        /// </summary>
        /// <param name="nomeProc"></param>
        private void ForceKillByName(string nomeProc)
        {
            Process[] stillRunningProc = Process.GetProcessesByName(nomeProc);
            if (stillRunningProc != null)
            {
                if (stillRunningProc.Length > 0)
                {
                    foreach (var item in stillRunningProc)
                    {
                        try
                        {
                            Process p = Process.GetProcessById(item.Id);
                            {
                                if (!p.HasExited)
                                {
                                    p.Kill();
                                    p.WaitForExit(waitForExitMsec);
                                }
                                if (!p.HasExited)
                                {
                                    Log.Error($"Process not Killed, 2nd try p.kill()");
                                    p.Kill();
                                    p.WaitForExit(waitForExitMsec * 2);
                                }
                                if (!p.HasExited)
                                {
                                    Log.Error($"Process not Killed, 3th try p.kill()");
                                    p.Kill();
                                }
                            }
                        }
                        catch (Exception exc)
                        {
                            Log.Error($"Errore in fase di kill processo da nome {exc}");
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Step preliminare di backup conf e app corrente
        /// </summary>
        /// <param name="reqApp"></param>
        /// <returns></returns>
        private async Task IobWinDoBackup(VersStatusDTO reqApp)
        {
            // controllo di avere un file di riferimento...
            string appDir = Path.GetDirectoryName(reqApp.LocalPath) ?? "";
            if (!string.IsNullOrEmpty(appDir))
            {
                string tempZip = Path.Combine(tempDir, "FULL", reqApp.CodApp);
                // step 0: inserisce i file semaforo di segnalazione update in corso
                using (FileStream fs = File.Create(updFilePath))
                {
                    // File is created and access is released when the using block ends
                }

                // step 1: backup configurazioni partendo da path applicazione...
                string srcDir = Path.Combine(appDir, "DATA", "CONF");
                string destDir = Path.Combine(backupDir, "Conf", reqApp.CodApp, "DATA", "CONF");
                // se MAN uso folder "accorciata"
                if (reqApp.CodApp == "IOB-MAN")
                {
                    srcDir = Path.Combine(appDir, "CONF");
                    destDir = Path.Combine(backupDir, "Conf", reqApp.CodApp, "CONF");
                }
                CopyDirectory(srcDir, destDir);

                // step 2: kill processi
                ForceKillByName(reqApp.CodApp);

                // step 3: backup + zip intera folder applicativo
                if (Directory.Exists(tempZip))
                {
                    Directory.Delete(tempZip, true);
                }
                Directory.CreateDirectory(tempZip);
                CopyDirectory(appDir, tempZip);

                string zipPath = Path.Combine(backupDir, "Archive", reqApp.CodApp, $"{DateTime.Now:yyyyMMdd}_{DateTime.Now:HHmmss}.zip");
                if (File.Exists(zipPath))
                {
                    File.Delete(zipPath);
                }
                else
                {
                    string zipDir = Path.GetDirectoryName(zipPath) ?? "";
                    if (!string.IsNullOrEmpty(zipDir))
                    {
                        if (!Directory.Exists(zipDir))
                        {
                            Directory.CreateDirectory(zipDir);
                        }
                    }
                }
                await Task.Run(() =>
                {
                    ZipFile.CreateFromDirectory(tempZip, zipPath);
                });
            }
            await Task.Delay(10);
        }

        /// <summary>
        /// Step di download da remoto
        /// </summary>
        /// <param name="reqApp"></param>
        /// <returns></returns>
        private async Task IobWinDownload(VersStatusDTO reqApp)
        {
            // step 4: download // controllo di avere un file di riferimento...
            string appDir = Path.GetDirectoryName(reqApp.LocalPath) ?? "";
            if (!string.IsNullOrEmpty(appDir))
            {
                string installerDir = Path.Combine(backupDir, "installer", reqApp.CodApp);
                // se il path fosse vuoto --> uso quello standard da nexus...
                string urlDownload = reqApp.UrlDownload;
                if (string.IsNullOrEmpty(urlDownload))
                {
                    urlDownload = $"https://nexus.steamware.net/repository/utility/MAPO/{reqApp.CodApp}/stable/{reqApp.CodApp}.zip";
                }
                long size = updateMan.DownloadApp(urlDownload, installerDir, reqApp.CodApp, reqApp.VersNumLast);
                // se non andata provo con auth...
                if (size == 0)
                {
                    size = updateManAuth.DownloadApp(urlDownload, installerDir, reqApp.CodApp, reqApp.VersNumLast);
                }
            }
            await Task.Delay(10);
        }

        /// <summary>
        /// Step di fix backup configurazioni + unlock file update run
        /// </summary>
        /// <param name="reqApp"></param>
        /// <returns></returns>
        private async Task IobWinRestoreConf(VersStatusDTO reqApp)
        {
            // step 6: restore conf
            string appDir = Path.GetDirectoryName(reqApp.LocalPath) ?? "";
            if (!string.IsNullOrEmpty(appDir))
            {
                string srcDir = Path.Combine(appDir, "DATA", "CONF");
                string destDir = Path.Combine(backupDir, "Conf", reqApp.CodApp, "DATA", "CONF");
                // se MAN uso folder "accorciata"
                if (reqApp.CodApp == "IOB-MAN")
                {
                    srcDir = Path.Combine(appDir, "CONF");
                    destDir = Path.Combine(backupDir, "Conf", reqApp.CodApp, "CONF");
                }

                CopyDirectory(destDir, srcDir);
            }
            // step 7: rimozione file lock semaforo
            File.Delete(updFilePath);
            await Task.Delay(10);
        }

        /// <summary>
        /// Step di unzip file scaricato
        /// </summary>
        /// <param name="reqApp"></param>
        /// <returns></returns>
        private async Task IobWinUnzip(VersStatusDTO reqApp)
        {
            // step 5: unzip + overwrite
            string appDir = Path.GetDirectoryName(reqApp.LocalPath) ?? "";
            if (!string.IsNullOrEmpty(appDir))
            {
                string installerDir = Path.Combine(backupDir, "installer", reqApp.CodApp);
                string srcZip = Path.Combine(installerDir, $"{reqApp.CodApp}.zip");
                // svuoto la dir di destinazione preliminarmente...
                DeleteDirectoryContents(appDir);
                // esegue unzip
                ZipFile.ExtractToDirectory(srcZip, appDir, true);
            }
            await Task.Delay(10);
        }

        private void ReportConfigUpd()
        {
            if (EA_ConfigUpdated != null)
            {
                EA_ConfigUpdated?.Invoke();
            }
        }

        private void ReportRemoteCall()
        {
            if (EA_RemoteCalling != null)
            {
                EA_RemoteCalling?.Invoke();
            }
        }

        private void ReportStatusUpd()
        {
            if (EA_StatusUpdated != null)
            {
                // controllo se almeno 1 app abbia update...
                foreach (var item in ListAppStatus)
                {
                    if (item.HasUpdate)
                    {
                        EA_StatusUpdated?.Invoke();
                        break;
                    }
                }
            }
        }

        #endregion Private Methods
    }
}