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

package dev.metaschema.model.testing;

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.apache.logging.log4j.LogBuilder;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.DynamicContainer;
import org.junit.jupiter.api.DynamicNode;
import org.junit.jupiter.api.DynamicTest;
import org.junit.platform.commons.JUnitException;

import java.io.IOException;
import java.io.Writer;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.StandardOpenOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;

import dev.metaschema.core.model.IModule;
import dev.metaschema.core.model.MetaschemaException;
import dev.metaschema.core.model.validation.IContentValidator;
import dev.metaschema.core.model.validation.IValidationFinding;
import dev.metaschema.core.model.validation.IValidationResult;
import dev.metaschema.core.model.validation.JsonSchemaContentValidator.JsonValidationFinding;
import dev.metaschema.core.util.ObjectUtils;
import dev.metaschema.databind.IBindingContext;
import dev.metaschema.databind.io.Format;
import dev.metaschema.databind.io.ISerializer;
import dev.metaschema.databind.model.metaschema.IBindingModuleLoader;
import dev.metaschema.model.testing.testsuite.GenerateSchema;
import dev.metaschema.model.testing.testsuite.Metaschema;
import dev.metaschema.model.testing.testsuite.TestCollection;
import dev.metaschema.model.testing.testsuite.TestScenario;
import dev.metaschema.model.testing.testsuite.TestSuite;
import dev.metaschema.model.testing.testsuite.ValidationCase;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import nl.talsmasoftware.lazy4j.Lazy;

/**
 * This abstract implementation dynamically produces JUnit tests based on a test
 * suite definition.
 *
 * @see #getTestSuiteURI()
 */
@SuppressWarnings({
    "PMD.GodClass",
    "PMD.CouplingBetweenObjects"
})
public abstract class AbstractTestSuite {
  private static final Logger LOGGER = LogManager.getLogger(AbstractTestSuite.class);

  private static final boolean DELETE_RESULTS_ON_EXIT = false;
  private static final OpenOption[] OPEN_OPTIONS_TRUNCATE = {
      StandardOpenOption.CREATE,
      StandardOpenOption.WRITE,
      StandardOpenOption.TRUNCATE_EXISTING
  };

  private static final String VALID = "VALID";

  /**
   * Get the content format used by the test suite.
   *
   * @return the format
   */
  @NonNull
  protected abstract Format getRequiredContentFormat();

  /**
   * Get the resource describing the tests to execute.
   *
   * @return the resource
   */
  @NonNull
  protected abstract URI getTestSuiteURI();

  /**
   * Get the filesystem location to use for generating content.
   *
   * @return the filesystem path
   */
  @NonNull
  protected abstract Path getGenerationPath();

  /**
   * Get the method used to generate a schema using a given Metaschema module and
   * writer.
   *
   * @return the schema generator supplier
   */
  @NonNull
  protected abstract BiFunction<IModule, Writer, Void> getSchemaGeneratorSupplier();

  /**
   * Get the method used to provide a schema validator.
   *
   * @return the method as a supplier
   */
  @Nullable
  protected abstract Supplier<? extends IContentValidator> getSchemaValidatorSupplier();

  /**
   * Get the method used to provide a content validator.
   *
   * @return the method as a supplier
   */
  @NonNull
  protected abstract Function<Path, ? extends IContentValidator> getContentValidatorSupplier();

  /**
   * Dynamically generate the unit tests.
   *
   * @param bindingContext
   *          the Module binding context
   *
   * @return the steam of unit tests
   */
  @NonNull
  protected Stream<DynamicNode> testFactory(@NonNull IBindingContext bindingContext) {
    try {
      Path generationPath = getGenerationPath();
      if (Files.exists(generationPath)) {
        if (!Files.isDirectory(generationPath)) {
          throw new JUnitException(String.format("Generation path '%s' exists and is not a directory", generationPath));
        }
      } else {
        Files.createDirectories(generationPath);
      }

      URI testSuiteUri = getTestSuiteURI();
      URL testSuiteUrl = testSuiteUri.toURL();
      TestSuite testSuite = bindingContext.newBoundLoader().load(TestSuite.class, testSuiteUrl);
      List<TestCollection> testCollections = testSuite.getTestCollections();
      return ObjectUtils.notNull(testCollections.stream()
          .flatMap(
              collection -> Stream
                  .of(generateCollection(
                      ObjectUtils.notNull(collection),
                      testSuiteUri,
                      generationPath,
                      bindingContext))));
    } catch (IOException | URISyntaxException ex) {
      throw new JUnitException("Unable to generate tests", ex);
    }
  }

  /**
   * Configure removal of the provided directory after test execution.
   *
   * @param path
   *          the directory to configure for removal
   */
  protected void deleteCollectionOnExit(@NonNull Path path) {
    Runtime.getRuntime().addShutdownHook(new Thread( // NOPMD - this is not a webapp
        () -> {
          try {
            Files.walkFileTree(path, new SimpleFileVisitor<>() {
              @Override
              public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                Files.delete(file);
                return FileVisitResult.CONTINUE;
              }

              @Override
              public FileVisitResult postVisitDirectory(Path dir, IOException ex) throws IOException {
                if (ex == null) {
                  Files.delete(dir);
                  return FileVisitResult.CONTINUE;
                }
                // directory iteration failed for some reason
                throw ex;
              }
            });
          } catch (IOException ex) {
            throw new JUnitException("Failed to delete collection: " + path, ex);
          }
        }));
  }

  private DynamicContainer generateCollection(
      @NonNull TestCollection collection,
      @NonNull URI testSuiteUri,
      @NonNull Path generationPath,
      @NonNull IBindingContext bindingContext) {
    URI collectionUri = testSuiteUri.resolve(collection.getLocation());
    assert collectionUri != null;

    LOGGER.atInfo().log("Collection: " + collectionUri);
    Lazy<Path> collectionGenerationPath = ObjectUtils.notNull(Lazy.of(() -> {
      Path retval;
      try {
        retval = ObjectUtils.requireNonNull(Files.createTempDirectory(generationPath, "collection-"));
        if (DELETE_RESULTS_ON_EXIT) {
          deleteCollectionOnExit(ObjectUtils.requireNonNull(retval));
        }
      } catch (IOException ex) {
        throw new JUnitException("Unable to create collection temp directory", ex);
      }
      return retval;
    }));

    List<TestScenario> testScenarios = collection.getTestScenarios();
    return DynamicContainer.dynamicContainer(
        collection.getName(),
        testSuiteUri,
        testScenarios.stream()
            .flatMap(scenario -> {
              assert scenario != null;
              return Stream.of(generateScenario(
                  scenario,
                  collectionUri,
                  collectionGenerationPath,
                  bindingContext));
            })
            .sequential());
  }

  @NonNull
  private Path generateSchema(
      @NonNull IModule module,
      @NonNull Lazy<Path> scenarioGenerationPath) {
    String schemaExtension;
    Format requiredContentFormat = getRequiredContentFormat();
    switch (requiredContentFormat) {
    case JSON:
    case YAML:
      schemaExtension = ".json";
      break;
    case XML:
      schemaExtension = ".xsd";
      break;
    default:
      throw new IllegalStateException(String.format("Unhandled content format '%s'.", requiredContentFormat));
    }

    // determine what file to use for the schema
    Path schemaPath;
    try {
      schemaPath = Files.createTempFile(scenarioGenerationPath.get(), "", "-schema" + schemaExtension);
    } catch (IOException ex) {
      throw new JUnitException("Unable to create schema temp file", ex);
    }
    try {
      generateSchema(ObjectUtils.notNull(module), ObjectUtils.notNull(schemaPath), getSchemaGeneratorSupplier());
    } catch (IOException ex) {
      throw new IllegalStateException(ex);
    }
    return ObjectUtils.notNull(schemaPath);
  }

  /**
   * Generate a schema for the provided module using the provided schema
   * generator.
   *
   * @param module
   *          the Metaschema module to generate the schema for
   * @param schemaPath
   *          the location to generate the schema
   * @param schemaProducer
   *          the method callback to use to generate the schema
   * @throws IOException
   *           if an error occurred while writing the schema
   */
  protected void generateSchema(
      @NonNull IModule module,
      @NonNull Path schemaPath,
      @NonNull BiFunction<IModule, Writer, Void> schemaProducer) throws IOException {
    Path parentDir = schemaPath.getParent();
    if (parentDir != null && !Files.exists(parentDir)) {
      Files.createDirectories(parentDir);
    }

    try (Writer writer = Files.newBufferedWriter(
        schemaPath,
        StandardCharsets.UTF_8,
        getWriteOpenOptions())) {
      schemaProducer.apply(module, writer);
    }
    LOGGER.atInfo().log("Produced schema '{}' for module '{}'", schemaPath, module.getLocation());
  }

  /**
   * The the options for writing generated content.
   *
   * @return the options
   */
  @SuppressWarnings("PMD.MethodReturnsInternalArray")
  protected OpenOption[] getWriteOpenOptions() {
    return OPEN_OPTIONS_TRUNCATE;
  }

  @SuppressWarnings("PMD.AvoidCatchingGenericException")
  private DynamicContainer generateScenario(
      @NonNull TestScenario scenario,
      @NonNull URI collectionUri,
      @NonNull Lazy<Path> collectionGenerationPath,
      @NonNull IBindingContext bindingContext) {
    Lazy<Path> scenarioGenerationPath = ObjectUtils.notNull(Lazy.of(() -> {
      Path retval;
      try {
        retval = Files.createTempDirectory(collectionGenerationPath.get(), "scenario-");
      } catch (IOException ex) {
        throw new JUnitException("Unable to create scenario temp directory", ex);
      }
      return retval;
    }));

    GenerateSchema generateSchema = scenario.getGenerateSchema();
    if (generateSchema == null) {
      throw new JUnitException(String.format(
          "Scenario '%s' does not have a generate-schema directive", scenario.getName()));
    }
    Metaschema metaschemaDirective = generateSchema.getMetaschema();
    URI metaschemaUri = collectionUri.resolve(metaschemaDirective.getLocation());

    IModule module;
    try {
      IBindingModuleLoader loader = bindingContext.newModuleLoader();

      module = loader.load(ObjectUtils.notNull(metaschemaUri.toURL()));
    } catch (IOException | MetaschemaException ex) {
      throw new JUnitException("Unable to generate classes for metaschema: " + metaschemaUri, ex);
    }

    Lazy<Path> lazySchema = Lazy.of(() -> generateSchema(module, scenarioGenerationPath));

    Lazy<IContentValidator> lazyContentValidator = Lazy.of(() -> {
      Path schemaPath = lazySchema.get();
      return getContentValidatorSupplier().apply(schemaPath);
    });
    assert lazyContentValidator != null;

    // build a test container for the generate and validate steps
    DynamicTest validateSchema = DynamicTest.dynamicTest(
        "Validate Schema",
        () -> {
          Supplier<? extends IContentValidator> supplier = getSchemaValidatorSupplier();
          if (supplier != null) {
            Path schemaPath;
            try {
              schemaPath = ObjectUtils.requireNonNull(lazySchema.get());
            } catch (Exception ex) {
              throw new JUnitException(
                  "failed to generate schema", ex);
            }
            validateWithSchema(ObjectUtils.requireNonNull(supplier.get()), schemaPath);
          }
        });

    List<ValidationCase> validationCases = scenario.getValidationCases();
    Stream<? extends DynamicNode> contentTests = validationCases.stream()
        .flatMap(contentCase -> {
          assert contentCase != null;
          DynamicTest test
              = generateValidationCase(
                  contentCase,
                  bindingContext,
                  lazyContentValidator,
                  collectionUri,
                  ObjectUtils.notNull(scenarioGenerationPath));
          return test == null ? Stream.empty() : Stream.of(test);
        }).sequential();

    return DynamicContainer.dynamicContainer(
        scenario.getName(),
        metaschemaUri,
        Stream.concat(Stream.of(validateSchema), contentTests).sequential());
  }

  /**
   * Perform content conversion.
   *
   * @param resource
   *          the resource to convert
   * @param generationPath
   *          the path to write the converted resource to
   * @param context
   *          the Metaschema binding context
   * @return the location of the converted content
   * @throws IOException
   *           if an error occurred while reading or writing content
   * @see #getRequiredContentFormat()
   */
  protected Path convertContent(
      @NonNull URI resource,
      @NonNull Path generationPath,
      @NonNull IBindingContext context)
      throws IOException {
    Object object;
    try {
      object = context.newBoundLoader().load(ObjectUtils.notNull(resource.toURL()));
    } catch (URISyntaxException ex) {
      throw new IOException(ex);
    }

    if (!Files.exists(generationPath)) {
      Files.createDirectories(generationPath);
    }

    Path convertedContetPath;
    try {
      convertedContetPath = ObjectUtils.notNull(Files.createTempFile(generationPath, "", "-content"));
    } catch (IOException ex) {
      throw new JUnitException(
          String.format("Unable to create converted content path in location '%s'", generationPath),
          ex);
    }

    Format toFormat = getRequiredContentFormat();
    if (LOGGER.isInfoEnabled()) {
      LOGGER.atInfo().log("Converting content '{}' to {} as '{}'", resource, toFormat, convertedContetPath);
    }

    ISerializer<?> serializer
        = context.newSerializer(toFormat, ObjectUtils.asType(object.getClass()));
    serializer.serialize(ObjectUtils.asType(object), convertedContetPath, getWriteOpenOptions());

    return convertedContetPath;
  }

  /**
   * Convert a source format string to the corresponding Format enum value.
   *
   * @param sourceFormat
   *          the source format string (e.g., "XML", "JSON", "YAML")
   * @return the corresponding Format, or null if the format is not recognized
   */
  @Nullable
  private static Format toFormat(@Nullable String sourceFormat) {
    if (sourceFormat == null) {
      return null;
    }
    switch (sourceFormat) {
    case "XML":
      return Format.XML;
    case "JSON":
      return Format.JSON;
    case "YAML":
      return Format.YAML;
    default:
      return null;
    }
  }

  @SuppressWarnings("PMD.AvoidCatchingGenericException")
  private DynamicTest generateValidationCase(
      @NonNull ValidationCase contentCase,
      @NonNull IBindingContext bindingContext,
      @NonNull Lazy<IContentValidator> lazyContentValidator,
      @NonNull URI collectionUri,
      @NonNull Lazy<Path> resourceGenerationPath) {

    URI contentUri = ObjectUtils.notNull(collectionUri.resolve(contentCase.getLocation()));

    Format format = toFormat(contentCase.getSourceFormat());
    boolean expectedValid = isValid(contentCase.getValidationResult());

    DynamicTest retval = null;
    if (getRequiredContentFormat().equals(format)) {
      retval = DynamicTest.dynamicTest(
          String.format("Validate %s=%s: %s", format, expectedValid,
              contentCase.getLocation()),
          contentUri,
          () -> {
            IContentValidator contentValidator;
            try {
              contentValidator = lazyContentValidator.get();
            } catch (Exception ex) {
              throw new JUnitException(
                  "failed to produce the content validator", ex);
            }

            assertEquals(
                expectedValid,
                validateWithSchema(
                    ObjectUtils.notNull(contentValidator), ObjectUtils.notNull(contentUri.toURL())),
                "validation did not match expectation for: " + contentUri.toASCIIString());
          });
    } else if (expectedValid) {
      retval = DynamicTest.dynamicTest(
          String.format("Convert and Validate %s=%s: %s", format, expectedValid,
              contentCase.getLocation()),
          contentUri,
          () -> {
            Path convertedContetPath;
            try {
              convertedContetPath = convertContent(
                  contentUri,
                  ObjectUtils.notNull(resourceGenerationPath.get()),
                  bindingContext);
            } catch (Exception ex) {
              throw new JUnitException("failed to convert content: " + contentUri, ex);
            }

            IContentValidator contentValidator;
            try {
              contentValidator = lazyContentValidator.get();
            } catch (Exception ex) {
              throw new JUnitException( // NOPMD - cause is relevant, exception is not
                  "failed to produce the content validator",
                  ex.getCause());
            }

            if (LOGGER.isInfoEnabled()) {
              LOGGER.atInfo().log("Validating content '{}'", convertedContetPath);
            }
            assertEquals(expectedValid,
                validateWithSchema(
                    ObjectUtils.notNull(contentValidator),
                    ObjectUtils.notNull(convertedContetPath.toUri().toURL())),
                String.format("validation of '%s' did not match expectation", convertedContetPath));
          });
    }
    return retval;
  }

  /**
   * Check if the validation result string indicates a valid result.
   *
   * @param validationResult
   *          the validation result string
   * @return {@code true} if the result indicates valid, {@code false} otherwise
   */
  private static boolean isValid(@Nullable String validationResult) {
    return VALID.equals(validationResult);
  }

  private static boolean validateWithSchema(@NonNull IContentValidator validator, @NonNull URL target)
      throws IOException {
    IValidationResult schemaValidationResult;
    try {
      schemaValidationResult = validator.validate(target);
    } catch (URISyntaxException ex) {
      throw new IOException(ex);
    }
    return processValidationResult(schemaValidationResult);
  }

  /**
   * Use the provided validator to validate the provided target.
   *
   * @param validator
   *          the content validator to use
   * @param target
   *          the resource to validate
   * @return {@code true} if the content is valid or {@code false} otherwise
   * @throws IOException
   *           if an error occurred while reading the content
   */
  protected static boolean validateWithSchema(@NonNull IContentValidator validator, @NonNull Path target)
      throws IOException {
    LOGGER.atError().log("Validating: {}", target);
    IValidationResult schemaValidationResult = validator.validate(target);
    if (!schemaValidationResult.isPassing()) {
      LOGGER.atError().log("Schema validation failed for: {}", target);
    }
    return processValidationResult(schemaValidationResult);
  }

  private static boolean processValidationResult(IValidationResult schemaValidationResult) {
    for (IValidationFinding finding : schemaValidationResult.getFindings()) {
      logFinding(ObjectUtils.notNull(finding));
    }
    return schemaValidationResult.isPassing();
  }

  private static void logFinding(@NonNull IValidationFinding finding) {
    LogBuilder logBuilder;
    switch (finding.getSeverity()) {
    case CRITICAL:
      logBuilder = LOGGER.atFatal();
      break;
    case ERROR:
      logBuilder = LOGGER.atError();
      break;
    case WARNING:
      logBuilder = LOGGER.atWarn();
      break;
    case INFORMATIONAL:
      logBuilder = LOGGER.atInfo();
      break;
    case DEBUG:
      logBuilder = LOGGER.atDebug();
      break;
    default:
      throw new IllegalArgumentException("Unknown level: " + finding.getSeverity().name());
    }

    // if (finding.getCause() != null) {
    // logBuilder.withThrowable(finding.getCause());
    // }

    if (finding instanceof JsonValidationFinding) {
      JsonValidationFinding jsonFinding = (JsonValidationFinding) finding;
      logBuilder.log("[{}] {}", jsonFinding.getCause().getPointerToViolation(), finding.getMessage());
    } else {
      logBuilder.log("{}", finding.getMessage());
    }
  }
}