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

package gov.nist.secauto.metaschema.schemagen.json;

import com.fasterxml.jackson.databind.node.ObjectNode;

import gov.nist.secauto.metaschema.core.model.IDefinition;
import gov.nist.secauto.metaschema.core.util.ObjectUtils;
import gov.nist.secauto.metaschema.schemagen.SchemaGenerationException;
import gov.nist.secauto.metaschema.schemagen.json.impl.AbstractDefinitionJsonSchema.SimpleKey;
import gov.nist.secauto.metaschema.schemagen.json.impl.AbstractModelDefinitionJsonSchema.ComplexKey;

import java.util.Comparator;

import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;

/**
 * Represents a JSON schema that is a global definition or an inline schema.
 * <p>
 * A schema of this type will be a global definition if
 * {@link #isInline(IJsonGenerationState)} is {@code false}.
 */
public interface IDefineableJsonSchema {

  /**
   * Determine if the schema is defined inline or as a global definition.
   *
   * @param state
   *          the schema generation state used for context
   * @return {@code true} if the schema is to be defined inline or {@code false}
   *         if the schema is to be defined globally
   */
  boolean isInline(@NonNull IJsonGenerationState state);

  default void generateSchemaOrRef(
      @NonNull ObjectNode obj,
      @NonNull IJsonGenerationState state) {
    if (isInline(state)) {
      generateInlineSchema(obj, state);
    } else {
      generateRef(obj, state);
    }
  }

  /**
   * Generate the schema within the provided JSON object node.
   *
   * @param obj
   *          the JSON object to populate
   * @param state
   *          the schema generation state used for context and writing
   * @throws SchemaGenerationException
   *           if an error occurred while writing the type
   */
  void generateInlineSchema(
      @NonNull ObjectNode obj,
      @NonNull IJsonGenerationState state);

  /**
   * Get the definition's name.
   *
   * @param state
   *          the schema generation state used for context and writing
   * @return the definition name
   * @throws IllegalStateException
   *           if the JSON schema object is not a definition
   */
  @NonNull
  String getDefinitionName(@NonNull IJsonGenerationState state);

  /**
   * Get the definition's reference URI.
   *
   * @param state
   *          the schema generation state used for context and writing
   * @return the definition's reference URI
   * @throws IllegalStateException
   *           if the JSON schema object is not a definition
   */
  default String getDefinitionRef(@NonNull IJsonGenerationState state) {
    return ObjectUtils.notNull(new StringBuilder()
        .append("#/definitions/")
        .append(getDefinitionName(state))
        .toString());
  }

  /**
   * Generate a reference to a globally defined schema, within the provided JSON
   * object node.
   *
   * @param obj
   *          the JSON object to populate
   * @param state
   *          the schema generation state used for context and writing
   * @throws SchemaGenerationException
   *           if an error occurred while writing the type
   */
  default void generateRef(
      @NonNull ObjectNode obj,
      @NonNull IJsonGenerationState state) {
    obj.put("$ref", getDefinitionRef(state));
  }

  // /**
  // * Determine if the JSON schema object is a JSON definition.
  // *
  // * @param state
  // * the schema generation state used for context and writing
  // * @return {@code true} if the SON schema object is a definition or
  // * {@code false} otherwise
  // */
  // default boolean isDefinition(@NonNull IJsonGenerationState state) {
  // return !isInline(state);
  // }

  // REFACTOR: move to abstract implementation?
  default void generateDefinition(@NonNull IJsonGenerationState state, @NonNull ObjectNode definitionsObject) {

    // create the definition property
    ObjectNode definitionObj = ObjectUtils.notNull(
        definitionsObject.putObject(getDefinitionName(state)));

    // Add identifier, see usnistgov/metaschema#160
    definitionObj.put("$id", getDefinitionRef(state));

    // generate the definition object contents
    generateInlineSchema(definitionObj, state);
  }

  interface IKey extends Comparable<IKey> {
    Comparator<IKey> KEY_COMPARATOR = Comparator
        .<IKey, String>comparing(key -> key.getDefinition().getContainingModule().getShortName())
        .thenComparing(key -> key.getDefinition().getEffectiveName())
        .thenComparing(IKey::getJsonKeyFlagName, Comparator.nullsFirst(Comparator.naturalOrder()))
        .thenComparing(IKey::getDiscriminatorProperty, Comparator.nullsFirst(Comparator.naturalOrder()))
        .thenComparing(IKey::getDiscriminatorValue, Comparator.nullsFirst(Comparator.naturalOrder()));

    @NonNull
    static IKey of(@NonNull IDefinition definition) {
      return new SimpleKey(definition);
    }

    @NonNull
    static IKey of(
        @NonNull IDefinition definition,
        @Nullable String jsonKeyFlagName,
        @Nullable String discriminatorProperty,
        @Nullable String discriminatorValue) {
      IKey retval;
      if (jsonKeyFlagName != null || discriminatorProperty != null || discriminatorValue != null) {
        retval = new ComplexKey(definition, jsonKeyFlagName, discriminatorProperty, discriminatorValue);
      } else {
        retval = of(definition);
      }
      return retval;
    }

    @NonNull
    IDefinition getDefinition();

    @Nullable
    String getJsonKeyFlagName();

    @Nullable
    String getDiscriminatorProperty();

    @Nullable
    String getDiscriminatorValue();

    @Override
    default int compareTo(IKey other) {
      return KEY_COMPARATOR.compare(this, other);
    }
  }
}