/*
 * 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.juneau.jsonschema;

import static org.apache.juneau.commons.utils.AssertionUtils.*;
import static org.apache.juneau.commons.utils.CollectionUtils.*;
import static org.apache.juneau.commons.utils.Utils.*;
import static org.apache.juneau.jsonschema.TypeCategory.*;

import java.lang.reflect.*;
import java.util.*;
import java.util.function.*;
import java.util.regex.*;

import org.apache.juneau.*;
import org.apache.juneau.annotation.*;
import org.apache.juneau.collections.*;
import org.apache.juneau.commons.utils.*;
import org.apache.juneau.json.*;
import org.apache.juneau.parser.*;
import org.apache.juneau.serializer.*;

/**
 * Session object that lives for the duration of a single use of {@link JsonSchemaSerializer}.
 *
 * <h5 class='section'>Notes:</h5><ul>
 *    <li class='warn'>This class is not thread safe and is typically discarded after one use.
 * </ul>
 *
 * <h5 class='section'>See Also:</h5><ul>
 *    <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/JsonSchemaDetails">JSON-Schema Support</a>
 * </ul>
 */
public class JsonSchemaGeneratorSession extends BeanTraverseSession {
   /**
    * Builder class.
    */
   public static class Builder extends BeanTraverseSession.Builder {

      private JsonSchemaGenerator ctx;

      /**
       * Constructor
       *
       * @param ctx The context creating this session.
       *    <br>Cannot be <jk>null</jk>.
       */
      protected Builder(JsonSchemaGenerator ctx) {
         super(assertArgNotNull("ctx", ctx));
         this.ctx = ctx;
      }

      @Override /* Overridden from Builder */
      public <T> Builder apply(Class<T> type, Consumer<T> apply) {
         super.apply(type, apply);
         return this;
      }

      @Override
      public JsonSchemaGeneratorSession build() {
         return new JsonSchemaGeneratorSession(this);
      }

      @Override /* Overridden from Builder */
      public Builder debug(Boolean value) {
         super.debug(value);
         return this;
      }

      @Override /* Overridden from Builder */
      public Builder locale(Locale value) {
         super.locale(value);
         return this;
      }

      @Override /* Overridden from Builder */
      public Builder mediaType(MediaType value) {
         super.mediaType(value);
         return this;
      }

      @Override /* Overridden from Builder */
      public Builder mediaTypeDefault(MediaType value) {
         super.mediaTypeDefault(value);
         return this;
      }

      @Override /* Overridden from Builder */
      public Builder properties(Map<String,Object> value) {
         super.properties(value);
         return this;
      }

      @Override /* Overridden from Builder */
      public Builder property(String key, Object value) {
         super.property(key, value);
         return this;
      }

      @Override /* Overridden from Builder */
      public Builder timeZone(TimeZone value) {
         super.timeZone(value);
         return this;
      }

      @Override /* Overridden from Builder */
      public Builder timeZoneDefault(TimeZone value) {
         super.timeZoneDefault(value);
         return this;
      }

      @Override /* Overridden from Builder */
      public Builder unmodifiable() {
         super.unmodifiable();
         return this;
      }
   }

   /**
    * Creates a new builder for this object.
    *
    * @param ctx The context creating this session.
    *    <br>Cannot be <jk>null</jk>.
    * @return A new builder.
    */
   public static Builder create(JsonSchemaGenerator ctx) {
      return new Builder(assertArgNotNull("ctx", ctx));
   }

   private final JsonSchemaGenerator ctx;
   private final Map<String,JsonMap> defs;
   private JsonParserSession jpSession;
   private JsonSerializerSession jsSession;

   /**
    * Constructor.
    *
    * @param builder The builder for this object.
    */
   protected JsonSchemaGeneratorSession(Builder builder) {
      super(builder);
      ctx = builder.ctx;
      defs = isUseBeanDefs() ? new TreeMap<>() : null;
   }

   /**
    * Adds a schema definition to this session.
    *
    * @param id The definition ID.
    *    <br>Cannot be <jk>null</jk>.
    * @param def The definition schema.
    *    <br>Cannot be <jk>null</jk>.
    * @return This object.
    */
   public JsonSchemaGeneratorSession addBeanDef(String id, JsonMap def) {
      if (nn(defs))
         defs.put(assertArgNotNull("id", id), assertArgNotNull("def", def));
      return this;
   }

   /**
    * Returns the definition ID for the specified class.
    *
    * @param cm The class to get the definition ID of.
    * @return The definition ID for the specified class.
    */
   public String getBeanDefId(ClassMeta<?> cm) {
      return getBeanDefMapper().getId(cm);
   }

   /**
    * Returns the definitions that were gathered during this session.
    *
    * <p>
    * This map is modifiable and affects the map in the session.
    *
    * @return
    *    The definitions that were gathered during this session, or <jk>null</jk> if {@link JsonSchemaGenerator.Builder#useBeanDefs()} was not enabled.
    */
   public Map<String,JsonMap> getBeanDefs() { return defs; }

   /**
    * Returns the definition URI for the specified class.
    *
    * @param cm The class to get the definition URI of.
    * @return The definition URI for the specified class.
    */
   public java.net.URI getBeanDefUri(ClassMeta<?> cm) {
      return getBeanDefMapper().getURI(cm);
   }

   /**
    * Returns the definition URI for the specified class.
    *
    * @param id The definition ID to get the definition URI of.
    * @return The definition URI for the specified class.
    */
   public java.net.URI getBeanDefUri(String id) {
      return getBeanDefMapper().getURI(id);
   }

   /**
    * Returns the language-specific metadata on the specified bean property.
    *
    * @param bpm The bean property to return the metadata on.
    * @return The metadata.
    */
   public JsonSchemaBeanPropertyMeta getJsonSchemaBeanPropertyMeta(BeanPropertyMeta bpm) {
      return ctx.getJsonSchemaBeanPropertyMeta(bpm);
   }

   /**
    * Returns the language-specific metadata on the specified class.
    *
    * @param cm The class to return the metadata on.
    * @return The metadata.
    */
   public JsonSchemaClassMeta getJsonSchemaClassMeta(ClassMeta<?> cm) {
      return ctx.getJsonSchemaClassMeta(cm);
   }

   /**
    * Returns the JSON-schema for the specified type.
    *
    * @param cm The object type.
    * @return The schema for the type.
    * @throws BeanRecursionException Bean recursion occurred.
    * @throws SerializeException Error occurred.
    */
   public JsonMap getSchema(ClassMeta<?> cm) throws BeanRecursionException, SerializeException {
      return getSchema(cm, "root", null, false, false, null);
   }

   /**
    * Returns the JSON-schema for the specified object.
    *
    * @param o
    *    The object.
    *    <br>Can either be a POJO or a <c>Class</c>/<c>Type</c>.
    * @return The schema for the type.
    * @throws BeanRecursionException Bean recursion occurred.
    * @throws SerializeException Error occurred.
    */
   public JsonMap getSchema(Object o) throws BeanRecursionException, SerializeException {
      return getSchema(toClassMeta(o), "root", null, false, false, null);
   }

   /**
    * Returns the JSON-schema for the specified type.
    *
    * @param type The object type.
    * @return The schema for the type.
    * @throws BeanRecursionException Bean recursion occurred.
    * @throws SerializeException Error occurred.
    */
   public JsonMap getSchema(Type type) throws BeanRecursionException, SerializeException {
      return getSchema(getClassMeta(type), "root", null, false, false, null);
   }

   private Object getDescription(ClassMeta<?> sType, TypeCategory t, boolean descriptionAdded) {
      var canAdd = isAllowNestedDescriptions() || ! descriptionAdded;
      if (canAdd && (getAddDescriptionsTo().contains(t) || getAddDescriptionsTo().contains(ANY)))
         return sType.toString();
      return null;
   }

   @SuppressWarnings("unchecked")
   private static List<String> getEnums(ClassMeta<?> cm) {
      List<String> l = list();
      for (var e : ((Class<Enum<?>>)cm.inner()).getEnumConstants())
         l.add(cm.toString(e));
      return l;
   }

   private Object getExample(ClassMeta<?> sType, TypeCategory t, boolean exampleAdded) throws SerializeException {
      var canAdd = isAllowNestedExamples() || ! exampleAdded;
      if (canAdd && (getAddExamplesTo().contains(t) || getAddExamplesTo().contains(ANY))) {
         var example = sType.getExample(this, jpSession());
         if (nn(example)) {
            try {
               return JsonParser.DEFAULT.parse(toJson(example), Object.class);
            } catch (ParseException e) {
               throw new SerializeException(e);
            }
         }
      }
      return null;
   }

   @SuppressWarnings({ "unchecked", "rawtypes" })
   private JsonMap getSchema(ClassMeta<?> eType, String attrName, List<String> pNames, boolean exampleAdded, boolean descriptionAdded, JsonSchemaBeanPropertyMeta jsbpm)
      throws BeanRecursionException, SerializeException {

      if (ctx.isIgnoredType(eType))
         return null;

      var out = new JsonMap();

      if (eType == null)
         eType = object();

      var aType = (ClassMeta<?>)null;        // The actual type (will be null if recursion occurs)
      var sType = (ClassMeta<?>)null;        // The serialized type
      var objectSwap = eType.getSwap(this);

      aType = push(attrName, eType, null);

      sType = eType.getSerializedClassMeta(this);

      var type = (String)null;
      var format = (String)null;
      var example = (Object)null;
      var description = (Object)null;

      boolean useDef = isUseBeanDefs() && sType.isBean() && pNames == null;

      if (useDef) {
         exampleAdded = false;
         descriptionAdded = false;
      }

      if (useDef && defs.containsKey(getBeanDefId(sType))) {
         pop();
         return new JsonMap().append("$ref", getBeanDefUri(sType));
      }

      var jscm = (JsonSchemaClassMeta)null;
      var objectSwapCM = objectSwap == null ? null : getClassMeta(objectSwap.getClass());
      if (nn(objectSwapCM) && getAnnotationProvider().has(Schema.class, objectSwapCM))
         jscm = getJsonSchemaClassMeta(objectSwapCM);
      if (jscm == null)
         jscm = getJsonSchemaClassMeta(sType);

      var tc = (TypeCategory)null;

      if (sType.isNumber()) {
         tc = NUMBER;
         if (sType.isDecimal()) {
            type = "number";
            if (sType.isFloat()) {
               format = "float";
            } else if (sType.isDouble()) {
               format = "double";
            }
         } else {
            type = "integer";
            if (sType.isShort()) {
               format = "int16";
            } else if (sType.isInteger()) {
               format = "int32";
            } else if (sType.isLong()) {
               format = "int64";
            }
         }
      } else if (sType.isBoolean()) {
         tc = BOOLEAN;
         type = "boolean";
      } else if (sType.isMap()) {
         tc = MAP;
         type = "object";
      } else if (sType.isBean()) {
         tc = BEAN;
         type = "object";
      } else if (sType.isCollection()) {
         tc = COLLECTION;
         type = "array";
      } else if (sType.isArray()) {
         tc = ARRAY;
         type = "array";
      } else if (sType.isEnum()) {
         tc = ENUM;
         type = "string";
      } else if (sType.isCharSequence() || sType.isChar()) {
         tc = STRING;
         type = "string";
      } else if (sType.isUri()) {
         tc = STRING;
         type = "string";
         format = "uri";
      } else {
         tc = STRING;
         type = "string";
      }

      // Add info from @Schema on bean property.
      if (nn(jsbpm)) {
         out.append(jsbpm.getSchema());
      }

      out.append(jscm.getSchema());

      Predicate<String> ne = Utils::ne;
      out.appendIfAbsentIf(ne, "type", type);
      out.appendIfAbsentIf(ne, "format", format);

      if (nn(aType)) {

         example = getExample(sType, tc, exampleAdded);
         description = getDescription(sType, tc, descriptionAdded);
         exampleAdded |= nn(example);
         descriptionAdded |= nn(description);

         if (tc == BEAN) {
            var properties = new JsonMap();
            BeanMeta bm = getBeanMeta(sType.inner());
            if (nn(pNames))
               bm = new BeanMetaFiltered(bm, pNames);
            for (Iterator<BeanPropertyMeta> i = bm.getProperties().values().iterator(); i.hasNext();) {
               BeanPropertyMeta p = i.next();
               if (p.canRead()) {
                  var pProps = p.getProperties();
                  properties.put(p.getName(), getSchema(p.getClassMeta(), p.getName(), pProps, exampleAdded, descriptionAdded, getJsonSchemaBeanPropertyMeta(p)));
               }
            }
            out.put("properties", properties);

         } else if (tc == COLLECTION) {
            ClassMeta et = sType.getElementType();
            if (sType.isCollection() && sType.isChildOf(Set.class))
               out.put("uniqueItems", true);
            out.put("items", getSchema(et, "items", pNames, exampleAdded, descriptionAdded, null));

         } else if (tc == ARRAY) {
            ClassMeta et = sType.getElementType();
            if (sType.isCollection() && sType.isChildOf(Set.class))
               out.put("uniqueItems", true);
            out.put("items", getSchema(et, "items", pNames, exampleAdded, descriptionAdded, null));

         } else if (tc == ENUM) {
            out.put("enum", getEnums(sType));

         } else if (tc == MAP) {
            var om = getSchema(sType.getValueType(), "additionalProperties", null, exampleAdded, descriptionAdded, null);
            if (! om.isEmpty())
               out.put("additionalProperties", om);

         }
      }

      out.append(jscm.getSchema());

      Predicate<Object> neo = Utils::ne;
      out.appendIfAbsentIf(neo, "description", description);
      out.appendIfAbsentIf(neo, "example", example);

      if (useDef) {
         defs.put(getBeanDefId(sType), out);
         out = JsonMap.of("$ref", getBeanDefUri(sType));
      }

      pop();

      return out;
   }

   private JsonParserSession jpSession() {
      if (jpSession == null)
         jpSession = ctx.getJsonParser().getSession();
      return jpSession;
   }

   private ClassMeta<?> toClassMeta(Object o) {
      if (o instanceof Type o2)
         return getClassMeta(o2);
      return getClassMetaForObject(o);
   }

   private String toJson(Object o) throws SerializeException {
      if (jsSession == null)
         jsSession = ctx.getJsonSerializer().getSession();
      return jsSession.serializeToString(o);
   }

   /**
    * Add descriptions to types.
    *
    * @see JsonSchemaGenerator.Builder#addDescriptionsTo(TypeCategory...)
    * @return
    *    Set of categories of types that descriptions should be automatically added to generated schemas.
    */
   protected final Set<TypeCategory> getAddDescriptionsTo() { return ctx.getAddDescriptionsTo(); }

   /**
    * Add examples.
    *
    * @see JsonSchemaGenerator.Builder#addExamplesTo(TypeCategory...)
    * @return
    *    Set of categories of types that examples should be automatically added to generated schemas.
    */
   protected final Set<TypeCategory> getAddExamplesTo() { return ctx.getAddExamplesTo(); }

   /**
    * Bean schema definition mapper.
    *
    * @see JsonSchemaGenerator.Builder#beanDefMapper(Class)
    * @return
    *    Interface to use for converting Bean classes to definition IDs and URIs.
    */
   protected final BeanDefMapper getBeanDefMapper() { return ctx.getBeanDefMapper(); }

   /**
    * Ignore types from schema definitions.
    *
    * @see JsonSchemaGenerator.Builder#ignoreTypes(String...)
    * @return
    *    Custom schema information for particular class types.
    */
   protected final List<Pattern> getIgnoreTypes() { return ctx.getIgnoreTypes(); }

   /**
    * Allow nested descriptions.
    *
    * @see JsonSchemaGenerator.Builder#allowNestedDescriptions()
    * @return
    *    <jk>true</jk> if nested descriptions are allowed in schema definitions.
    */
   protected final boolean isAllowNestedDescriptions() { return ctx.isAllowNestedDescriptions(); }

   /**
    * Allow nested examples.
    *
    * @see JsonSchemaGenerator.Builder#allowNestedExamples()
    * @return
    *    <jk>true</jk> if nested examples are allowed in schema definitions.
    */
   protected final boolean isAllowNestedExamples() { return ctx.isAllowNestedExamples(); }

   /**
    * Use bean definitions.
    *
    * @see JsonSchemaGenerator.Builder#useBeanDefs()
    * @return
    *    <jk>true</jk> if schemas on beans will be serialized with <js>'$ref'</js> tags.
    */
   protected final boolean isUseBeanDefs() { return ctx.isUseBeanDefs(); }
}