using NLog;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Management;
using System.Runtime.InteropServices;
using System.Text;

namespace POSV.Utils
{
    public class DeviceUtils
    {
        private static Logger logger = NLog.LogManager.GetCurrentClassLogger();

        private static object _lock = new object();

        private static DeviceUtils _instance;

        public static DeviceUtils Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        Stopwatch watch = Stopwatch.StartNew();

                        _instance = new DeviceUtils();

                        _instance.ComputerName = GetComputerName();

                        _instance.IPAddress = GetIPAddress();

                        _instance.MotherboardNumber = GetMotherboardNumber();

                        _instance.CpuID = GetCpuID();

                        _instance.DiskID = GetDiskID();

                        _instance.MacAddress = GetMacAddress();

                        logger.Info("检测设备信息耗时<{0}>", watch.ElapsedMilliseconds);

                    }
                }
                    

                return _instance;
            }
        }

        public string ComputerName { get; private set; }

        public string IPAddress { get; private set; }

        public string MotherboardNumber { get; private set; }

        public string CpuID { get; private set; }

        public string DiskID { get; private set; }

        public string MacAddress { get; private set; }

        /// <summary>
        /// 获取计算机名
        /// </summary>
        /// <returns></returns>
        private static string GetComputerName()
        {
            return Environment.MachineName;
        }
        
        /// <summary>
        /// 获取IP地址
        /// </summary>
        /// <returns></returns>
        private static string GetIPAddress()
        {
            string st = "";
            try
            {
                ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    if ((bool)mo["IPEnabled"] == true)
                    {
                        //st=mo["IpAddress"].ToString(); 
                        Array ar;
                        ar = (Array)(mo.Properties["IpAddress"].Value);
                        st = ar.GetValue(0).ToString();
                        break;
                    }
                }
            }
            catch
            {
                st = "127.0.0.1";
            }
            return st;
        }

        /// <summary>
        /// 操作系统类型
        /// </summary>
        /// <returns></returns> 
        public static string GetSystemType()
        {
            string st = "";
            try
            { 
                ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    st = mo["SystemType"].ToString();
                }
                return st;
            }
            catch (Exception ex)
            {
                logger.Error(ex);
                st = "127.0.0.1";
                return st;
            }
           
        }

        /// <summary>
        /// 物理内存
        /// </summary>
        /// <returns></returns>
        private static string GetPhysicalMemory()
        {
            string st = "";
            ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
            ManagementObjectCollection moc = mc.GetInstances();
            foreach (ManagementObject mo in moc)
            {
                st = mo["TotalPhysicalMemory"].ToString();
            }
            return st;
        }

        /// <summary>
        /// 显卡PNPDeviceID
        /// </summary>
        /// <returns></returns>
        private static string GetVideoPNPID()
        {
            string st = "";
            ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_VideoController");
            foreach (ManagementObject mo in mos.Get())
            {
                st = mo["PNPDeviceID"].ToString();
            }
            return st;
        }

        /// <summary>
        /// 声卡PNPDeviceID
        /// </summary>
        /// <returns></returns>
        private static string GetSoundPNPID()
        {
            string st = "";
            ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_SoundDevice");
            foreach (ManagementObject mo in mos.Get())
            {
                st = mo["PNPDeviceID"].ToString();
            }
            return st;
        }

        /// <summary>
        /// CPU版本信息
        /// </summary>
        /// <returns></returns>
        private static string GetCPUVersion()
        {
            string st = "";
            ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_Processor");
            foreach (ManagementObject mo in mos.Get())
            {
                st = mo["Version"].ToString();
            }
            return st;
        }

        /// <summary>
        /// CPU名称信息
        /// </summary>
        /// <returns></returns>
        private static string GetCPUName()
        {
            string st = "";
            ManagementObjectSearcher driveID = new ManagementObjectSearcher("Select * from Win32_Processor");
            foreach (ManagementObject mo in driveID.Get())
            {
                st = mo["Name"].ToString();
            }
            return st;
        }

        /// <summary>
        /// CPU制造厂商
        /// </summary>
        /// <returns></returns>
        private static string GetCPUManufacturer()
        {
            string st = "";
            ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_Processor");
            foreach (ManagementObject mo in mos.Get())
            {
                st = mo["Manufacturer"].ToString();
            }
            return st;
        }

        /// <summary>
        /// 主板制造厂商
        /// </summary>
        /// <returns></returns>
        private static string GetBoardManufacturer()
        {
            SelectQuery query = new SelectQuery("Select * from Win32_BaseBoard");
            ManagementObjectSearcher mos = new ManagementObjectSearcher(query);
            ManagementObjectCollection.ManagementObjectEnumerator data = mos.Get().GetEnumerator();
            data.MoveNext();
            ManagementBaseObject board = data.Current;
            return board.GetPropertyValue("Manufacturer").ToString();
        }

        /// <summary>
        /// 主板编号
        /// </summary>
        /// <returns></returns>
        private static string GetBoardID()
        {
            string st = "";
            ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_BaseBoard");
            foreach (ManagementObject mo in mos.Get())
            {
                st = mo["SerialNumber"].ToString();
            }
            return st;
        }

        /// <summary>
        /// 主板型号
        /// </summary>
        /// <returns></returns>
        private static string GetBoardType()
        {
            string st = "";
            ManagementObjectSearcher mos = new ManagementObjectSearcher("Select * from Win32_BaseBoard");
            foreach (ManagementObject mo in mos.Get())
            {
                st = mo["Product"].ToString();
            }
            return st;
        }


        /// <summary>
        /// 获取主板号
        /// </summary>
        /// <returns></returns>
        private static string GetMotherboardNumber()
        {
            try
            {
                return string.Join("," , HWiNFO.HWiNFO.WMI_DeviceQuery(3));
            }
            catch
            {
                return MotherboardId();
            }

            
        }

        /// <summary>
        /// 获取CPU ID
        /// </summary>
        /// <returns></returns>
        public static string GetCpuID()
        {
            try
            {
                return string.Join("," , HWiNFO.HWiNFO.WMI_DeviceQuery(4));
            }
            catch
            {
                return CpuId();
            }
            
        }

        private static string Identifier(string wmiClass , string wmiProperty)
        {
            string result = "";
            System.Management.ManagementClass mc =
        new System.Management.ManagementClass(wmiClass);
            System.Management.ManagementObjectCollection moc = mc.GetInstances();
            foreach (System.Management.ManagementObject mo in moc)
            {
                //Only get the first one
                if (result == "")
                {
                    try
                    {
                        result = mo[wmiProperty].ToString();
                        break;
                    }
                    catch
                    {
                    }
                }
            }
            return result;
        }

        private static string CpuId()
        {
            //Uses first CPU identifier available in order of preference
            //Don't get all identifiers, as it is very time consuming
            string retVal = Identifier("Win32_Processor" , "UniqueId");
            if (retVal == "") //If no UniqueID, use ProcessorID
            {
                retVal = Identifier("Win32_Processor" , "ProcessorId");
                if (retVal == "") //If no ProcessorId, use Name
                {
                    retVal = Identifier("Win32_Processor" , "Name");
                    if (retVal == "") //If no Name, use Manufacturer
                    {
                        retVal = Identifier("Win32_Processor" , "Manufacturer");
                    }
                    //Add clock speed for extra security
                    retVal += Identifier("Win32_Processor" , "MaxClockSpeed");
                }
            }
            return retVal;
        }

        //BIOS Identifier
        private static string BiosId()
        {
            return Identifier("Win32_BIOS" , "Manufacturer")
            + Identifier("Win32_BIOS" , "SMBIOSBIOSVersion")
            + Identifier("Win32_BIOS" , "IdentificationCode")
            + Identifier("Win32_BIOS" , "SerialNumber")
            + Identifier("Win32_BIOS" , "ReleaseDate")
            + Identifier("Win32_BIOS" , "Version");
        }
        //Main physical hard drive ID
        private static string DiskId()
        {
            return Identifier("Win32_DiskDrive" , "Model")
            + Identifier("Win32_DiskDrive" , "Manufacturer")
            + Identifier("Win32_DiskDrive" , "Signature")
            + Identifier("Win32_DiskDrive" , "TotalHeads");
        }
        //Motherboard ID
        private static string MotherboardId()
        {
            return Identifier("Win32_BaseBoard" , "Model")
            + Identifier("Win32_BaseBoard" , "Manufacturer")
            + Identifier("Win32_BaseBoard" , "Name")
            + Identifier("Win32_BaseBoard" , "SerialNumber");
        }
        //Primary video controller ID
        private static string VideoId()
        {
            return Identifier("Win32_VideoController" , "DriverVersion")
            + Identifier("Win32_VideoController" , "Name");
        }
        //First enabled network card ID
        private static string MacId()
        {
            return Identifier("Win32_NetworkAdapterConfiguration" ,
                "MACAddress" , "IPEnabled");
        }

        private static string Identifier
       (string wmiClass , string wmiProperty , string wmiMustBeTrue)
        {
            string result = "";
            System.Management.ManagementClass mc =
        new System.Management.ManagementClass(wmiClass);
            System.Management.ManagementObjectCollection moc = mc.GetInstances();
            foreach (System.Management.ManagementObject mo in moc)
            {
                if (mo[wmiMustBeTrue].ToString() == "True")
                {
                    //Only get the first one
                    if (result == "")
                    {
                        try
                        {
                            result = mo[wmiProperty].ToString();
                            break;
                        }
                        catch
                        {
                        }
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// 获取硬盘序列号
        /// </summary>
        /// <returns></returns>
        public static string GetDiskID()
        {
            try
            {
                return GetHardDiskID();
            }
            catch
            {
                return DiskId();// GetDiskVolume("C"); 
            }
            
        }

        #region 获取硬盘序列号
        [DllImport("kernel32.dll")]
        private static extern int GetVolumeInformation(
            string lpRootPathName ,
            string lpVolumeNameBuffer ,
            int nVolumeNameSize ,
            ref int lpVolumeSerialNumber ,
            int lpMaximumComponentLength ,
            int lpFileSystemFlags ,
            string lpFileSystemNameBuffer ,
            int nFileSystemNameSize
        );
        /// <summary>
        /// 获取硬盘序列号
        /// </summary>
        /// <param name="drvID">硬盘盘符[c|d|e|....]</param>
        /// <returns></returns>
        private static string GetDiskVolume(string drvID)
        {
            const int MAX_FILENAME_LEN = 256;
            int retVal = 0;
            int lpMaximumComponentLength = 0;
            int lpFileSystemFlags = 0;
            string lpVolumeNameBuffer = null;
            string lpFileSystemNameBuffer = null;
            int i = GetVolumeInformation(
            drvID + @":\" ,
            lpVolumeNameBuffer ,
            MAX_FILENAME_LEN ,
            ref retVal ,
            lpMaximumComponentLength ,
            lpFileSystemFlags ,
            lpFileSystemNameBuffer ,
            MAX_FILENAME_LEN
            );
            return retVal.ToString("x");
        }

        //取第一块硬盘编号   
        private static string GetHardDiskID()
        {
            try
            {
                ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia");
                string strHardDiskID = null;
                foreach (ManagementObject mo in searcher.Get())
                {
                    strHardDiskID = mo["SerialNumber"].ToString().Trim();
                    break;
                }
                return strHardDiskID;
            }
            catch
            {
                return "";
            }
        }

        #endregion


        /// <summary>
        /// 获取Mac地址
        /// </summary>
        /// <returns></returns>
        public static string GetMacAddress()
        {
            try
            {
                return string.Join(",", HWiNFO.HWiNFO.WMI_DeviceQuery(0));
            }
            catch
            {
                var macs = HWiNFO.HWiNFO.WDK_QueryMacAddress(true);
                if (macs != null)
                {
                    return string.Join(",", macs);
                }
                else
                {
                    return null;
                }
            }
        }

        /// <summary>
        /// 获取空闲内存(单位为M) 
        /// </summary>
        /// <returns></returns>
        public static int GetFreePhysicalMemory()
        {
            long availablebytes = 0;
            try
            {


                ManagementClass mos = new ManagementClass("Win32_OperatingSystem");
                foreach (ManagementObject mo in mos.GetInstances())
                {
                    if (mo["FreePhysicalMemory"] != null)
                    {
                        availablebytes = long.Parse(mo["FreePhysicalMemory"].ToString());
                    }
                }
            }
            catch
            {
                availablebytes = 0;
            }



            return (int)(availablebytes / 1024);
        }

        /// <summary>
        /// 获取系统内存大小(单位M)
        /// </summary>
        /// <returns>内存大小</returns>
        public static int GetPhisicalMemory()
        {
            ManagementObjectSearcher searcher = new ManagementObjectSearcher();   //用于查询一些如系统信息的管理对象 
            searcher.Query = new SelectQuery("Win32_PhysicalMemory ", "", new string[] { "Capacity" });//设置查询条件 
            ManagementObjectCollection collection = searcher.Get();   //获取内存容量 
            ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();

            long capacity = 0;
            while (em.MoveNext())
            {
                ManagementBaseObject baseObj = em.Current;
                if (baseObj.Properties["Capacity"].Value != null)
                {
                    try
                    {
                        capacity += long.Parse(baseObj.Properties["Capacity"].Value.ToString());
                    }
                    catch
                    {
                        return 0;
                    }
                }
            }
            return (int)(capacity / 1024 / 1024);
        }

        public static string GetOsVersion(Version ver)
        {
            string strClient = "";
            if (ver.Major == 5 && ver.Minor == 0)
            {
                strClient = "Win2000";
            }
            else if (ver.Major == 5 && ver.Minor == 1)
            {
                strClient = "WinXP";
            }
            else if (ver.Major == 6 && ver.Minor == 0)
            {
                strClient = "WinVista";
            }
            else if (ver.Major == 6 && ver.Minor == 1)
            {
                strClient = "Win7";
            }
            else if (ver.Major == 6 && ver.Minor == 2)
            {
                strClient = "Win8+";
            }
            else if (ver.Major == 10 && ver.Minor == 0)
            {
                strClient = "Win10";
            }
            else
            {
                strClient = "未知";
            }
            return strClient;
        }

        /// <summary>
        /// 获取指定驱动器的剩余空间总大小(单位为M) 
        /// </summary>
        /// <param name="diskName"></param>
        /// <returns></returns>
        public static long GetHardDiskFreeSpace(string diskName)
        {
            long freeSpace = new long();
            diskName = diskName + ":\\";
            System.IO.DriveInfo[] drives = System.IO.DriveInfo.GetDrives();
            foreach (System.IO.DriveInfo drive in drives)
            {
                if (drive.Name == diskName)
                {
                    freeSpace = drive.TotalFreeSpace / (1024 * 1024);
                }
            }
            return freeSpace;
        }

        /// <summary>
        /// 获取指定驱动器的空间总大小(单位为M) 
        /// </summary>
        /// <param name="diskName"></param>
        /// <returns></returns>
        public static long GetHardDiskSpace(string diskName)
        {
            long totalSize = new long();
            diskName = diskName + ":\\";
            System.IO.DriveInfo[] drives = System.IO.DriveInfo.GetDrives();
            foreach (System.IO.DriveInfo drive in drives)
            {
                if (drive.Name == diskName)
                {
                    totalSize = drive.TotalSize / (1024 * 1024);
                }
            }
            return totalSize;
        }
    }
}