/*
 * 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.drill.fmpp.mojo;

import static java.lang.String.format;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.concurrent.TimeUnit;

import org.apache.commons.io.FileUtils;
import org.apache.drill.fmpp.mojo.MavenDataLoader.MavenData;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;

import com.google.common.base.Stopwatch;

import fmpp.Engine;
import fmpp.ProgressListener;
import fmpp.progresslisteners.TerseConsoleProgressListener;
import fmpp.setting.Settings;
import fmpp.util.MiscUtil;

/**
 * a maven plugin to run the freemarker generation incrementally
 * (if output has not changed, the files are not touched)
 * @goal generate
 * @phase generate-sources
 */
public class FMPPMojo extends AbstractMojo {

  /**
   * Used to add new source directories to the build.
   * @parameter default-value="${project}"
   * @required
   * @readonly
   **/
  private MavenProject project;

  /**
   * Where to find the FreeMarker template files.
   *
   * @parameter default-value="src/main/resources/fmpp/templates/"
   * @required
   */
  private File templates;

  /**
   * Where to write the generated files of the output files.
   *
   * @parameter default-value="${project.build.directory}/generated-sources/fmpp/"
   * @required
   */
  private File output;

  /**
   * Location of the FreeMarker config file.
   *
   * @parameter default-value="src/main/resources/fmpp/config.fmpp"
   * @required
   */
  private File config;

  /**
   * compilation scope to be added to ("compile" or "test")
   *
   * @parameter default-value="compile"
   * @required
   */
  private String scope;

  /**
   * if maven properties are added as data
   *
   * @parameter default-value="true"
   * @required
   */
  private boolean addMavenDataLoader;

  @Override
  public void execute() throws MojoExecutionException, MojoFailureException {
    if (project == null) {
      throw new MojoExecutionException("This plugin can only be used inside a project.");
    }
    String outputPath = output.getAbsolutePath();
    if ((!output.exists() && !output.mkdirs()) || !output.isDirectory()) {
      throw new MojoFailureException("can not write to output dir: " + outputPath);
    }
    String templatesPath = templates.getAbsolutePath();
    if (!templates.exists() || !templates.isDirectory()) {
      throw new MojoFailureException("templates not found in dir: " + outputPath);
    }

    // add the output directory path to the project source directories
    switch (scope) {
      case "compile":
        project.addCompileSourceRoot(outputPath);
      break;
      case "test":
        project.addTestCompileSourceRoot(outputPath);
      break;
      default:
        throw new MojoFailureException("scope must be compile or test");
    }

    final Stopwatch sw = Stopwatch.createStarted();
    try {
      getLog().info(format("Freemarker generation:\n scope: %s,\n config: %s,\n templates: %s",
          scope, config.getAbsolutePath(), templatesPath));
      final File tmp = Files.createTempDirectory("freemarker-tmp").toFile();
      String tmpPath = tmp.getAbsolutePath();
      final String tmpPathNormalized = tmpPath.endsWith(File.separator) ? tmpPath : tmpPath + File.separator;
      Settings settings = new Settings(new File("."));
      settings.set(Settings.NAME_SOURCE_ROOT, templatesPath);
      settings.set(Settings.NAME_OUTPUT_ROOT, tmp.getAbsolutePath());
      settings.load(config);
      settings.addProgressListener(new TerseConsoleProgressListener());
      settings.addProgressListener(new ProgressListener() {
        @Override
        public void notifyProgressEvent(
            Engine engine, int event,
            File src, int pMode,
            Throwable error, Object param)
            throws Exception {
          if (event == EVENT_END_PROCESSING_SESSION) {
            getLog().info(format("Freemarker generation took %dms", sw.elapsed(TimeUnit.MILLISECONDS)));
            sw.reset();
            Report report = moveIfChanged(tmp, tmpPathNormalized);
            if (!tmp.delete()) {
              throw new MojoFailureException(format("can not delete %s", tmp));
            }
            getLog().info(format("Incremental output update took %dms", sw.elapsed(TimeUnit.MILLISECONDS)));
            getLog().info(format("new: %d", report.newFiles));
            getLog().info(format("changed: %d", report.changedFiles));
            getLog().info(format("unchanged: %d", report.unchangedFiles));
          }
        }
      } );
      if (addMavenDataLoader) {
        getLog().info("Adding maven data loader");
        settings.setEngineAttribute(MavenDataLoader.MAVEN_DATA_ATTRIBUTE, new MavenData(project));
        settings.add(Settings.NAME_DATA, format("maven: %s()", MavenDataLoader.class.getName()));
      }
      settings.execute();
    } catch (Exception e) {
      throw new MojoFailureException(MiscUtil.causeMessages(e), e);
    }
  }

  private static final class Report {
    int changedFiles;
    int unchangedFiles;
    int newFiles;
    Report(int changedFiles, int unchangedFiles, int newFiles) {
      super();
      this.changedFiles = changedFiles;
      this.unchangedFiles = unchangedFiles;
      this.newFiles = newFiles;
    }
    public Report() {
      this(0, 0, 0);
    }
    void add(Report other) {
      changedFiles += other.changedFiles;
      unchangedFiles += other.unchangedFiles;
      newFiles += other.newFiles;
    }
    public void addChanged() {
      ++ changedFiles;
    }
    public void addNew() {
      ++ newFiles;
    }
    public void addUnchanged() {
      ++ unchangedFiles;
    }
  }

  private Report moveIfChanged(File root, String tmpPath) throws MojoFailureException, IOException {
    Report report = new Report();
    for (File file : root.listFiles()) {
      if (file.isDirectory()) {
        report.add(moveIfChanged(file, tmpPath));
        if (!file.delete()) {
          throw new MojoFailureException(format("can not delete %s", file));
        }
      } else {
        String absPath = file.getAbsolutePath();
        if (!absPath.startsWith(tmpPath)) {
          throw new MojoFailureException(format("%s should start with %s", absPath, tmpPath));
        }
        String relPath = absPath.substring(tmpPath.length());
        File outputFile = new File(output, relPath);
        if (!outputFile.exists()) {
          report.addNew();
        } else if (!FileUtils.contentEquals(file, outputFile)) {
          getLog().info(format("%s has changed", relPath));
          if (!outputFile.delete()) {
            throw new MojoFailureException(format("can not delete %s", outputFile));
          }
          report.addChanged();
        } else {
          report.addUnchanged();
        }
        if (!outputFile.exists()) {
          File parentDir = outputFile.getParentFile();
          if (parentDir.exists() && !parentDir.isDirectory()) {
            throw new MojoFailureException(format("can not move %s to %s as %s is not a dir", file, outputFile, parentDir));
          }
          if (!parentDir.exists() && !parentDir.mkdirs()) {
            throw new MojoFailureException(format("can not move %s to %s as dir %s can not be created", file, outputFile, parentDir));
          }
          FileUtils.moveFile(file, outputFile);
        } else {
          if (!file.delete()) {
            throw new MojoFailureException(format("can not delete %s", file));
          }
        }
      }
    }
    return report;
  }

}