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

import static org.apache.juneau.commons.utils.IoUtils.*;
import static org.apache.juneau.commons.utils.StringUtils.*;
import static org.apache.juneau.commons.utils.ThrowableUtils.*;
import static org.apache.juneau.commons.utils.Utils.*;

import java.io.*;
import java.nio.charset.*;

import org.apache.juneau.*;
import org.apache.juneau.commons.utils.*;

/**
 * A wrapper around an object that a parser reads its input from.
 *
 * <p>
 * For character-based parsers, the input object can be any of the following:
 * <ul>
 *    <li>{@link Reader}
 *    <li>{@link CharSequence}
 *    <li>{@link InputStream}
 *    <li><code><jk>byte</jk>[]</code>
 *    <li>{@link File}
 *    <li><code><jk>null</jk></code>
 * </ul>
 *
 * <p>
 * For stream-based parsers, the input object can be any of the following:
 * <ul>
 *    <li>{@link InputStream}
 *    <li><code><jk>byte</jk>[]</code>
 *    <li>{@link File}
 *    <li>{@link String} - Hex-encoded bytes.  (not BASE-64!)
 *    <li><code><jk>null</jk></code>
 * </ul>
 *
 * <p>
 * Note that Readers and InputStreams will NOT be automatically closed when {@link #close()} is called, but
 * streams and readers created from other types (e.g. Files) WILL be automatically closed.
 *
 * <h5 class='section'>See Also:</h5><ul>
 *    <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/SerializersAndParsers">Serializers and Parsers</a>
 * </ul>
 */
@SuppressWarnings("resource")
public class ParserPipe implements Closeable {

   private final Object input;
   final boolean debug, strict, autoCloseStreams, unbuffered;
   private final Charset charset;

   private String inputString;
   private InputStream inputStream;
   private Reader reader;
   private ParserReader parserReader;
   private boolean doClose;
   private BinaryFormat binaryFormat;
   private Positionable positionable;

   /**
    * Shortcut constructor, typically for straight string input.
    *
    * <p>
    * Equivalent to calling <code><jk>new</jk> ParserPipe(input, <jk>false</jk>, <jk>false</jk>, <jk>null</jk>, <jk>null</jk>);</code>
    *
    * @param input The input object.
    */
   public ParserPipe(Object input) {
      this(input, false, false, false, false, null, null);
   }

   /**
    * Constructor for stream-based parsers.
    *
    * @param input The parser input object.
    * @param debug
    *    If <jk>true</jk>, the input contents will be copied locally and accessible via the {@link #getInputAsString()}
    *    method.
    *    This allows the contents of the pipe to be accessed when a problem occurs.
    * @param autoCloseStreams
    *    Automatically close {@link InputStream InputStreams} and {@link Reader Readers} when passed in as input.
    * @param unbuffered
    *    If <jk>true</jk>, we read one character at a time from underlying readers when the readers are expected to be parsed
    *    multiple times.
    *    <br>Otherwise, we read character data into a reusable buffer.
    * @param binaryFormat The binary format of input strings when converted to bytes.
    */
   public ParserPipe(Object input, boolean debug, boolean autoCloseStreams, boolean unbuffered, BinaryFormat binaryFormat) {
      this.input = input;
      this.debug = debug;
      this.strict = false;
      this.autoCloseStreams = autoCloseStreams;
      this.unbuffered = unbuffered;
      this.charset = null;
      if (input instanceof CharSequence input2)
         this.inputString = input2.toString();
      this.binaryFormat = binaryFormat;
   }

   /**
    * Constructor for reader-based parsers.
    *
    * @param input The parser input object.
    * @param debug
    *    If <jk>true</jk>, the input contents will be copied locally and accessible via the {@link #getInputAsString()}
    *    method.
    *    This allows the contents of the pipe to be accessed when a problem occurs.
    * @param strict
    *    If <jk>true</jk>, sets {@link CodingErrorAction#REPORT} on {@link CharsetDecoder#onMalformedInput(CodingErrorAction)}
    *    and {@link CharsetDecoder#onUnmappableCharacter(CodingErrorAction)}.
    *    Otherwise, sets them to {@link CodingErrorAction#REPLACE}.
    * @param autoCloseStreams
    *    Automatically close {@link InputStream InputStreams} and {@link Reader Readers} when passed in as input.
    * @param unbuffered
    *    If <jk>true</jk>, we read one character at a time from underlying readers when the readers are expected to be parsed
    *    multiple times.
    *    <br>Otherwise, we read character data into a reusable buffer.
    * @param fileCharset
    *    The charset to expect when reading from {@link File Files}.
    * @param streamCharset
    *    The charset to expect when reading from {@link InputStream InputStreams}.
    */
   public ParserPipe(Object input, boolean debug, boolean strict, boolean autoCloseStreams, boolean unbuffered, Charset streamCharset, Charset fileCharset) {
      boolean isFile = input instanceof File;
      this.input = input;
      this.debug = debug;
      this.strict = strict;
      this.autoCloseStreams = autoCloseStreams;
      this.unbuffered = unbuffered;
      Charset cs = isFile ? fileCharset : streamCharset;
      if (cs == null)
         cs = (isFile ? Charset.defaultCharset() : UTF8);
      this.charset = cs;
      if (input instanceof CharSequence cs2)
         this.inputString = cs2.toString();
      this.binaryFormat = null;
   }

   /**
    * Returns the contents of this pipe as a string.
    *
    * @return The contents of this pipe as a string.
    * @throws IOException If thrown from inner reader.
    */
   public String asString() throws IOException {
      if (inputString == null)
         inputString = read(getReader());
      return inputString;
   }

   @Override /* Overridden from Closeable */
   public void close() {
      try {
         if (doClose)
            IoUtils.close(reader, inputStream);
      } catch (IOException e) {
         throw bex(e);
      }
   }

   /**
    * Returns the contents of this pipe as a buffered reader.
    *
    * <p>
    * If the reader passed into this pipe is already a buffered reader, that reader will be returned.
    *
    * @return The contents of this pipe as a buffered reader.
    * @throws IOException Thrown by underlying stream.
    */
   public Reader getBufferedReader() throws IOException { return toBufferedReader(getReader()); }

   /**
    * Returns the input to this parser as a plain string.
    *
    * <p>
    * This method only returns a value if {@link org.apache.juneau.Context.Builder#debug()} is enabled.
    *
    * @return The input as a string, or <jk>null</jk> if debug mode not enabled.
    */
   public String getInputAsString() { return inputString; }

   /**
    * Wraps the specified input object inside an input stream.
    *
    * <p>
    * Subclasses can override this method to implement their own input streams.
    *
    * @return The input object wrapped in an input stream, or <jk>null</jk> if the object is null.
    * @throws IOException If object could not be converted to an input stream.
    */
   public InputStream getInputStream() throws IOException {
      if (input == null)
         return null;

      if (input instanceof InputStream input2) {
         if (debug) {
            var b = readBytes(input2);
            inputString = toHex(b);
            inputStream = new ByteArrayInputStream(b);
         } else {
            inputStream = input2;
            doClose = autoCloseStreams;
         }
      } else if (input instanceof byte[]) {
         if (debug)
            inputString = toHex((byte[])input);
         inputStream = new ByteArrayInputStream((byte[])input);
         doClose = false;
      } else if (input instanceof String input2) {
         inputString = input2;
         inputStream = new ByteArrayInputStream(convertFromString(input2));
         doClose = false;
      } else if (input instanceof File input2) {
         if (debug) {
            var b = readBytes(input2);
            inputString = toHex(b);
            inputStream = new ByteArrayInputStream(b);
         } else {
            inputStream = new FileInputStream(input2);
            doClose = true;
         }
      } else {
         throw ioex("Cannot convert object of type {0} to an InputStream.", cn(input));
      }

      return inputStream;
   }

   /**
    * Converts this pipe into a {@link ParserReader}.
    *
    * @return The converted pipe.
    * @throws IOException Thrown by underlying stream.
    */
   public ParserReader getParserReader() throws IOException {
      if (input == null)
         return null;
      if (input instanceof ParserReader input2)
         parserReader = input2;
      else
         parserReader = new ParserReader(this);
      return parserReader;
   }

   /**
    * Wraps the specified input object inside a reader.
    *
    * <p>
    * Subclasses can override this method to implement their own readers.
    *
    * @return The input object wrapped in a Reader, or <jk>null</jk> if the object is null.
    * @throws IOException If object could not be converted to a reader.
    */
   public Reader getReader() throws IOException {
      if (input == null)
         return null;

      if (input instanceof Reader input2) {
         if (debug) {
            inputString = read(input2);
            reader = new StringReader(inputString);
         } else {
            reader = input2;
            doClose = autoCloseStreams;
         }
      } else if (input instanceof CharSequence input2) {
         inputString = input2.toString();
         reader = new ParserReader(this);
         doClose = false;
      } else if (input instanceof InputStream || input instanceof byte[]) {
         doClose = input instanceof InputStream && autoCloseStreams;
         InputStream is = (input instanceof InputStream input2 ? input2 : new ByteArrayInputStream((byte[])input));
         CharsetDecoder cd = charset.newDecoder();
         if (strict) {
            cd.onMalformedInput(CodingErrorAction.REPORT);
            cd.onUnmappableCharacter(CodingErrorAction.REPORT);
         } else {
            cd.onMalformedInput(CodingErrorAction.REPLACE);
            cd.onUnmappableCharacter(CodingErrorAction.REPLACE);
         }
         reader = new InputStreamReader(is, cd);
         if (debug) {
            inputString = read(reader);
            reader = new StringReader(inputString);
         }
      } else if (input instanceof File input2) {
         CharsetDecoder cd = charset.newDecoder();
         if (strict) {
            cd.onMalformedInput(CodingErrorAction.REPORT);
            cd.onUnmappableCharacter(CodingErrorAction.REPORT);
         } else {
            cd.onMalformedInput(CodingErrorAction.REPLACE);
            cd.onUnmappableCharacter(CodingErrorAction.REPLACE);
         }
         reader = new InputStreamReader(new FileInputStream(input2), cd);
         if (debug) {
            inputString = read(reader);
            reader = new StringReader(inputString);
         }
         doClose = true;
      } else {
         throw ioex("Cannot convert object of type {0} to an InputStream.", cn(input));
      }

      return reader;
   }

   /**
    * Returns <jk>true</jk> if the contents passed into this pipe was a {@link CharSequence}.
    *
    * @return <jk>true</jk> if the contents passed into this pipe was a {@link CharSequence}.
    */
   public boolean isString() { return nn(inputString); }

   /**
    * Sets the ParserReader/ParserInputStream/XmlReader constructed from this pipe.
    *
    * <p>
    * Used for gathering the failure position when {@link ParseException} is thrown.
    *
    * @param positionable The ParserReader/ParserInputStream/XmlReader constructed from this pipe.
    */
   public void setPositionable(Positionable positionable) { this.positionable = positionable; }

   private byte[] convertFromString(String in) {
      return switch (binaryFormat) {
         case BASE64 -> base64Decode(in);
         case HEX -> fromHex(in);
         case SPACED_HEX -> fromSpacedHex(in);
         default -> new byte[0];
      };
   }

   Position getPosition() {
      if (positionable == null)
         return Position.UNKNOWN;
      Position p = positionable.getPosition();
      if (p == null)
         return Position.UNKNOWN;
      return p;
   }
}