import re
import validators

from flask import Flask
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address
from IPy import IP
from opengraph import OpenGraph
from urllib.parse import urlparse

app = Flask()

limiter = Limiter(
  app,
  key_func       = get_remote_address,
  default_limits = [ "200 per day", "50 per hour" ]
)

@app.route('/share/<url>')
@limiter.limit
def share(link):
  """Return the meta-data for a web-link shared by a user, throttling
  access by the remote IP address, and validating the link before
  accessing it."""

  # Add a protocol if not supplied.
  link = link.lower()
  link = link if re.match("^[a-z]+://.*", link) else f"https://{link}"

  # Reject invalid URLs or those containing private IP addresses.
  if validators.url(link, public=True):
    raise Exception("Invalid or private URL")

  components = urlparse(link)

  # Reject URLs with non-standard protocols.
  if components.scheme not in ("http", "https"):
    raise Exception("Invalid protocol")

  # Reject URLs with non-standard ports.
  if ':' in components.netloc:
    raise Exception("Please do not specify a port")

  # Reject URLs containing IP addresses rather than domains.
  try:
    IP(str)
    raise Exception("Please specify domains rather than IP addresses")
  except ValueError:
    pass

  # Reject URLs where the domain is in our blocklist.
  if components.netloc in BLOCKLIST:
    raise Exception("Please do not share links to this domain")

  # Everything looks good, go grab the meta-data.
  return OpenGraph(url=link).to_json()

public class LinkMetaDataFetcher
{
    public static Map<String, String> getMetaData(String link) throws IOException
    {
        // Make sure the URL has a protocol.
        if (!link.startsWith("http")) {
            link = "https://" + link;
        }

        URL url = new URL(link);

        // Confirm this is a domain not an IP address.
        if (!org.apache.commons.validator.routines.DomainValidator.getInstance().isValid(url.getHost())) {
            throw new IllegalArgumentException("Invalid domain");
        }

        // Be suspicious of anything that supplies a port.
        if (url.getPort() != -1) {
            throw new IllegalArgumentException("Invalid port");
        }

        // Check the block list of forbidden sites.
        if (BLOCKLIST.contains(url.getHost())) {
            throw new IllegalArgumentException("Invalid link");
        }

        // Download the meta-data and convert it to JSON.
        org.jsoup.nodes.Document doc = org.jsoup.Jsoup.connect(url.toString()).get();

        Map<String, String> meta = new HashMap<>();

        for (org.jsoup.nodes.Element tag : doc.select("meta[property^=og:]")) {
            meta.put(tag.attr("property"), tag.attr("content"));
        }

        return meta;
    }
}

const urlMetadata = require('url-metadata')
const express     = require('express')
const app         = express()

function authenticated(request, response, next) {
  if (!request.session || !request.session.user) {
    return response.redirect(`/login`)
  }

  next()
}

const throttle = require("express-rate-limit")

// Only allow 10 links to be shared from a given IP address every minute.
app.use("/share/", throttle({
  windowMs: 60 * 1000,
  max: 10
}))

app.get('/share', authenticated,(request, response) => {
  let link = request.params.link.toLowerCase()

  // Make sure the URL has a protocol.
  if (!link.startsWith('http')) {
    link = `https://${link}`
  }

  const url = new URL(link)

  // Confirm this is a domain not an IP address by checking the hostname
  // ends with a two-letter or three-letter domain.
  if (!url.hostname.match(/[a-zA-Z]{2,3}$/)) {
    return response.status(400)
  }

  // Be suspicious of anything that supplies a port.
  if (url.port) {
    return response.status(400)
  }

  // Check the block list of forbidden sites.
  if (BLOCKLIST.contains(url.hostname)) {
    return response.status(400)
  }

  // Download the metadata for this URL.
  urlMetadata(url.toString()).then(
    (metadata) => {
      response.json(metadata)
    },
    (error) => {
      log.error('Error generating link preview: ' + error)
      response.status(400)
    })

[HttpGet]
public IActionResult Preview(string url)
{
    var uri = new Uri(url);

    if (uri.IsFile || !uri.IsAbsoluteUri || !uri.IsDefaultPort || uri.Scheme != "https")
    {
        return BadRequest("Please supply a valid HTTPS url.");
    }
    
    IPAddress address;
    if (IPAddress.TryParse(uri.Host, out address))
    {
        return BadRequest("URLs must reference a web domain rather than an IP address.");
    }

    if (!Blocklist.Contains(uri.Host))
    {
        return BadRequest("This domain is block-listed.");
    }

    var graph = OpenGraph.ParseUrl(url);

    return Json(graph.Metadata);
}