/*
 * SPDX-FileCopyrightText: none
 * SPDX-License-Identifier: CC0-1.0
 */

package dev.metaschema.databind.codegen;

import java.io.IOException;
import java.io.StringWriter;
import java.nio.file.Path;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

import dev.metaschema.core.util.CollectionUtil;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;

/**
 * Provides support for compiling Java source files using the system Java
 * compiler.
 * <p>
 * This class wraps the {@link javax.tools.JavaCompiler} API to provide a
 * simplified interface for compiling generated Java source files. It supports
 * configuring the classpath, module path, and output directory.
 */
public class JavaCompilerSupport {
  @Nullable
  private Logger logger;
  @NonNull
  private final Path classDir;
  @NonNull
  private final Set<String> classPath = new LinkedHashSet<>();
  @NonNull
  private final Set<String> modulePath = new LinkedHashSet<>();
  @NonNull
  private final Set<String> rootModuleNames = new LinkedHashSet<>();

  /**
   * Construct a new compiler support instance.
   *
   * @param classDir
   *          the directory where compiled class files will be written
   */
  public JavaCompilerSupport(@NonNull Path classDir) {
    this.classDir = classDir;
  }

  /**
   * Get the configured classpath entries.
   *
   * @return the classpath entries
   */
  public Set<String> getClassPath() {
    return classPath;
  }

  /**
   * Get the configured module path entries.
   *
   * @return the module path entries
   */
  public Set<String> getModulePath() {
    return modulePath;
  }

  /**
   * Get the configured root module names.
   *
   * @return the root module names
   */
  public Set<String> getRootModuleNames() {
    return rootModuleNames;
  }

  /**
   * Add an entry to the classpath.
   *
   * @param entry
   *          the classpath entry to add
   */
  public void addToClassPath(@NonNull String entry) {
    classPath.add(entry);
  }

  /**
   * Add an entry to the module path.
   *
   * @param entry
   *          the module path entry to add
   */
  public void addToModulePath(@NonNull String entry) {
    modulePath.add(entry);
  }

  /**
   * Add a root module name.
   *
   * @param entry
   *          the root module name to add
   */
  public void addRootModule(@NonNull String entry) {
    rootModuleNames.add(entry);
  }

  /**
   * Set the logger for compilation messages.
   *
   * @param logger
   *          the logger to use
   */
  public void setLogger(@NonNull Logger logger) {
    this.logger = logger;
  }

  /**
   * Generate the compiler options based on the current configuration.
   *
   * @return the list of compiler options
   */
  @NonNull
  protected List<String> generateCompilerOptions() {
    List<String> options = new LinkedList<>();
    options.add("-d");
    options.add(classDir.toString());

    if (!classPath.isEmpty()) {
      options.add("-classpath");
      options.add(classPath.stream()
          .collect(Collectors.joining(":")));
    }

    if (!modulePath.isEmpty()) {
      options.add("-p");
      options.add(modulePath.stream()
          .collect(Collectors.joining(":")));
    }

    return options;
  }

  /**
   * Compile the provided Java source files.
   *
   * @param classFiles
   *          the source files to compile
   * @return information about the compilation result
   * @throws IOException
   *           if an error occurred while compiling the classes
   * @throws IllegalArgumentException
   *           if any of the options are invalid, or if any of the given
   *           compilation units are of other kind than
   *           {@link javax.tools.JavaFileObject.Kind#SOURCE}
   */
  public CompilationResult compile(@NonNull List<Path> classFiles) throws IOException {
    DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();

    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

    List<JavaFileObject> compilationUnits;
    try (StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null)) {

      compilationUnits = classFiles.stream()
          .map(fileManager::getJavaFileObjects)
          .map(CollectionUtil::toList)
          .flatMap(List::stream)
          .collect(Collectors.toUnmodifiableList());

      List<String> options = generateCompilerOptions();

      Logger logger = this.logger;
      if (logger != null && logger.isDebugEnabled()) {
        logger.debug(String.format("Using options: %s", options));
      }

      boolean result;
      try (StringWriter writer = new StringWriter()) {
        JavaCompiler.CompilationTask task = compiler.getTask(
            writer,
            fileManager,
            diagnostics,
            options,
            null,
            compilationUnits);
        task.addModules(rootModuleNames);

        result = task.call();
        writer.flush();
        String output = writer.toString();
        if (!output.isBlank() && logger != null && logger.isInfoEnabled()) {
          logger.info(String.format("compiler output: %s", writer.toString()));
        }
      }
      return new CompilationResult(result, diagnostics);
    }
  }

  /**
   * Contains the result of a compilation operation.
   */
  public static final class CompilationResult {
    private final boolean successful;
    @NonNull
    private final DiagnosticCollector<JavaFileObject> diagnostics;

    private CompilationResult(boolean successful, @NonNull DiagnosticCollector<JavaFileObject> diagnostics) {
      this.successful = successful;
      this.diagnostics = diagnostics;
    }

    /**
     * Check if the compilation was successful.
     *
     * @return {@code true} if compilation succeeded, {@code false} otherwise
     */
    public boolean isSuccessful() {
      return successful;
    }

    /**
     * Get the compilation diagnostics.
     *
     * @return the diagnostics collector containing any warnings or errors
     */
    public DiagnosticCollector<?> getDiagnostics() {
      return diagnostics;
    }
  }

  /**
   * A logging interface for compilation messages.
   */
  public interface Logger {
    /**
     * Check if debug logging is enabled.
     *
     * @return {@code true} if debug logging is enabled
     */
    boolean isDebugEnabled();

    /**
     * Check if info logging is enabled.
     *
     * @return {@code true} if info logging is enabled
     */
    boolean isInfoEnabled();

    /**
     * Log a debug message.
     *
     * @param msg
     *          the message to log
     */
    void debug(String msg);

    /**
     * Log an info message.
     *
     * @param msg
     *          the message to log
     */
    void info(String msg);
  }
}