using Microsoft.Extensions.Options;

using PrivaPub.Infrastructure.Geo;
using PrivaPub.Infrastructure.Statistics;
using PrivaPub.Models;
using PrivaPub.Models.Jobs;

using System.Net;
using System.Net.Sockets;

namespace PrivaPub.Domain.Statistics
{
	public interface ISelfLocation
	{
		//where this server is, or default when it cannot tell; Source is "configured" when the owner set it (Statistics:Geo:Self)
		Task<InstanceGeo> Get(CancellationToken token);
	}

	// This server's own place, for the instance API (the client's globe draws every server from it). The owner may set it,
	// for a server behind a proxy or a CDN; otherwise the server's own host name is resolved and located like any other
	// server's, once a day. Never the address of a request.
	public class SelfLocation : ISelfLocation
	{
		static readonly TimeSpan Lifetime = TimeSpan.FromDays(1);

		readonly IGeoLocator _geo;
		readonly ICdnRanges _cdnRanges;
		readonly IOptionsMonitor<StatisticsOptions> _options;
		readonly IOptionsMonitor<AppConfiguration> _app;
		readonly ILogger<SelfLocation> _logger;
		readonly SemaphoreSlim _gate = new(1, 1);

		InstanceGeo _located;
		DateTime _locatedAt = DateTime.MinValue;

		public SelfLocation(IGeoLocator geo, IOptionsMonitor<StatisticsOptions> options, IOptionsMonitor<AppConfiguration> app, ILogger<SelfLocation> logger,
			ICdnRanges cdnRanges = default)
		{
			_geo = geo;
			_cdnRanges = cdnRanges;
			_options = options;
			_app = app;
			_logger = logger;
		}

		public async Task<InstanceGeo> Get(CancellationToken token)
		{
			if (_options.CurrentValue.Geo.Self is { Latitude: { } latitude, Longitude: { } longitude } self)
				return new InstanceGeo
				{
					Country = self.Country,
					City = self.City,
					Latitude = Math.Round(latitude, 1),
					Longitude = Math.Round(longitude, 1),
					Source = "configured"
				};

			if (DateTime.UtcNow - _locatedAt < Lifetime)
				return _located;
			await _gate.WaitAsync(token);
			try
			{
				if (DateTime.UtcNow - _locatedAt >= Lifetime)
				{
					_located = await Locate(token);
					_locatedAt = DateTime.UtcNow;
				}
				return _located;
			}
			finally
			{
				_gate.Release();
			}
		}

		async Task<InstanceGeo> Locate(CancellationToken token)
		{
			try
			{
				if (!Uri.TryCreate(_app.CurrentValue.BackendBaseAddress, UriKind.Absolute, out var self))
					return default;
				var addresses = await Dns.GetHostAddressesAsync(self.Host, token);
				var address = addresses.FirstOrDefault(a => a.AddressFamily == AddressFamily.InterNetwork) ?? addresses.FirstOrDefault();
				var fix = address == default ? default : _geo.Locate(address);
				var (cdn, cdnSource) = Federation.Objects.InstanceDescriber.Cdn(address, self.Host, fix?.Asn, _cdnRanges, default);
				return fix == default ? default : new InstanceGeo
				{
					Country = fix.Country,
					City = fix.City,
					Latitude = fix.Latitude,
					Longitude = fix.Longitude,
					Asn = fix.Asn,
					AsnOrg = fix.AsnOrg,
					Cdn = cdn?.Name,
					CdnDomain = cdn?.Domain,
					CdnSource = cdnSource,
					Ipv6 = address.AddressFamily == AddressFamily.InterNetworkV6,
					Source = _geo.Source,
					LocatedAt = DateTime.UtcNow
				};
			}
			catch (Exception ex) when (ex is SocketException or ArgumentException)
			{
				_logger.LogInformation("{Service}: this server's host does not resolve", nameof(SelfLocation));
				return default;
			}
		}
	}
}