using System;

using VDS.Common.Tries;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Net.Sockets;

using System.Text;

​

public class Program

{

    private static readonly DomainNameTrie _excludedDomainNames = new();

    private static readonly IPAddressTrie _excludedIPAddresses = new();

    public static void Main()

    {

        /*

        _excludedDomainNames.Add("www.google.com", new(false));

        _excludedDomainNames.Add("www.pornhub.com", new(true));

        // _excludedIPAddresses.Add(new(IPAddress.Parse("8.8.8.8"), 32), new(false));

        // _excludedIPAddresses.Add(new(IPAddress.Parse("192.168.0.0"), 16), new(true));

        _excludedIPAddresses.Add(new(IPAddress.Parse("8.8.8.8"), 5), new(true));

        Console.WriteLine("Is 192.168.0.1 excluded: {0}", IsIPAddressExcluded(new(IPAddress.Parse("192.168.0.1"), 32)));

        Console.WriteLine("Is 192.168.255.255 excluded: {0}", IsIPAddressExcluded(new(IPAddress.Parse("192.168.255.255"), 32)));

        Console.WriteLine("Is 192.168.255.255 excluded: {0}", IsIPAddressExcluded(new(IPAddress.Parse("192.168.255.255"), 32)));

        Console.WriteLine("Is 8.8.8.8 excluded: {0}", IsIPAddressExcluded(new(IPAddress.Parse("8.8.8.8"), 32)));

        Console.WriteLine("Is 8.8.8.9 excluded: {0}", IsIPAddressExcluded(new(IPAddress.Parse("8.8.8.9"), 32)));

        */

        InlineData("0.0.0.0/0", "0.0.0.0", "127.127.127.127", "255.255.255.255"); // the whole IPv4 space

        /*InlineData("::/0", "::", "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); // the whole IPv6 space

        InlineData("255.255.255.255/32", "255.255.255.255"); // single IPv4 address

        InlineData("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128", "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); // single IPv6 address

        InlineData("255.255.255.0/24", "255.255.255.0", "255.255.255.255");

        InlineData("198.51.248.0/22", "198.51.248.0", "198.51.250.42", "198.51.251.255");

        InlineData("255.255.255.128/25", "255.255.255.128", "255.255.255.129", "255.255.255.255");

        InlineData("2a00::/13", "2a00::", "2a00::1", "2a01::", "2a07::", "2a07:ffff:ffff:ffff:ffff:ffff:ffff:ffff");

        InlineData("2a01:110:8012::/47", "2a01:110:8012::", "2a01:110:8012:42::", "2a01:110:8013::", "2a01:110:8013:ffff:ffff:ffff:ffff:ffff");

        InlineData("2a01:110:8012:1012:314f:2a00::/87", "2a01:110:8012:1012:314f:2a00::", "2a01:110:8012:1012:314f:2a00::1", "2a01:110:8012:1012:314f:2a00:abcd:4242", "2a01:110:8012:1012:314f:2bff:ffff:ffff");

        InlineData("2a01:110:8012:1010:914e:2451:1700:0/105", "2a01:110:8012:1010:914e:2451:1700:0", "2a01:110:8012:1010:914e:2451:1742:4242", "2a01:110:8012:1010:914e:2451:177f:ffff");*/

​

        /*

        Console.WriteLine("google.com is {0}.", IsDomainNameExcluded("google.com") ? "excluded" : "not excluded");

        Console.WriteLine("web.google.com is {0}.", IsDomainNameExcluded("web.google.com") ? "excluded" : "not excluded");

        Console.WriteLine("pornhub.com. is {0}.", IsDomainNameExcluded("pornhub.com.") ? "excluded" : "not excluded");

        Console.WriteLine("static.www.pornhub.com. is {0}.", IsDomainNameExcluded("static.www.pornhub.com.") ? "excluded" : "not excluded");

        Console.WriteLine("www.pornhub.com is {0}.", IsDomainNameExcluded("www.pornhub.com") ? "excluded" : "not excluded");

        */

    }

    public static void InlineData(string ipNetworkString, params string[] ipAddressesStrings)

    {

        var splitIpNetwork = ipNetworkString.Split('/');

        var ipTrie = new IPAddressTrie();

        var ipNetwork = new IPNetwork(IPAddress.Parse(splitIpNetwork[0]), Convert.ToUInt16(splitIpNetwork[1]));

        ipTrie.Add(ipNetwork, new(true));

        foreach (var addressString in ipAddressesStrings)

        {

            var address = IPAddress.Parse(addressString);

            ushort cidrSuffix = address.AddressFamily switch 

            {

                AddressFamily.InterNetwork => 32,

                AddressFamily.InterNetworkV6 => 128,

                _ => throw new NotSupportedException()  

            };

            var specificIPAddressNetwork = new IPNetwork(address, cidrSuffix);

            if (!IsIPAddressExcluded(specificIPAddressNetwork))

            {

                Console.WriteLine("{0} was not contained within {1}.", addressString, ipNetworkString); 

            }

        }

    }

    public static bool IsDomainNameExcluded(string domainName)

    {

        if (_excludedDomainNames.ContainsKey(domainName))

            return true;

        var predecessor = _excludedDomainNames.FindPredecessor(domainName);

        if (predecessor is null || predecessor.IsRoot)

            return false;

        return predecessor.Value.AllowSubdomains;

    }

    public static bool IsIPAddressExcluded(IPNetwork network)

    {

        if (_excludedIPAddresses.ContainsKey(network))

            return true;

        Console.WriteLine("{0}/{1} was not explicitly added as an exclusion.", network.Address, network.CidrSuffix);

        var predecessor = _excludedIPAddresses.FindPredecessor(network);

        Console.WriteLine("{0}/{1} predecessor {2}", network.Address, network.CidrSuffix, predecessor is null ? "is null" : "is not null");

        if (predecessor is null)

            return false;

        return predecessor.Value.AllowIpAddressesInCidrRange;

    }

}

​

public record DomainNameTrieNode(bool AllowSubdomains);

​

/// <summary>

/// In order to allow for faster lookups, we split things up into a trie that can properly do reverse and suffix searches.

/// </summary>

internal class DomainNameTrie : AbstractTrie<string, char, DomainNameTrieNode>, IComparer<char>

{

    public DomainNameTrie() : base(DomainNameTrieKeyMapper, new TrieNode<char, DomainNameTrieNode>(null, '.'))

    {

        KeyBitComparer = this;

    }

​

    /// <remarks>This key mapper lowercases the string and then reverses it. This way the string we pass into the Trie can be a standard string</remarks>

    static IEnumerable<char> DomainNameTrieKeyMapper(string key)

    {

        // All subdomains end with an implicit period (i.e. the root)

        if (!key.EndsWith('.'))

            yield return '.';

        foreach (var value in key.Reverse())

            yield return char.ToLowerInvariant(value);

    }

​

    protected override ITrieNode<char, DomainNameTrieNode> CreateRoot(char key)

        => new TrieNode<char, DomainNameTrieNode>(null, key);

​

    public int Compare(char x, char y)

        => char.ToLowerInvariant(x).CompareTo(char.ToLowerInvariant(y));

}

​

public record IPAddressTrieNode(bool AllowIpAddressesInCidrRange);

public readonly record struct IPNetwork(IPAddress Address, ushort CidrSuffix);

​

internal class IPAddressTrie : AbstractTrie<IPNetwork, char, IPAddressTrieNode>, IComparer<char>

{

    public IPAddressTrie() : base(IPAddressTrieKeyMapper, new TrieNode<char, IPAddressTrieNode>(null, '.'))

    {

        KeyBitComparer = this;

    }

    private static IEnumerable<char> IPAddressTrieKeyMapper(IPNetwork network)

    {

        var bitString = ".".Concat(network.Address.GetAddressBytes().SelectMany(x => Convert.ToString(x, 2).PadLeft(8, '0')).Take(network.CidrSuffix));

        // Console.WriteLine("{0}/{1}: {2}", network.Address, network.CidrSuffix, string.Join(string.Empty, bitString));

        return bitString;

    }

​

    protected override ITrieNode<char, IPAddressTrieNode> CreateRoot(char key)

        => new TrieNode<char, IPAddressTrieNode>(null, key);

    public int Compare(char x, char y)

        => char.ToLowerInvariant(x).CompareTo(char.ToLowerInvariant(y));

}