/*
 * 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.marshall.ini;

import static org.apache.juneau.commons.function.Suppliers.*;
import static org.apache.juneau.commons.utils.Shorts.*;

import java.io.*;
import java.util.*;
import java.util.Map.*;
import java.util.regex.*;

import org.apache.juneau.commons.bean.*;
import org.apache.juneau.commons.function.*;
import org.apache.juneau.commons.reflect.*;
import org.apache.juneau.marshall.*;
import org.apache.juneau.marshall.collections.*;
import org.apache.juneau.marshall.json.*;
import org.apache.juneau.marshall.json5.*;
import org.apache.juneau.marshall.parser.*;
import org.apache.juneau.marshall.stream.*;

/**
 * Session for parsing INI format into POJOs.
 */
@SuppressWarnings({
   "java:S135", // The INI line-reading, populateBean() and buildMapFromSections() loops use several 'continue's to skip blank lines, comments, nested sections and already-handled keys.
   "java:S1192", // Duplicated literals (argument/property names) read more clearly inline than as constants
   "java:S3776", // Branching is inherent to populateBean(), buildMapFromSections() and readValue(), which dispatch over section nesting and target value types.
   "java:S6541", // populateBean() is a single dispatch over bean properties, sub-sections and value types; splitting it would scatter the INI section mapping.
   "resource", // Closeable resources are owned by the caller's parser session; Eclipse JDT @Owning warning is by design.
   "unchecked" // The (T) cast of convertMapToTarget() in doRead() is safe because the target type is the Map type the result was built for.
})
public class IniParserSession extends ReaderParserSession implements RecordReadable {

   /** Delimiter for nested section names (e.g. {@code address/street}). */
   private static final String SECTION_PATH_DELIMITER = "/";

   private final Memoizer<JsonParser> json5Parser = memoizer(
      () -> Json5Parser.create().marshallingContext((MarshallingContext) getContext()).build()
   );

   /**
    * Builder for INI parser session.
    */
   public static class Builder extends ReaderParserSession.Builder<Builder> {

      private final IniParser ctx;

      protected Builder(IniParser ctx) {
         super(reqnn("ctx", ctx));
         this.ctx = ctx;
      }

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

   /**
    * Creates a session builder.
    *
    * @param ctx The parser context.
    *    <br>Cannot be <jk>null</jk>.
    * @return The builder.
    */
   public static Builder create(IniParser ctx) {
      return new Builder(reqnn("ctx", ctx));
   }

   private final IniParser ctx;

   protected IniParserSession(Builder builder) {
      super(builder);
      ctx = builder.ctx;
   }

   @Override /* RecordReadable */
   public RecordReader readRecords(Object input) throws IOException {
      return RecordAdapter.reader(this, input);
   }

   @Override /* RecordReadable */
   public boolean isRecordStreaming() {
      return false;
   }

   @Override
   protected <T> T doRead(ParserPipe pipe, ClassMeta<T> type) throws IOException, ParseException, ExecutableException {
      try (Reader r = pipe.getParserReader()) {
         if (r == null)
            return null;
         var sections = readIniContent(r);
         if (!type.isBean() && !type.isMap())
            throw new ParseException(this, "INI format requires bean or Map<String,?> target. Got: %s", type.inner().getName());
         if (type.isMap()) {
            var result = buildMapFromSections(sections, "");
            return (T) convertMapToTarget(result, type);
         }
         var bm = toBeanMap(type.newInstance(getOuter()));
         populateBean(bm, sections, "");
         return type.cast(checkRequired(bm).getBean());
      }
   }

   /**
    * Parses INI content into section -> (key -> raw value) structure.
    *
    * @param r The reader.
    *    <br>Must not be <jk>null</jk>.
    * @return Map of section name to key-value map. Default section uses "".
    */
   protected Map<String,Map<String,String>> readIniContent(Reader r) throws IOException {
      var sections = new LinkedHashMap<String,Map<String,String>>();
      var current = sections.computeIfAbsent("", k -> m());
      var br = r instanceof BufferedReader r2 ? r2 : new BufferedReader(r);
      String line;
      while ((line = br.readLine()) != null) {
         line = line.trim();
         if (line.isEmpty() || line.startsWith("#"))
            continue;
         if (line.startsWith("[")) {
            var end = line.indexOf(']');
            if (end < 0)
               continue;
            var sectionName = line.substring(1, end).trim();
            current = sections.computeIfAbsent(sectionName, k -> m());
            continue;
         }
         var kv = splitKeyValue(line);
         if (kv != null) {
            var key = kv[0].trim();
            var value = kv[1].trim();
            // Strip inline comment (# ...) from value (when not inside quotes)
            value = stripInlineComment(value);
            current.put(key, value);
         }
      }
      return sections;
   }

   /**
    * Splits an INI {@code key=value} / {@code key:value} (or configured-separator) line into its key and
    * raw-value parts.
    *
    * <p>
    * Behavior mirrors the former {@code ^([^=#\s][^=]*)\s*[=:]\s*(.*)$} regex but without its super-linear
    * backtracking: when this session's {@link IniParser.Builder#kvSeparator(char) kvSeparator} is left at its
    * default (<c>=</c>), an {@code '='} delimiter (if present) binds to the first {@code '='}; otherwise the
    * last {@code ':'} is used (unchanged legacy behavior). When a non-default {@code kvSeparator} has been
    * configured (e.g. to round-trip an {@link IniSerializer} that was configured with a matching
    * {@code kvSeparator}), only that character is recognized as the delimiter. Surrounding whitespace is left
    * in place (callers trim).
    *
    * @param line The (already-trimmed) candidate line.
    * @return A two-element array of {raw-key, raw-value}, or <jk>null</jk> if the line is not a key/value pair.
    */
   @SuppressWarnings({
      "java:S1168" // null is a distinct "not a key/value pair" sentinel; the caller guards on != null before indexing, so an empty array would change parse semantics.
   })
   private String[] splitKeyValue(String line) {
      if (line.isEmpty())
         return null;
      var first = line.charAt(0);
      if (first == '=' || first == '#' || Character.isWhitespace(first))
         return null;
      var sep = ctx.kvSeparator;
      var idx = line.indexOf(sep);
      if (idx < 0 && sep == '=')
         idx = line.lastIndexOf(':');
      if (idx < 1)
         return null;
      return new String[] { line.substring(0, idx), line.substring(idx + 1) };
   }

   private void populateBean(BeanMap<?> bm, Map<String,Map<String,String>> sections, String sectionPath) throws ParseException, ExecutableException {
      var defaultSection = sections.get(sectionPath);
      if (defaultSection != null) {
         for (Entry<String,String> e : defaultSection.entrySet()) {
            var key = e.getKey();
            var rawValue = e.getValue();
            var pMeta = bm.getMeta().getProperties().get(key);
            if (pMeta == null && isIgnoreUnknownBeanProperties())
               continue;
            if (pMeta == null)
               throw new ParseException(this, "Unknown property '%s'", key);
            var value = readValue(rawValue, (ClassMeta<?>) pMeta.getBeanInfo());
            bm.put(key, value);
         }
      }
      // Process nested sections
      for (var entry : sections.entrySet()) {
         var sectionName = entry.getKey();
         var sub = entry.getValue();
         if (sectionName.equals(sectionPath))
            continue;
         var isChild = sectionPath.isEmpty() ? !sectionName.contains(SECTION_PATH_DELIMITER)
            : sectionName.startsWith(sectionPath + SECTION_PATH_DELIMITER);
         if (!isChild)
            continue;
         var childName = sectionPath.isEmpty() ? sectionName
            : sectionName.substring(sectionPath.length() + SECTION_PATH_DELIMITER.length()).split(Pattern.quote(SECTION_PATH_DELIMITER))[0];
         var pMeta = bm.getMeta().getProperties().get(childName);
         if (pMeta == null && isIgnoreUnknownBeanProperties())
            continue;
         if (pMeta == null)
            continue;
         var cMeta = (ClassMeta<?>) pMeta.getBeanInfo();
         var childPath = sectionPath.isEmpty() ? childName : sectionPath + SECTION_PATH_DELIMITER + childName;
         if (cMeta.isBean()) {
            var child = toBeanMap(cMeta.newInstance(getOuter()));
            populateBean(child, sections, childPath);
            bm.put(childName, checkRequired(child).getBean());
         } else if (cMeta.isMap() && sub != null) {
            var valueType = cMeta.getValueType();
            if (valueType == null)
               valueType = object();
            var map = new LinkedHashMap<String,Object>();
            for (Entry<String,String> e : sub.entrySet())
               map.put(e.getKey(), readValue(e.getValue(), valueType));
            bm.put(childName, convertMapToTarget(map, cMeta));
         } else if (cMeta.isMap()) {
            // sub == null: no literal header line for this section, only reachable via nested paths.
         } else {
            // The section header matched a real (known) bean property, but its declared type is neither
            // a bean nor a map shape that a section's key/value content can be poured into (e.g. a plain
            // scalar). Unlike an unmatched section name (see above), this is a genuine type mismatch on a
            // property we DO know about, so surface it instead of silently dropping the section's data.
            throw new ParseException(this, "Cannot populate property '%s' of type '%s' from INI section '%s'; expected a bean or map type.", childName, cMeta, sectionName);
         }
      }
   }

   private Map<String,Object> buildMapFromSections(Map<String,Map<String,String>> sections, String sectionPath) throws ParseException, ExecutableException {
      var result = new LinkedHashMap<String,Object>();
      var defaultSection = sections.get(sectionPath);
      if (defaultSection != null) {
         for (Entry<String,String> e : defaultSection.entrySet())
            result.put(e.getKey(), readValue(e.getValue(), object()));
      }
      for (var entry : sections.entrySet()) {
         var sectionName = entry.getKey();
         var childSection = entry.getValue();
         if (sectionName.equals(sectionPath))
            continue;
         // Every non-root section is nested under "" by definition, so at the root level a
         // grandchild-only section (e.g. "employment/company" with no literal "[employment]" header)
         // must still be recognized as belonging to the "employment" subtree -- restricting root-level
         // children to sections with no delimiter at all silently dropped that whole subtree.
         var isChild = sectionPath.isEmpty() || sectionName.startsWith(sectionPath + SECTION_PATH_DELIMITER);
         if (!isChild)
            continue;
         var childName = sectionPath.isEmpty() ? sectionName.split(Pattern.quote(SECTION_PATH_DELIMITER))[0]
            : sectionName.substring(sectionPath.length() + SECTION_PATH_DELIMITER.length()).split(Pattern.quote(SECTION_PATH_DELIMITER))[0];
         if (result.containsKey(childName))
            continue;
         var childPath = sectionPath.isEmpty() ? childName : sectionPath + SECTION_PATH_DELIMITER + childName;
         var hasNested = sections.keySet().stream().anyMatch(s -> s.startsWith(childPath + SECTION_PATH_DELIMITER));
         if (hasNested) {
            result.put(childName, buildMapFromSections(sections, childPath));
         } else if (childSection != null) {
            var map = new LinkedHashMap<String,Object>();
            for (Entry<String,String> e : childSection.entrySet())
               map.put(e.getKey(), readValue(e.getValue(), object()));
            result.put(childName, map);
         }
      }
      return result;
   }

   private Object readValue(String raw, ClassMeta<?> targetType) throws ParseException, ExecutableException {
      if (raw == null)
         return null;
      var trimmed = raw.trim();
      if (eq(trimmed, "null"))
         return null;
      if (eqic(trimmed, "true"))
         return true;
      if (eqic(trimmed, "false"))
         return false;
      if (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length() >= 2) {
         var inner = trimmed.substring(1, trimmed.length() - 1).replace("''", "'");
         return convertToMemberType(null, inner, targetType);
      }
      if (trimmed.startsWith("[") || trimmed.startsWith("{"))
         return getJson5Parser().read(trimmed, targetType);
      if (targetType.isNumber()) {
         try {
            if (trimmed.contains(".") || trimmed.toLowerCase(Locale.ROOT).contains("e"))
               return Double.parseDouble(trimmed);
            return Long.parseLong(trimmed);
         } catch (@SuppressWarnings("unused") NumberFormatException e) {
            return convertToMemberType(null, trimmed, targetType);
         }
      }
      if (targetType.isDate())
         return readDate(trimmed, targetType);
      if (targetType.isCalendar())
         return readCalendar(trimmed, targetType);
      if (targetType.isTemporal())
         return readTemporal(trimmed, targetType);
      if (targetType.isDuration())
         return readDuration(trimmed);
      if (targetType.isPeriod())
         return readPeriod(trimmed);
      return convertToMemberType(null, trimmed, targetType);
   }

   /**
    * Returns a Json5 parser configured with this session's {@link MarshallingContext}.
    *
    * <p>
    * Required so that format hints carried on the parent {@code IniParser} context (e.g.
    * {@link LocaleFormat}, {@link TimeZoneFormat}) are honored
    * when nested JSON5-encoded collection/map values are deserialized.  Using {@code Json5Parser.DEFAULT}
    * here would silently drop those hints and fall back to the format-default behavior.
    *
    * <p>
    * Memoized via {@link Memoizer} — first call constructs the parser; subsequent calls return
    * the cached instance.  {@link #readValue} calls this once per JSON5-encoded value, so a single
    * builder-construction + parser-instantiation is amortized across the whole INI document rather
    * than repeated for every {@code […]} / {@code {…}} value.
    *
    * <p>
    * List-of-{@link Locale} values written under {@link LocaleFormat#UNDERSCORE}
    * (wire form {@code "en_US"}) were being parsed via {@code Locale.forLanguageTag("en_US")} (BCP_47 default)
    * which returns {@link Locale#ROOT}, dropping the locale content.
    */
   private JsonParser getJson5Parser() {
      return json5Parser.get();
   }

   private static Object convertMapToTarget(Map<String,Object> map, ClassMeta<?> type) throws ParseException, ExecutableException {
      if (JsonMap.class.isAssignableFrom(type.inner()))
         return new JsonMap(map);
      return map;
   }

   private static String stripInlineComment(String value) {
      if (value == null || !value.contains("#"))
         return value;
      var inQuote = false;
      for (var i = 0; i < value.length(); i++) {
         var c = value.charAt(i);
         if (c == '\'')
            inQuote = !inQuote;
         else if (c == '#' && !inQuote)
            return value.substring(0, i).trim();
      }
      return value;
   }
}