/*
    * The coLAB project
    * Copyright (C) 2022-2023 AlbaSim, MEI, HEIG-VD, HES-SO
    *
    * Licensed under the MIT License
    */
   package ch.colabproject.colab.api.controller.document;
   
   import ch.colabproject.colab.api.controller.RequestManager;
  import ch.colabproject.colab.api.rest.document.bean.UrlMetadata;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.net.URI;
  import java.net.URLDecoder;
  import java.nio.charset.StandardCharsets;
  import java.time.OffsetDateTime;
  import java.util.HashMap;
  import java.util.Iterator;
  import javax.cache.Cache;
  import javax.ejb.LocalBean;
  import javax.ejb.Stateless;
  import javax.inject.Inject;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.hc.client5.http.classic.methods.HttpGet;
  import org.apache.hc.client5.http.impl.classic.HttpClients;
  import org.apache.hc.core5.http.Header;
  import org.apache.hc.core5.http.HttpEntity;
  import org.apache.hc.core5.net.URIBuilder;
  import org.jsoup.Jsoup;
  import org.jsoup.nodes.Document;
  import org.jsoup.select.Elements;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * To deal with external data
   *
   * @author maxence
   */
  @Stateless
  @LocalBean
  public class ExternalDataManager {
  
      /** duration an entry may stay in cache before being drop or refreshed */
      private static final int CACHE_TTL_HOUR = 24;
  
      /** Logger */
      private static final Logger logger = LoggerFactory.getLogger(UrlMetadata.class);
  
      /** Open graph title property */
      private static final String OG_TITLE = "og:title";
  
      /** Open graph title */
      private static final String OG_URL = "og:url";
  
      /** Open graph image */
      private static final String OG_IMAGE = "og:image";
  
      /**
       * cache metadata to avoid spamming external services.
       */
      @Inject
      private Cache<String, UrlMetadata> metadataCache;
  
      /** get the baseUrl of the application */
      @Inject
      private RequestManager requestManager;
  
      /**
       * Read response entity as stream
       *
       * @param entity http entity to read
       *
       * @return the string
       *
       * @throws IOException if something went wrong
       */
      private static String getEntityAsString(HttpEntity entity) throws IOException {
          if (entity != null) {
              ByteArrayOutputStream baos = new ByteArrayOutputStream();
              entity.writeTo(baos);
              return baos.toString("UTF-8");
          } else {
              return "";
          }
      }
  
      /**
       * Is the given data outdated?
       *
       * @param data metadata to check
       *
       * @return true if data is outdated
       */
      private boolean isOutdated(UrlMetadata data) {
          OffsetDateTime date = data.getDate();
          if (date != null) {
              OffsetDateTime endOfLife = date.plusHours(CACHE_TTL_HOUR);
              if (endOfLife.isAfter(OffsetDateTime.now())) {
                 return false;
             }
         }
 
         return true;
     }
 
     /**
      * Get cached Url metadata. if exists of build fresh
      *
      * @param url url to fetch metadata for
      *
      * @return url metadata
      */
     public UrlMetadata getUrlMetadata(String url) {
         try {
             UrlMetadata cached = metadataCache.get(url);
             if (cached != null && !isOutdated(cached)) {
                 logger.trace("Get {} from cache", url);
                 return cached;
             }
         } catch (Throwable t) {
             logger.trace("Failed to fetch {} from cache {}", url, t);
             metadataCache.remove(url);
         }
         return this.refreshAndGetUrlMetadata(url);
     }
 
     /**
      * Make sure url starts with a protocol
      *
      * @param url             to sanitize
      * @param defaultProtocol default protocol to use. http is the default defaultProtocol
      *
      * @return url with protocol
      */
     private String sanitizeUrl(String rawUrl, String defaultProtocol) {
         if (!rawUrl.matches("[a-z-A-Z0-9]*://.*")) {
             // There is no protocol, add default one
             if (StringUtils.isEmpty(defaultProtocol)) {
                 return "http://" + rawUrl;
             } else {
                 return defaultProtocol + "://" + rawUrl;
             }
         }
         return rawUrl;
     }
 
     /**
      * Update cache with fresh metadata
      *
      * @param url url to fetch metadata for
      *
      * @return url metadata
      */
     public UrlMetadata refreshAndGetUrlMetadata(String url) {
 
         UrlMetadata urlMetadata = new UrlMetadata();
         urlMetadata.setBroken(true);
         HashMap<String, String> metadata = new HashMap<>();
         urlMetadata.setMetadata(metadata);
 
         String decoded = URLDecoder.decode(url, StandardCharsets.UTF_8);
 
         // hack: intercept loobpack link
         String baseUrl = requestManager.getBaseUrl();
         if (decoded.startsWith(baseUrl)) {
             logger.trace("Loopback url intercepted");
             urlMetadata.setBroken(false);
             metadata.put(OG_IMAGE, baseUrl + "/favicon_128.png");
             metadata.put(OG_URL, decoded);
         } else {
 
             logger.trace("Raw URL {}", url);
             try (var client = HttpClients.createDefault()) {
                 String sanitizedUrl = sanitizeUrl(url, null);
 
                 URIBuilder uriBuilder = new URIBuilder(sanitizedUrl, StandardCharsets.UTF_8);
 
                 URI uri = uriBuilder.normalizeSyntax().build();
                 metadata.put(OG_URL, url);
 
                 String[] segs = uri.getPath().split("/");
                 if (segs != null && segs.length > 0) {
                     // default og:name to last path segment
                     String filename = segs[segs.length - 1];
                     metadata.put(OG_TITLE, filename);
                 } else {
                     // otherwise, default to hostname
                     metadata.put(OG_TITLE, uri.getHost());
                 }
 
                 var get = new HttpGet(uri);
                 try (var response = client.execute(get)) {
 
                     HttpEntity entity = response.getEntity();
                     int statusCode = response.getCode();
 
                     if (statusCode < 400) {
                         // success
                         urlMetadata.setBroken(false);
 
                         Header firstHeader = response.getFirstHeader("content-type");
                         String contentType = firstHeader.getValue();
                         int separator = contentType.indexOf(';');
 
                         if (separator > 0) {
                             contentType = contentType.substring(0, separator);
                         }
 
                         if (contentType != null) {
                             urlMetadata.setContentType(contentType);
                             if (contentType.equals("text/html")) {
                                 // try to fetch metadata in head meta tags
                                 String html = getEntityAsString(entity);
                                 Document htmlDocument = Jsoup.parse(html, url);
                                 Elements metas = htmlDocument.head().select("meta");
                                 metas.forEach(meta -> {
                                     String prop = meta.attr("property");
                                     String name = meta.attr("name");
                                     if (prop != null && prop.indexOf(':') >= 0
                                         || name != null && name.indexOf(':') >= 0) {
                                         metadata.put(prop, meta.attr("content"));
                                     }
                                 });
                             }
                         }
                     }
 
                 }
             } catch (Exception e) {
                 logger.debug("Major Failure", e);
                 urlMetadata.setBroken(true);
             }
         }
         urlMetadata.setDate(OffsetDateTime.now());
         // cache metadata
         metadataCache.put(url, urlMetadata);
         return urlMetadata;
     }
 
     /**
      * Drop outdated entries from cache
      */
     public void clearOutdated() {
         Iterator<Cache.Entry<String, UrlMetadata>> iterator = metadataCache.iterator();
         while (iterator.hasNext()) {
             Cache.Entry<String, UrlMetadata> entry = iterator.next();
             UrlMetadata data = entry.getValue();
             if (isOutdated(data)) {
                 iterator.remove();
             }
         }
     }
 
 }