using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;

namespace FastGithub.DomainResolve
{
 /// <summary>
 /// IP服务
 /// 域名IP关系缓存10分钟
 /// IPEndPoint时延缓存5分钟
 /// IPEndPoint连接超时5秒
 /// </summary>
 sealed class IPAddressService
 {
 private record DomainAddress(string Domain, IPAddress Address);
 private readonly TimeSpan domainAddressExpiration = TimeSpan.FromMinutes(10d);
 private readonly IMemoryCache domainAddressCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));

 private record AddressElapsed(IPAddress Address, TimeSpan Elapsed);
 private readonly TimeSpan problemElapsedExpiration = TimeSpan.FromMinutes(1d);
 private readonly TimeSpan normalElapsedExpiration = TimeSpan.FromMinutes(5d);
 private readonly TimeSpan connectTimeout = TimeSpan.FromSeconds(5d);
 private readonly IMemoryCache addressElapsedCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));

 private readonly DnsClient dnsClient;

 /// <summary>
 /// IP服务
 /// </summary>
 /// <param name="dnsClient"></param>
 public IPAddressService(DnsClient dnsClient)
 {
 this.dnsClient = dnsClient;
 }

 /// <summary>
 /// 并行获取可连接的IP
 /// </summary>
 /// <param name="dnsEndPoint"></param>
 /// <param name="oldAddresses"></param>
 /// <param name="cancellationToken"></param>
 /// <returns></returns>
 public async Task<IPAddress[]> GetAddressesAsync(DnsEndPoint dnsEndPoint, IEnumerable<IPAddress> oldAddresses, CancellationToken cancellationToken)
 {
 var ipEndPoints = new HashSet<IPEndPoint>();

 // 历史未过期的IP节点
 foreach (var address in oldAddresses)
 {
 var domainAddress = new DomainAddress(dnsEndPoint.Host, address);
 if (this.domainAddressCache.TryGetValue(domainAddress, out _))
 {
 ipEndPoints.Add(new IPEndPoint(address, dnsEndPoint.Port));
 }
 }

 // 新解析出的IP节点
 await foreach (var address in this.dnsClient.ResolveAsync(dnsEndPoint, fastSort: false, cancellationToken))
 {
 ipEndPoints.Add(new IPEndPoint(address, dnsEndPoint.Port));
 var domainAddress = new DomainAddress(dnsEndPoint.Host, address);
 this.domainAddressCache.Set(domainAddress, default(object), this.domainAddressExpiration);
 }

 if (ipEndPoints.Count == 0)
 {
 return Array.Empty<IPAddress>();
 }

 var addressElapsedTasks = ipEndPoints.Select(item => this.GetAddressElapsedAsync(item, cancellationToken));
 var addressElapseds = await Task.WhenAll(addressElapsedTasks);

 return addressElapseds
 .Where(item => item.Elapsed < TimeSpan.MaxValue)
 .OrderBy(item => item.Elapsed)
 .Select(item => item.Address)
 .ToArray();
 }


 /// <summary>
 /// 获取IP节点的时延
 /// </summary> 
 /// <param name="endPoint"></param>
 /// <param name="cancellationToken"></param>
 /// <returns></returns>
 private async Task<AddressElapsed> GetAddressElapsedAsync(IPEndPoint endPoint, CancellationToken cancellationToken)
 {
 if (this.addressElapsedCache.TryGetValue<AddressElapsed>(endPoint, out var addressElapsed))
 {
 return addressElapsed;
 }

 var stopWatch = Stopwatch.StartNew();
 try
 {
 using var timeoutTokenSource = new CancellationTokenSource(this.connectTimeout);
 using var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutTokenSource.Token);
 using var socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
 await socket.ConnectAsync(endPoint, linkedTokenSource.Token);

 addressElapsed = new AddressElapsed(endPoint.Address, stopWatch.Elapsed);
 return this.addressElapsedCache.Set(endPoint, addressElapsed, this.normalElapsedExpiration);
 }
 catch (Exception ex)
 {
 cancellationToken.ThrowIfCancellationRequested();

 addressElapsed = new AddressElapsed(endPoint.Address, TimeSpan.MaxValue);
 var expiration = IsLocalNetworkProblem(ex) ? this.problemElapsedExpiration : this.normalElapsedExpiration;
 return this.addressElapsedCache.Set(endPoint, addressElapsed, expiration);
 }
 finally
 {
 stopWatch.Stop();
 }
 }

 /// <summary>
 /// 是否为本机网络问题
 /// </summary>
 /// <param name="ex"></param>
 /// <returns></returns>
 private static bool IsLocalNetworkProblem(Exception ex)
 {
 if (ex is not SocketException socketException)
 {
 return false;
 }

 var code = socketException.SocketErrorCode;
 return code == SocketError.NetworkDown || code == SocketError.NetworkUnreachable;
 }
 }
}