using System;
using System.Diagnostics;
using System.Linq;
using System.Management;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;
using Vinno.IUS.Common.Log;

namespace Vinno.FIS.Sonopost.Features.Network
{
    public enum OperationStatus
    {
        Connecting,
        Connected,
        Disconnecting,
        Disconnected
    }

    public class NetworkInterfaceInfo
    {
        private enum NetworkInterfaceErrors
        {
            Unknow = -1,
            Success = 0,
            InvalidSubnetMask = 66,
            InvalidIpAddress = 70,
            InvalidGateWay = 71
        }

        private OperationStatus _operationalStatus;

        public Guid Guid { get; private set; }

        public NetworkInterfaceType NetworkInterfaceType { get; private set; }

        public string MacAddress { get; private set; }

        public string Description { get; private set; }

        public NetworkInterfaceInfoParam<bool> EnableDhcp { get; private set; }

        public OperationStatus OperationalStatus
        {
            get
            {
                return _operationalStatus;
            }
            set
            {
                if (_operationalStatus != value)
                {
                    _operationalStatus = value;
                }
            }
        }

        public NetworkInterfaceInfoParam<string> IpAddress { get; private set; }

        public NetworkInterfaceInfoParam<string> SubnetMask { get; private set; }

        public NetworkInterfaceInfoParam<string> GateWay { get; private set; }

        public NetworkInterfaceInfoParam<string> PreferredDNSServer { get; private set; }

        public NetworkInterfaceInfoParam<string> StandbyDNSServer { get; private set; }

        internal NetworkInterfaceInfo(NetworkInterface networkInterface)
        {
            Load(networkInterface);
            if (EnableDhcp == null || IpAddress == null || SubnetMask == null || GateWay == null)
            {
                throw new ArgumentNullException("TcpIpSetting parameters");
            }
        }

        public bool ValidIpProperties()
        {
            if (!IsAddressValid(IpAddress.Value))
            {
                return false;
            }
            if (!IsAddressValid(SubnetMask.Value))
            {
                return false;
            }
            if (!string.IsNullOrEmpty(GateWay.Value) && !IsAddressValid(GateWay.Value))
            {
                return false;
            }

            if (!string.IsNullOrEmpty(PreferredDNSServer.Value) && !IsAddressValid(PreferredDNSServer.Value))
            {
                return false;
            }
            if (!string.IsNullOrEmpty(StandbyDNSServer.Value) && !IsAddressValid(StandbyDNSServer.Value))
            {
                return false;
            }
            return true;
        }

        public bool SaveChanges(bool enableDhcp, bool rollback = false)
        {
            if (rollback)
            {
                UpdateDefaults(EnableDhcp.DefaultValue, IpAddress.DefaultValue, SubnetMask.DefaultValue, GateWay.DefaultValue, PreferredDNSServer.DefaultValue, StandbyDNSServer.DefaultValue);
                return true;
            }
            uint num = 0u;
            string queryString = $"select * from Win32_NetworkAdapterConfiguration ";
            using (ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(queryString))
            {
                var managementObjects = managementObjectSearcher.Get().OfType<ManagementObject>();
                ManagementObject managementObject = managementObjects.FirstOrDefault(x => x["MacAddress"] != null && ((string)x["MacAddress"]).Replace(":", "-") == MacAddress);
                if (managementObject == null)
                {
                    Logger.WriteLineError($"Adapter {MacAddress} is not enabled.");
                    HandleSetNetworkReturnValue(NetworkInterfaceErrors.Unknow);
                    return false;
                }
                if (enableDhcp)
                {
                    if (!(bool)managementObject["DHCPEnabled"])
                    {
                        num = (uint)managementObject.InvokeMethod("EnableDHCP", null);
                        switch (num)
                        {
                            case 0u:
                                break;

                            case 84u:
                                {
                                    NetworkInterface networkInterface = NetworkInterface.GetAllNetworkInterfaces().FirstOrDefault(x => GetMacAddress(x.GetPhysicalAddress()) == MacAddress);
                                    if (networkInterface != null)
                                    {
                                        try
                                        {
                                            Process process = new Process
                                            {
                                                StartInfo =
                                                {
                                                    FileName = "netsh.exe",
                                                    Arguments = $"interface ip set address \"{networkInterface.Name}\" DHCP",
                                                    UseShellExecute = false,
                                                    CreateNoWindow = true
                                                }
                                            };
                                            process.Start();
                                        }
                                        catch (Exception ex)
                                        {
                                            Logger.WriteLineError($"netsh command exception : {ex}");
                                        }
                                    }
                                    break;
                                }
                            default:
                                Logger.WriteLineError("Enable DHCP failed. Error code:" + num);
                                return false;
                        }

                        num = (uint)managementObject.InvokeMethod("SetDNSServerSearchOrder", null);
                        if (num != 0)
                        {
                            Logger.WriteLineError("Set dns server search order fail. Error code:" + num);
                            return false;
                        }
                    }
                }
                else
                {
                    if (!string.IsNullOrWhiteSpace(IpAddress.Value) && !string.IsNullOrWhiteSpace(SubnetMask.Value))
                    {
                        num = (uint)managementObject.InvokeMethod("EnableStatic", new object[2]
                        {
                            new string[1]
                            {
                                IpAddress.Value
                            },
                            new string[1]
                            {
                                SubnetMask.Value
                            }
                        });
                        if (num != 0)
                        {
                            NetworkInterfaceErrors errorCode = NetworkInterfaceErrors.Unknow;
                            if (Enum.IsDefined(typeof(NetworkInterfaceErrors), (int)num))
                            {
                                errorCode = (NetworkInterfaceErrors)num;
                            }
                            Logger.WriteLineError("Set static IP address failed. Error code:" + num);
                            HandleSetNetworkReturnValue(errorCode, num);
                            return false;
                        }
                        else
                        {
                            Logger.WriteLineInfo($"Network Interface Info Set IP And SubnetMask Success.");
                        }
                    }

                    if (!string.IsNullOrWhiteSpace(GateWay.Value))
                    {
                        num = (uint)managementObject.InvokeMethod("SetGateways", new object[2]
                        {
                            new string[1]
                            {
                                GateWay.Value
                            },
                            new ushort[1]
                            {
                                1
                            }
                        });
                        if (num != 0)
                        {
                            HandleSetNetworkReturnValue(NetworkInterfaceErrors.InvalidGateWay);
                            Logger.WriteLineError("Set static default gateway failed. Error code:" + num);
                            return false;
                        }
                        else
                        {
                            Logger.WriteLineInfo($"Network Interface Info Set default gateway Success.");
                        }
                    }

                    if (!string.IsNullOrWhiteSpace(PreferredDNSServer.Value) || !string.IsNullOrWhiteSpace(StandbyDNSServer.Value))
                    {
                        var objInPara = managementObject.GetMethodParameters("SetDNSServerSearchOrder");
                        if (string.IsNullOrWhiteSpace(StandbyDNSServer.Value))
                        {
                            objInPara["DNSServerSearchOrder"] = new string[] { PreferredDNSServer.Value };
                        }
                        else if (string.IsNullOrWhiteSpace(PreferredDNSServer.Value))
                        {
                            objInPara["DNSServerSearchOrder"] = new string[] { StandbyDNSServer.Value };
                        }
                        else
                        {
                            objInPara["DNSServerSearchOrder"] = new string[] { PreferredDNSServer.Value, StandbyDNSServer.Value };
                        }
                        var managementBaseObject = managementObject.InvokeMethod("SetDNSServerSearchOrder", objInPara, null);
                        num = (uint)managementBaseObject["ReturnValue"];
                        if (num != 0)
                        {
                            Logger.WriteLineError("Set DNS Server failed. Error code:" + num);
                            return false;
                        }
                        else
                        {
                            Logger.WriteLineInfo($"Network Interface Info Set DNS Success.");
                        }
                    }
                }
            }
            return true;
        }

        private void UpdateDefaults(bool enableDhcp, string address, string submask, string getway, string preferredDnsServer, string standbyDnsServer)
        {
            if (EnableDhcp != null)
            {
                EnableDhcp.UpdateDefaultValue(enableDhcp);
            }
            if (IpAddress != null)
            {
                IpAddress.UpdateDefaultValue(address);
            }
            if (SubnetMask != null)
            {
                SubnetMask.UpdateDefaultValue(submask);
            }
            if (GateWay != null)
            {
                GateWay.UpdateDefaultValue(getway);
            }
            if (PreferredDNSServer != null)
            {
                PreferredDNSServer.UpdateDefaultValue(preferredDnsServer);
            }
            if (StandbyDNSServer != null)
            {
                StandbyDNSServer.UpdateDefaultValue(standbyDnsServer);
            }
        }

        private void Load(NetworkInterface networkInterface)
        {
            if (networkInterface == null)
            {
                throw new ArgumentNullException("networkInterface");
            }
            Guid = new Guid(networkInterface.Id);
            NetworkInterfaceType = networkInterface.NetworkInterfaceType;
            Description = networkInterface.Description;
            OperationalStatus = ((networkInterface.OperationalStatus == System.Net.NetworkInformation.OperationalStatus.Up) ? OperationStatus.Connected : OperationStatus.Disconnected);
            MacAddress = GetMacAddress(networkInterface.GetPhysicalAddress());
            bool enbleDhcp = false;
            string address = string.Empty;
            string submask = string.Empty;
            string getway = string.Empty;
            string preferredDnsServer = string.Empty;
            string standbyDnsServer = string.Empty;
            ParseTcpIpInfo(networkInterface, out enbleDhcp, out address, out submask, out getway, out preferredDnsServer, out standbyDnsServer);
            EnableDhcp = new NetworkInterfaceInfoParam<bool>("AutoConfigIPAddress", enbleDhcp);
            IpAddress = new NetworkInterfaceInfoParam<string>("IPv4Setting", address);
            SubnetMask = new NetworkInterfaceInfoParam<string>("Subnetmask", submask);
            GateWay = new NetworkInterfaceInfoParam<string>("DefaultGateway", getway);
            PreferredDNSServer = new NetworkInterfaceInfoParam<string>("PreferredDNSServer", preferredDnsServer);
            StandbyDNSServer = new NetworkInterfaceInfoParam<string>("StandbyDNSServer", standbyDnsServer);
        }

        private void ParseTcpIpInfo(NetworkInterface networkInterface, out bool enbleDhcp, out string address, out string submask, out string getway, out string preferredDnsServer, out string standbyDnsServer)
        {
            IPInterfaceProperties iPProperties = networkInterface.GetIPProperties();
            IPv4InterfaceProperties iPv4Properties = iPProperties.GetIPv4Properties();
            if (iPv4Properties != null)
            {
                enbleDhcp = iPv4Properties.IsDhcpEnabled;
            }
            else
            {
                enbleDhcp = false;
            }
            if (networkInterface.OperationalStatus == System.Net.NetworkInformation.OperationalStatus.Down)
            {
                address = string.Empty;
                submask = string.Empty;
                getway = string.Empty;
                preferredDnsServer = string.Empty;
                standbyDnsServer = string.Empty;
                return;
            }
            UnicastIPAddressInformation unicastIPAddressInformation = enbleDhcp ? iPProperties.UnicastAddresses.FirstOrDefault((UnicastIPAddressInformation x) => x.Address.AddressFamily == AddressFamily.InterNetwork && x.PrefixOrigin == PrefixOrigin.Dhcp) : iPProperties.UnicastAddresses.FirstOrDefault((UnicastIPAddressInformation x) => x.Address.AddressFamily == AddressFamily.InterNetwork && x.PrefixOrigin == PrefixOrigin.Manual);
            if (unicastIPAddressInformation == null)
            {
                unicastIPAddressInformation = iPProperties.UnicastAddresses.FirstOrDefault((UnicastIPAddressInformation x) => x.Address.AddressFamily == AddressFamily.InterNetwork && x.PrefixOrigin == PrefixOrigin.Manual);
            }
            if (unicastIPAddressInformation != null)
            {
                address = unicastIPAddressInformation.Address.ToString();
                submask = ((unicastIPAddressInformation.IPv4Mask != null) ? unicastIPAddressInformation.IPv4Mask.ToString() : GetDefaultSubnetMaskWithIpAddress(address));
            }
            else
            {
                address = string.Empty;
                submask = string.Empty;
            }
            GatewayIPAddressInformation gatewayIPAddressInformation = iPProperties.GatewayAddresses.FirstOrDefault((GatewayIPAddressInformation x) => x.Address.AddressFamily == AddressFamily.InterNetwork);
            if (gatewayIPAddressInformation != null)
            {
                getway = gatewayIPAddressInformation.Address.ToString();
                if ("0.0.0.0" == getway)
                {
                    getway = string.Empty;
                }
            }
            else
            {
                getway = string.Empty;
            }
            var ipAddressCollection = iPProperties.DnsAddresses.Where(c => c.AddressFamily == AddressFamily.InterNetwork).ToList();
            preferredDnsServer = string.Empty;
            standbyDnsServer = string.Empty;
            if (ipAddressCollection.Any())
            {
                preferredDnsServer = ipAddressCollection[0].ToString();
                if (ipAddressCollection.Count == 2)
                {
                    standbyDnsServer = ipAddressCollection[1].ToString();
                }
            }
        }

        private bool? HandleSetNetworkReturnValue(NetworkInterfaceErrors errorCode, uint result = 0u)
        {
            if (errorCode != 0)
            {
                return true;
            }
            return null;
        }

        public static string GetDefaultSubnetMaskWithIpAddress(string iPAddress)
        {
            if (!IsAddressValid(iPAddress))
            {
                return string.Empty;
            }
            IPAddress iPAddress2 = IPAddress.Parse(iPAddress);
            byte[] addressBytes = iPAddress2.GetAddressBytes();
            uint num = addressBytes[0];
            if (num >= 0 && num <= 127)
            {
                return "255.0.0.0";
            }
            if (num >= 128 && num <= 191)
            {
                return "255.255.0.0";
            }
            if (num >= 192 && num <= 223)
            {
                return "255.255.255.0";
            }
            return "0.0.0.0";
        }

        private string GetMacAddress(PhysicalAddress address)
        {
            //return address.ToString();
            return BitConverter.ToString(address.GetAddressBytes());
        }

        private static bool IsAddressValid(string address)
        {
            if (string.IsNullOrEmpty(address))
            {
                return false;
            }
            IPAddress address2;
            return IPAddress.TryParse(address, out address2);
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append($"GUID:{Guid}\t");
            sb.Append($"Description:{Description}\t");
            sb.Append($"DHCP:{EnableDhcp.Value}\t");
            sb.Append($"MAC:{MacAddress}\t");
            sb.Append($"IP:{IpAddress.Value}\t");
            sb.Append($"SubnetMask:{SubnetMask.Value}\t");
            sb.Append($"Gateway:{GateWay.Value}\t");
            sb.Append($"DNS1:{PreferredDNSServer.Value}\t");
            sb.Append($"DNS2:{StandbyDNSServer.Value}\t");
            sb.Append($"Type:{NetworkInterfaceType}\t");

            return sb.ToString();
        }

        internal virtual void Dispose()
        {
        }
    }
}