using Microsoft.VisualBasic.Devices;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;

namespace SteamWare
{
    /// <summary>
    /// Helper x estrarre dati sintetici su HW, Software, librerie installate...
    /// </summary>
    public class HwSwInfo
    {
        #region Protected Fields

        /// <summary>
        /// Assembly di base
        /// </summary>
        protected Assembly assembly = Assembly.GetExecutingAssembly();

        #endregion Protected Fields

        #region Public Constructors

        /// <summary>
        /// Istanza base
        /// </summary>
        public HwSwInfo()
        {
            assembly = Assembly.GetExecutingAssembly();
        }

        public HwSwInfo(Assembly targetAssembly)
        {
            assembly = targetAssembly;
        }

        #endregion Public Constructors

#if false
    /// <summary>
    /// Singleton!
    /// </summary>
    public static HwSwInfo man = new HwSwInfo();
#endif

        #region Public Properties

        /// <summary>
        /// Statistiche IIS
        /// </summary>
        public string IISStats
        {
            get
            {
                StringBuilder sb = new StringBuilder();
                using (var iis = Process.GetCurrentProcess())
                {
                    //Process iis = Process.GetCurrentProcess();
                    sb.AppendLine(string.Format("UPTIME: {0}", ToDateString(DateTime.Now - iis.StartTime)));
                    sb.AppendLine(string.Format("Priority: {0}", iis.PriorityClass));
                    sb.AppendLine(string.Format("Physical Memory Used: {0}", memFormat(iis.WorkingSet64)));
                    sb.AppendLine(string.Format("Virtual Memory Used: {0}", memFormat(iis.VirtualMemorySize64)));
                }
                return sb.ToString();
            }
        }

        /// <summary>
        /// Versioni di ogni libreria compresa
        /// </summary>
        public string librariesVers
        {
            get
            {
                string answ = "";
                try
                {
                    AssemblyName[] referencedAssemblyNames = assembly.GetReferencedAssemblies();
                    foreach (AssemblyName referencedAssemblyName in referencedAssemblyNames.OrderBy(n => n.Name))
                    {
                        answ += referencedAssemblyName.FullName + Environment.NewLine;
                    }
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// Nome MainAssembly
        /// </summary>
        public string mainAssembly
        {
            get
            {
                string answ = "";
                try
                {
                    answ = assembly.FullName;
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// Num di librerie inserite
        /// </summary>
        public int numLibraries
        {
            get
            {
                int numLib = 0; ;
                try
                {
                    AssemblyName[] referencedAssemblyNames = assembly.GetReferencedAssemblies();
                    foreach (AssemblyName referencedAssemblyName in referencedAssemblyNames.OrderBy(n => n.Name))
                    {
                        numLib++;
                    }
                }
                catch
                { }
                return numLib;
            }
        }

        /// <summary>
        /// Restitusice l'elenco delle dimensioni browser registrate
        /// </summary>
        public string paretoBrowserSize
        {
            get
            {
                string redHash = memLayer.ML.redHash("COUNT:wh:*");
                return getBrowserData(redHash);
            }
        }

        /// <summary>
        /// Restitusice l'elenco delle dimensioni SCHERMO registrate
        /// </summary>
        public string paretoScreenSize
        {
            get
            {
                string redHash = memLayer.ML.redHash("COUNT:scr:*");
                return getBrowserData(redHash);
            }
        }

        /// <summary>
        /// Restitusice l'elenco delle dimensioni FINESTRA browser + PIXEL ratio registrate
        /// </summary>
        public string paretoWinPixRat
        {
            get
            {
                string redHash = memLayer.ML.redHash("COUNT:wpr:*");
                return getBrowserData(redHash);
            }
        }

        /// <summary>
        /// Dati sui server redis...
        /// </summary>
        public string redisServersData
        {
            get
            {
                StringBuilder sb = new StringBuilder();
                try
                {
                    var servData = memLayer.ML.redServInfo();
                    foreach (var item in servData)
                    {
                        sb.AppendLine(string.Format("Server: {0} | {1} | {2}", item, item.Version, item.ServerType));
                        // da completare con altre info?!?
                        var srvInfo = item.Info();
                        // esporto un pò di info x gruppo...
                        foreach (IGrouping<string, System.Collections.Generic.KeyValuePair<string, string>> capitolo in srvInfo)
                        {
                            sb.AppendLine("----------------------------------------------");
                            sb.AppendLine(string.Format("Capitolo: {0}", capitolo.Key));
                            sb.AppendLine("----------------------------------------------");
                            foreach (var kvp in capitolo)
                            {
                                sb.AppendLine(string.Format("{0}:{1}", kvp.Key, kvp.Value));
                            }

                            sb.AppendLine();
                        }
                    }
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(string.Format("Errore in redisServersData{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
                }
                return sb.ToString();
            }
        }

        /// <summary>
        /// Runtime assembly
        /// </summary>
        public string runtimeImg
        {
            get
            {
                string answ = "";
                try
                {
                    answ = assembly.ImageRuntimeVersion;
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// Statistiche server
        /// </summary>
        public string ServerStats
        {
            get
            {
                StringBuilder sb = new StringBuilder();
                try
                {
                    // calcoli preliminari
                    TimeSpan uptime;
                    using (var uptimeCounter = new PerformanceCounter("System", "System Up Time"))
                    {
                        uptimeCounter.NextValue();
                        uptime = TimeSpan.FromSeconds(uptimeCounter.NextValue());
                    }
                    var computer = new ComputerInfo();

                    // compongo output
                    sb.AppendLine(string.Format("NAME: {0}", Environment.MachineName));
                    sb.AppendLine(Environment.OSVersion.VersionString);
                    sb.AppendLine(string.Format("OS 64bit: {0} | PROC 64bit: {1}", Environment.Is64BitOperatingSystem, Environment.Is64BitProcess));
                    sb.AppendLine(string.Format("SYS UPTIME: {0}", ToDateString(uptime)));
                    sb.AppendLine(string.Format("CPU: {0}", Environment.ProcessorCount));
                    sb.AppendLine(string.Format("RAM: {0}", memFormat(computer.TotalPhysicalMemory)));
                    sb.AppendLine(string.Format("Virtual Memory: {0}", memFormat(computer.TotalVirtualMemory)));
                    sb.AppendLine(string.Format("Available RAM: {0}", memFormat(computer.AvailablePhysicalMemory)));
                    sb.AppendLine(string.Format("Available Virtual Memory: {0}", memFormat(computer.AvailableVirtualMemory)));
                    sb.AppendLine(string.Format("DIR: {0}", Environment.CurrentDirectory));
                    sb.AppendLine(string.Format("USER: {0} | USER: {1}", Environment.UserDomainName, Environment.UserName));
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(string.Format("Errore in ServerStats{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
                }
                return sb.ToString();
            }
        }

        #endregion Public Properties

        #region Private Methods

        private static string getBrowserData(string redPattern)
        {
            StringBuilder sb = new StringBuilder();
            int numRec = memLayer.ML.redCountKey(redPattern);
            var redKeys = memLayer.ML.redGetKeys(redPattern);
            // riordino elenco
            sb.AppendLine(string.Format("Trovate {0} combinazioni", numRec));
            string currKey = "";
            string currVal = "";
            foreach (var item in redKeys)
            {
                currKey = item.ToString().Replace(memLayer.ML.redHash(redPattern.Replace(":*", ":")), "");
                currVal = memLayer.ML.getRSV(item);
                sb.AppendLine($"{currKey}: {currVal}");
            }
            return sb.ToString();
        }

        #endregion Private Methods

        #region Public Methods

        /// <summary>
        /// Singleton!
        /// </summary>
        public static HwSwInfo man(Assembly targetAssembly)
        {
            HwSwInfo answ = new HwSwInfo(targetAssembly);
            return answ;
        }

        /// <summary>
        /// Formatta un numero da int a size in Kb/Mb/Gb/Tb
        /// </summary>
        /// <param name="rawSize"></param>
        /// <returns></returns>
        public string memFormat(double rawSize)
        {
            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
            int order = 0;
            while (rawSize >= 1024 && order < sizes.Length - 1)
            {
                order++;
                rawSize = rawSize / 1024;
            }

            // Adjust the format string to your preferences. For example "{0:0.#}{1}" would
            // show a single decimal place, and no space.
            return String.Format("{0:0.##} {1}", rawSize, sizes[order]);
        }

        /// <summary>
        /// Stringa timing in gg, ore, ... da timespan
        /// </summary>
        /// <param name="time"></param>
        /// <returns></returns>
        public string ToDateString(TimeSpan time)
        {
            return string.Format("{0}gg, {1:00}:{2:00}:{3:00} (h:m:s)", time.Days, time.Hours, time.Minutes, time.Seconds);
        }

        #endregion Public Methods
    }
}