/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  package org.apache.maven.report.projectinfo;
  
  import javax.inject.Inject;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.List;
  import java.util.Locale;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.commons.validator.routines.UrlValidator;
  import org.apache.maven.doxia.sink.Sink;
  import org.apache.maven.doxia.util.DoxiaUtils;
  import org.apache.maven.model.License;
  import org.apache.maven.plugins.annotations.Mojo;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.ProjectBuilder;
  import org.apache.maven.reporting.MavenReportException;
  import org.apache.maven.repository.RepositorySystem;
  import org.apache.maven.settings.Settings;
  import org.codehaus.plexus.i18n.I18N;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * Generates the Project Licenses report.
   *
   * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
   * @since 2.0
   */
  @Mojo(name = "licenses")
  public class LicensesReport extends AbstractProjectInfoReport {
      // ----------------------------------------------------------------------
      // Mojo parameters
      // ----------------------------------------------------------------------
  
      /**
       * Whether the system is currently offline.
       */
      @Parameter(property = "settings.offline")
      private boolean offline;
  
      /**
       * Whether the only render links to the license documents instead of inlining them.
       * <br/>
       * If the system is in {@link #offline} mode, the linkOnly parameter will be always <code>true</code>.
       *
       * @since 2.3
       */
      @Parameter(defaultValue = "false")
      private boolean linkOnly;
  
      /**
       * Specifies the input encoding of the project's license file(s).
       *
       * @since 2.8
       */
      @Parameter
      private String licenseFileEncoding;
  
      @Inject
      public LicensesReport(RepositorySystem repositorySystem, I18N i18n, ProjectBuilder projectBuilder) {
          super(repositorySystem, i18n, projectBuilder);
      }
  
      // ----------------------------------------------------------------------
      // Public methods
      // ----------------------------------------------------------------------
  
      @Override
      public boolean canGenerateReport() throws MavenReportException {
          boolean result = super.canGenerateReport();
          if (result && skipEmptyReport) {
              result = !isEmpty(getProject().getModel().getLicenses());
          }
  
          if (!result) {
              return false;
         }
 
         if (!offline) {
             return true;
         }
 
         for (License license : project.getModel().getLicenses()) {
             String url = license.getUrl();
 
             URL licenseUrl = null;
             try {
                 licenseUrl = getLicenseURL(project, url);
             } catch (IOException e) {
                 getLog().error(e.getMessage());
             }
 
             if (licenseUrl != null && licenseUrl.getProtocol().equals("file")) {
                 return true;
             }
 
             if (licenseUrl != null
                     && (licenseUrl.getProtocol().equals("http")
                             || licenseUrl.getProtocol().equals("https"))) {
                 linkOnly = true;
                 return true;
             }
         }
 
         return false;
     }
 
     @Override
     public void executeReport(Locale locale) {
         LicensesRenderer r = new LicensesRenderer(
                 getSink(), getProject(), getI18N(locale), locale, settings, linkOnly, licenseFileEncoding);
 
         r.render();
     }
 
     /**
      * {@inheritDoc}
      */
     public String getOutputName() {
         return "licenses";
     }
 
     @Override
     protected String getI18Nsection() {
         return "licenses";
     }
 
     /**
      * @param project not null
      * @param url     not null
      * @return a valid URL object from the url string
      * @throws IOException if any
      */
     protected static URL getLicenseURL(MavenProject project, String url) throws IOException {
         URL licenseUrl;
         UrlValidator urlValidator = new UrlValidator(UrlValidator.ALLOW_ALL_SCHEMES);
         // UrlValidator does not accept file URLs because the file
         // URLs do not contain a valid authority (no hostname).
         // As a workaround accept license URLs that start with the
         // file scheme.
         if (urlValidator.isValid(url) || StringUtils.defaultString(url).startsWith("file://")) {
             try {
                 licenseUrl = new URL(url);
             } catch (MalformedURLException e) {
                 throw new MalformedURLException("The license url '" + url + "' seems to be invalid: " + e.getMessage());
             }
         } else {
             File licenseFile = new File(project.getBasedir(), url);
             if (!licenseFile.exists()) {
                 // Workaround to allow absolute path names while
                 // staying compatible with the way it was...
                 licenseFile = new File(url);
             }
             if (!licenseFile.exists()) {
                 throw new IOException("Maven can't find the file '" + licenseFile + "' on the system.");
             }
             try {
                 licenseUrl = licenseFile.toURI().toURL();
             } catch (MalformedURLException e) {
                 throw new MalformedURLException("The license url '" + url + "' seems to be invalid: " + e.getMessage());
             }
         }
 
         return licenseUrl;
     }
 
     // ----------------------------------------------------------------------
     // Private
     // ----------------------------------------------------------------------
 
     /**
      * Internal renderer class
      */
     private static class LicensesRenderer extends AbstractProjectInfoRenderer {
         private final MavenProject project;
 
         private final Settings settings;
 
         private final boolean linkOnly;
 
         private final String licenseFileEncoding;
 
         LicensesRenderer(
                 Sink sink,
                 MavenProject project,
                 I18N i18n,
                 Locale locale,
                 Settings settings,
                 boolean linkOnly,
                 String licenseFileEncoding) {
             super(sink, i18n, locale);
 
             this.project = project;
 
             this.settings = settings;
 
             this.linkOnly = linkOnly;
 
             this.licenseFileEncoding = licenseFileEncoding;
         }
 
         @Override
         protected String getI18Nsection() {
             return "licenses";
         }
 
         @Override
         protected void renderBody() {
             List<License> licenses = project.getModel().getLicenses();
 
             if (licenses.isEmpty()) {
                 startSection(getTitle());
 
                 paragraph(getI18nString("nolicense"));
 
                 endSection();
 
                 return;
             }
 
             // Overview
             startSection(getI18nString("overview.title"));
 
             paragraph(getI18nString("overview.intro"));
 
             endSection();
 
             // License
             startSection(getI18nString("title"));
 
             if (licenses.size() > 1) {
                 // multiple licenses
                 paragraph(getI18nString("multiple"));
 
                 if (!linkOnly) {
                     // add an index before licenses content
                     sink.list();
                     for (License license : licenses) {
                         String name = license.getName();
                         if (name == null || name.isEmpty()) {
                             name = getI18nString("unnamed");
                         }
 
                         sink.listItem();
                         link("#" + DoxiaUtils.encodeId(name), name);
                         sink.listItem_();
                     }
                     sink.list_();
                 }
             }
 
             for (License license : licenses) {
                 String name = license.getName();
                 if (name == null || name.isEmpty()) {
                     name = getI18nString("unnamed");
                 }
 
                 String url = license.getUrl();
                 String comments = license.getComments();
 
                 startSection(name);
 
                 if (!(comments == null || comments.isEmpty())) {
                     paragraph(comments);
                 }
 
                 if (url != null) {
                     try {
                         URL licenseUrl = getLicenseURL(project, url);
 
                         if (linkOnly) {
                             link(licenseUrl.toExternalForm(), licenseUrl.toExternalForm());
                         } else {
                             renderLicenseContent(licenseUrl);
                         }
                     } catch (IOException e) {
                         // I18N message
                         paragraph(e.getMessage());
                     }
                 }
 
                 endSection();
             }
 
             endSection();
         }
 
         /**
          * Render the license content into the report.
          *
          * @param licenseUrl the license URL
          */
         private void renderLicenseContent(URL licenseUrl) {
             try {
                 // All licenses are supposed to be in English...
                 String licenseContent = ProjectInfoReportUtils.getContent(licenseUrl, settings, licenseFileEncoding);
 
                 // TODO: we should check for a text/html mime type instead, and possibly use a html parser to do this a
                 // bit more cleanly/reliably.
                 String licenseContentLC = licenseContent.toLowerCase(Locale.ENGLISH);
                 int bodyStart = licenseContentLC.indexOf("<body");
                 int bodyEnd = licenseContentLC.indexOf("</body>");
 
                 if ((licenseContentLC.contains("<!doctype html") || licenseContentLC.contains("<html>"))
                         && ((bodyStart >= 0) && (bodyEnd > bodyStart))) {
                     bodyStart = licenseContentLC.indexOf('>', bodyStart) + 1;
                     String body = licenseContent.substring(bodyStart, bodyEnd);
 
                     link(licenseUrl.toExternalForm(), getI18nString("originalText"));
                     paragraph(getI18nString("copy"));
 
                     body = replaceRelativeLinks(body, baseURL(licenseUrl).toExternalForm());
                     sink.rawText(body);
                 } else {
                     verbatimText(licenseContent);
                 }
             } catch (IOException e) {
                 paragraph("Can't read the url [" + licenseUrl + "] : " + e.getMessage());
             }
         }
 
         private static URL baseURL(URL aUrl) {
             String urlTxt = aUrl.toExternalForm();
             int lastSlash = urlTxt.lastIndexOf('/');
             if (lastSlash > -1) {
                 try {
                     return new URL(urlTxt.substring(0, lastSlash + 1));
                 } catch (MalformedURLException e) {
                     throw new AssertionError(e);
                 }
             }
 
             return aUrl;
         }
 
         private static String replaceRelativeLinks(String html, String baseURL) {
             String url = baseURL;
             if (!url.endsWith("/")) {
                 url += "/";
             }
 
             String serverURL = url.substring(0, url.indexOf('/', url.indexOf("//") + 2));
 
             String content = replaceParts(html, url, serverURL, "[aA]", "[hH][rR][eE][fF]");
             content = replaceParts(content, url, serverURL, "[iI][mM][gG]", "[sS][rR][cC]");
             return content;
         }
 
         private static String replaceParts(
                 String html, String baseURL, String serverURL, String tagPattern, String attributePattern) {
             Pattern anchor = Pattern.compile(
                     "(<\\s*" + tagPattern + "\\s+[^>]*" + attributePattern + "\\s*=\\s*\")([^\"]*)\"([^>]*>)");
             StringBuilder sb = new StringBuilder(html);
 
             int indx = 0;
             boolean done = false;
             while (!done) {
                 Matcher mAnchor = anchor.matcher(sb);
                 if (mAnchor.find(indx)) {
                     indx = mAnchor.end(3);
 
                     if (mAnchor.group(2).startsWith("#")) {
                         // relative link - don't want to alter this one!
                     }
                     if (mAnchor.group(2).startsWith("/")) {
                         // root link
                         sb.insert(mAnchor.start(2), serverURL);
                         indx += serverURL.length();
                     } else if (mAnchor.group(2).indexOf(':') < 0) {
                         // relative link
                         sb.insert(mAnchor.start(2), baseURL);
                         indx += baseURL.length();
                     }
                 } else {
                     done = true;
                 }
             }
             return sb.toString();
         }
     }
 }