using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using Vinno.FIS.Sonopost.Wireless;
using Vinno.IUS.Common.Log;

namespace Vinno.FIS.Sonopost.Features.Network
{
    public class WirelessNetworkInterfaceInfo : NetworkInterfaceInfo
    {
        private Wifi _wifi;
        private NetworkInterface _wlanInterface;

        public WifiStatus ConnectionStatus => _wifi?.ConnectionStatus ?? WifiStatus.Disconnected;

        private readonly object _locker = new object();

        private IList<AccessPoint> _wirelessNetworks;

        private IList<AccessPoint> _currentWirelessNetworks;

        public event EventHandler<WifiStatusEventArgs> ConnectionStatusChanged;

        public WirelessNetworkInterfaceInfo(NetworkInterface networkInterface, bool wifiScan) : base(networkInterface)
        {
            _wifi = new Wifi();
            _wlanInterface = networkInterface;
            _wirelessNetworks = new List<AccessPoint>();
            _currentWirelessNetworks = new List<AccessPoint>();
            RefreshNetworks(wifiScan);
        }

        private void RefreshNetworks(bool wifiScan)
        {
            try
            {
                var list = _wifi.GetAccessPoints(_wlanInterface.Id, wifiScan);
                _wirelessNetworks.Clear();
                foreach (var item in list.OrderBy(c => c.SignalStrength))
                {
                    if (string.IsNullOrWhiteSpace(item.Name))
                    {
                        _wirelessNetworks.Add(item);
                    }
                    else
                    {
                        _wirelessNetworks.Insert(0, item);
                    }
                }
                lock (_locker)
                {
                    _currentWirelessNetworks.Clear();
                    foreach (var network in _wirelessNetworks)
                    {
                        _currentWirelessNetworks.Add((AccessPoint)network.Clone());
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"WirelessNetworkInterfaceInfo RefreshNetworks Error, ex:{ex}");
            }
        }

        public IList<AccessPoint> GetAccessPoints()
        {
            lock (_locker)
            {
                var wirelessNetworks = new List<AccessPoint>();
                foreach (var network in _currentWirelessNetworks)
                {
                    wirelessNetworks.Add((AccessPoint)network.Clone());
                }
                return wirelessNetworks;
            }
        }

        public bool Connect(AccessPoint accessPoint, string userName, string password, string domain = "")
        {
            try
            {
                AuthRequest authRequest = new AuthRequest(accessPoint);
                bool overwrite = true;
                if (authRequest.IsPasswordRequired)
                {
                    if (accessPoint.HasProfile)
                    {
                        overwrite = false;
                    }
                    if (overwrite)
                    {
                        if (authRequest.IsUsernameRequired)
                        {
                            authRequest.Username = userName;
                            if (!accessPoint.IsValidPassword(password))
                            {
                                return false;
                            }
                        }
                        authRequest.Password = password;
                        if (authRequest.IsDomainSupported)
                        {
                            authRequest.Domain = domain;
                        }
                    }
                }

                if (accessPoint?.Connect(authRequest, overwrite) == false)
                {
                    accessPoint.DeleteProfile();
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Connect Wifi Error:{ex}");
            }
            return false;
        }

        public bool Disconnect()
        {
            try
            {
                _wifi?.Disconnect();
                return true;
            }
            catch (Exception e)
            {
                Logger.WriteLineError($"DisConnect Error:{e}");
                return false;
            }
        }

        public void DeleteProfile(AccessPoint accessPoint)
        {
            accessPoint.DeleteProfile();
        }

        internal override void Dispose()
        {
            base.Dispose();
        }
    }
}