package io.jawk.jrt;
   
   /*-
    * ╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲
    * Jawk
    * ჻჻჻჻჻჻
    * Copyright (C) 2006 - 2026 MetricsHub
    * ჻჻჻჻჻჻
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation, either version 3 of the
   * License, or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Lesser Public License for more details.
   *
   * You should have received a copy of the GNU General Lesser Public
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-3.0.html>.
   * ╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱
   */
  
  import java.io.Closeable;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.nio.charset.StandardCharsets;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  
  import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  
  /**
   * An {@link InputSource} that reads records from an {@link InputStream},
   * traversing the {@code ARGV} array to open filenames and apply
   * {@code name=value} variable assignments exactly like the classic AWK
   * command-line flow.
   * <p>
   * When no filename arguments are present in {@code ARGV}, records are read
   * from the supplied default {@link InputStream} (usually {@code System.in}).
   * This class is the default {@link InputSource} used internally by the
   * runtime when no custom source has been configured via
   * {@code AwkSettings#setInputSource(...)}.
   * </p>
   * <p>
   * API note: this type is public to allow runtime wiring between packages, but
   * it is considered an internal implementation detail. Embedding applications
   * should implement {@link InputSource} directly rather than depend on this
   * class, whose behavior may change in future releases.
   * </p>
   *
   * @see InputSource
   */
  public class StreamInputSource implements InputSource, Closeable {
  
  	private final InputStream defaultInput;
  	private final VariableManager vm;
  	private final JRT jrt;
  
  	// ARGV traversal state
  	private Map<Object, Object> arglistMap;
  	private int arglistIdx;
  	private int arglistMaxKey;
  	private boolean hasFilenames;
  
  	// Current reader and record
  	private PartitioningReader partitioningReader;
  	private boolean currentReaderIsDefaultInput;
  	private boolean currentFromFilenameList;
  	private String currentRecord;
  	private boolean currentReaderExhausted;
  
  	// Per-file stepping state (BEGINFILE/ENDFILE and nextfile support)
  	private String currentFileOpenError;
  	private boolean currentPresentedToLoop;
  	private int lastArgumentIndex;
  
  	/**
  	 * Creates a stream-backed input source.
  	 *
  	 * @param defaultInput the fallback input stream used when {@code ARGV}
  	 *        contains no filename arguments (typically {@code System.in})
  	 * @param vm the variable manager providing access to {@code ARGV} and
  	 *        {@code ARGC}
  	 * @param jrt the JRT instance used for string conversion and special
  	 *        variable updates
  	 */
  	@SuppressFBWarnings(value = "CT_CONSTRUCTOR_THROW", justification = "Fail-fast argument validation; no security-sensitive state to protect from finalizer attacks")
  	public StreamInputSource(InputStream defaultInput, VariableManager vm, JRT jrt) {
  		this.defaultInput = Objects.requireNonNull(defaultInput, "defaultInput");
  		this.vm = Objects.requireNonNull(vm, "vm");
  		this.jrt = Objects.requireNonNull(jrt, "jrt");
  	}
  
 	/** {@inheritDoc} */
 	@Override
 	public boolean nextRecord() throws IOException {
 		initializeArgList();
 
 		while (true) {
 			if (partitioningReader == null || currentReaderExhausted) {
 				if (!prepareNextReader()) {
 					return false;
 				}
 				currentReaderExhausted = false;
 			}
 
 			String nextRecord = partitioningReader.readRecord();
 			if (nextRecord != null) {
 				currentRecord = nextRecord;
 				currentFromFilenameList = partitioningReader.fromFilenameList();
 				return true;
 			}
 			if (!partitioningReader.fromFilenameList()) {
 				return false;
 			}
 			currentReaderExhausted = true;
 		}
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public String getRecordText() {
 		return currentRecord;
 	}
 
 	/**
 	 * Always returns {@code null} so that the runtime splits {@code $0} using
 	 * the current field separator (FS).
 	 *
 	 * @return {@code null}
 	 */
 	@Override
 	public List<String> getFields() {
 		return null;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public boolean isFromFilenameList() {
 		return currentFromFilenameList;
 	}
 
 	/**
 	 * Propagates a record-separator change to the active
 	 * {@link PartitioningReader}.
 	 *
 	 * @param rs the new record separator value
 	 */
 	public void setRecordSeparator(String rs) {
 		if (partitioningReader != null) {
 			partitioningReader.setRecordSeparator(rs);
 		}
 	}
 
 	/**
 	 * Returns the underlying {@link PartitioningReader} currently in use, or
 	 * {@code null} if no reader has been opened yet.
 	 *
 	 * @return the active reader, or {@code null}
 	 */
 	PartitioningReader getPartitioningReader() {
 		return partitioningReader;
 	}
 
 	// ------------------------------------------------------------------
 	// ARGV traversal logic (moved from JRT)
 	// ------------------------------------------------------------------
 
 	/**
 	 * Initialize internal state for traversing {@code ARGV}.
 	 */
 	private void initializeArgList() {
 		if (arglistMap != null) {
 			return;
 		}
 		arglistMap = toArgvMap(vm.getARGV());
 		arglistMaxKey = computeMaxArgvKey();
 		arglistIdx = 1;
 		hasFilenames = detectFilenames();
 	}
 
 	private Map<Object, Object> toArgvMap(Object argv) {
 		if (!(argv instanceof Map)) {
 			throw new IllegalArgumentException("ARGV must be a Map.");
 		}
 		@SuppressWarnings("unchecked")
 		Map<Object, Object> argvMap = (Map<Object, Object>) argv;
 		return argvMap;
 	}
 
 	/**
 	 * Compute the highest numeric key present in the current {@code arglistMap}.
 	 *
 	 * @return the maximum integer key, or {@code 0} when the array is empty
 	 */
 	private int computeMaxArgvKey() {
 		int max = 0;
 		for (Object key : arglistMap.keySet()) {
 			int idx = (int) JRT.toLong(key);
 			if (idx > max) {
 				max = idx;
 			}
 		}
 		return max;
 	}
 
 	/**
 	 * Determine whether {@code ARGV} contains any filename entries (arguments
 	 * without an equals sign).
 	 *
 	 * @return {@code true} if at least one filename was found
 	 */
 	private boolean detectFilenames() {
 		int traversalArgCount = getTraversalArgCount();
 		boolean found = false;
 		for (int i = 1; i < traversalArgCount && !found; i++) {
 			Object argValue = getArgvValue(i);
 			if (argValue == MISSING_ARGV_VALUE) {
 				continue;
 			}
 			String arg = jrt.toAwkString(argValue);
 			if (arg.isEmpty() || arg.indexOf('=') > 0) {
 				continue;
 			}
 			found = true;
 		}
 		return found;
 	}
 
 	/**
 	 * Retrieve the number of command-line arguments supplied to the script.
 	 *
 	 * @return {@code ARGC} converted to an {@code int}
 	 */
 	private int getArgCount() {
 		double raw = JRT.toDouble(vm.getARGC());
 		if (raw <= 0) {
 			return 0;
 		}
 		if (raw > Integer.MAX_VALUE) {
 			return Integer.MAX_VALUE;
 		}
 		return (int) raw;
 	}
 
 	/**
 	 * Return the effective upper bound for ARGV traversal, capped by the
 	 * highest known ARGV key so that absurdly large ARGC values do not
 	 * cause unbounded iteration over missing entries.
 	 *
 	 * @return the capped traversal count
 	 */
 	private int getTraversalArgCount() {
 		int argCount = getArgCount();
 		if (argCount <= 0) {
 			return 0;
 		}
 		return Math.min(argCount, arglistMaxKey + 1);
 	}
 
 	/**
 	 * Obtain the next valid argument from {@code ARGV}, skipping
 	 * uninitialized or empty entries.
 	 *
 	 * @return the next argument as an AWK string, or {@code null} if none
 	 *         remain
 	 */
 	private String nextArgument() {
 		int traversalArgCount = getTraversalArgCount();
 		while (arglistIdx < traversalArgCount) {
 			int idx = arglistIdx++;
 			Object argValue = getArgvValue(idx);
 			if (argValue == MISSING_ARGV_VALUE) {
 				continue;
 			}
 			String arg = jrt.toAwkString(argValue);
 			if (!arg.isEmpty()) {
 				lastArgumentIndex = idx;
 				return arg;
 			}
 		}
 		return null;
 	}
 
 	private static final Object MISSING_ARGV_VALUE = new Object();
 
 	private Object getArgvValue(int index) {
 		Long longIndex = Long.valueOf(index);
 		if (arglistMap instanceof AssocArray) {
 			return JRT.containsAwkKey(arglistMap, longIndex) ?
 					JRT.getAssocArrayValue(arglistMap, longIndex) : MISSING_ARGV_VALUE;
 		}
 		if (arglistMap.containsKey(longIndex)) {
 			return arglistMap.get(longIndex);
 		}
 		Integer intIndex = Integer.valueOf(index);
 		if (arglistMap.containsKey(intIndex)) {
 			return arglistMap.get(intIndex);
 		}
 		for (Map.Entry<Object, Object> entry : arglistMap.entrySet()) {
 			Object key = entry.getKey();
 			if (!(key instanceof Number)) {
 				continue;
 			}
 			double numericKey = ((Number) key).doubleValue();
 			if (JRT.isActuallyLong(numericKey) && ((long) Math.rint(numericKey)) == index) {
 				return entry.getValue();
 			}
 		}
 		return MISSING_ARGV_VALUE;
 	}
 
 	/**
 	 * Prepare the {@link PartitioningReader} for the next input source. This
 	 * may be a filename, a variable assignment, or standard input if no
 	 * filenames remain.
 	 *
 	 * @return {@code true} if a reader was prepared, {@code false} if no more
 	 *         input is available
 	 * @throws IOException if an I/O error occurs while opening a file
 	 */
 	private boolean prepareNextReader() throws IOException {
 		boolean ready = false;
 		arglistMaxKey = computeMaxArgvKey();
 		hasFilenames = detectFilenames();
 		while (!ready) {
 			String arg = nextArgument();
 			if (arg == null) {
 				// ARGC/ARGV may have changed while evaluating assignments.
 				hasFilenames = detectFilenames();
 				if (partitioningReader == null && !hasFilenames) {
 					partitioningReader = new PartitioningReader(
 							new InputStreamReader(defaultInput, StandardCharsets.UTF_8),
 							jrt.getRSString());
 					currentReaderIsDefaultInput = true;
 					jrt.setFILENAMEViaJrt(jrt.toInputScalar(""));
 					// gawk clears ERRNO whenever the main input advances
 					// successfully
 					jrt.setERRNO("");
 					return true;
 				}
 				closeCurrentReaderIfFileStream();
 				return false;
 			}
 			if (arg.indexOf('=') > 0) {
 				setFilelistVariable(arg);
 				// Recompute bounds so ARGC changes are reflected immediately.
 				arglistMaxKey = computeMaxArgvKey();
 				hasFilenames = detectFilenames();
 				if (partitioningReader == null && !hasFilenames) {
 					partitioningReader = new PartitioningReader(
 							new InputStreamReader(defaultInput, StandardCharsets.UTF_8),
 							jrt.getRSString());
 					currentReaderIsDefaultInput = true;
 					jrt.setFILENAMEViaJrt(jrt.toInputScalar(""));
 					// gawk clears ERRNO whenever the main input advances
 					// successfully
 					jrt.setERRNO("");
 					return true;
 				}
 			} else {
 				closeCurrentReaderIfFileStream();
 				partitioningReader = openFileListReader(arg);
 				jrt.setFILENAMEViaJrt(jrt.toInputScalar(arg));
 				jrt.setFNR(0L);
 				jrt.setARGIND(Long.valueOf(lastArgumentIndex));
 				// gawk clears ERRNO whenever the main input advances
 				// successfully
 				jrt.setERRNO("");
 				ready = true;
 			}
 		}
 		return true;
 	}
 
 	/**
 	 * Advance to the next input file for the per-file main input loop used
 	 * when BEGINFILE/ENDFILE rules or {@code nextfile} are present. Variable
 	 * assignment arguments are applied along the way, exactly like
 	 * {@link #nextRecord()} does when it crosses a file boundary.
 	 * <p>
 	 * On success, FILENAME, FNR, ARGIND, and ERRNO are updated and {@code $0}
 	 * is cleared, so the BEGINFILE rules observe the new file before any
 	 * record is read. A file that cannot be opened is still reported as
 	 * available: ERRNO carries the error description and
 	 * {@link #getCurrentFileOpenError()} returns it until the next advance,
 	 * enabling gawk's non-fatal BEGINFILE error handling.
 	 * </p>
 	 *
 	 * @return {@code true} when a new input file (or the initial stdin
 	 *         stream) is current; {@code false} when input is exhausted
 	 * @throws IOException if an I/O error occurs while traversing ARGV
 	 */
 	public boolean advanceToNextFile() throws IOException {
 		initializeArgList();
 
 		// Adopt a reader already opened by a non-redirected getline that ran
 		// before the per-file loop (e.g. in a BEGIN rule): it is the current
 		// input file, already positioned after the records getline consumed.
 		if (!currentPresentedToLoop
 				&& partitioningReader != null
 				&& !currentReaderExhausted
 				&& currentFileOpenError == null) {
 			currentPresentedToLoop = true;
 			return true;
 		}
 
 		currentFileOpenError = null;
 		arglistMaxKey = computeMaxArgvKey();
 		hasFilenames = detectFilenames();
 		while (true) {
 			String arg = nextArgument();
 			if (arg == null) {
 				// ARGC/ARGV may have changed while evaluating assignments.
 				hasFilenames = detectFilenames();
 				if (partitioningReader == null && !hasFilenames) {
 					return presentDefaultInput();
 				}
 				closeCurrentReaderIfFileStream();
 				return false;
 			}
 			if (arg.indexOf('=') > 0) {
 				setFilelistVariable(arg);
 				// Recompute bounds so ARGC changes are reflected immediately.
 				arglistMaxKey = computeMaxArgvKey();
 				hasFilenames = detectFilenames();
 				if (partitioningReader == null && !hasFilenames) {
 					return presentDefaultInput();
 				}
 			} else {
 				closeCurrentReaderIfFileStream();
 				partitioningReader = null;
 				currentReaderExhausted = false;
 				currentPresentedToLoop = true;
 				jrt.setFILENAMEViaJrt(jrt.toInputScalar(arg));
 				beginFileState(lastArgumentIndex);
 				currentFileOpenError = openCurrentFile(arg);
 				if (currentFileOpenError != null) {
 					jrt.setERRNO(currentFileOpenError);
 				}
 				return true;
 			}
 		}
 	}
 
 	/**
 	 * Reads the next record of the current input file only, never advancing
 	 * to the next input file. Used by the per-file main input loop so that
 	 * ENDFILE rules can run at each file boundary.
 	 *
 	 * @return {@code true} when a record is available; {@code false} at the
 	 *         end of the current input file
 	 * @throws IOException if an I/O error occurs
 	 */
 	public boolean nextRecordInCurrentFile() throws IOException {
 		if (partitioningReader == null || currentReaderExhausted || currentFileOpenError != null) {
 			return false;
 		}
 		String nextRecord = partitioningReader.readRecord();
 		if (nextRecord == null) {
 			currentReaderExhausted = true;
 			return false;
 		}
 		currentRecord = nextRecord;
 		currentFromFilenameList = partitioningReader.fromFilenameList();
 		return true;
 	}
 
 	/**
 	 * Returns the error description recorded when the current input file
 	 * could not be opened by {@link #advanceToNextFile()}, or {@code null}
 	 * when the current input is readable.
 	 *
 	 * @return the pending open error, or {@code null}
 	 */
 	public String getCurrentFileOpenError() {
 		return currentFileOpenError;
 	}
 
 	/**
 	 * Presents the default input stream (usually stdin) as the current and
 	 * only input "file" for the per-file main input loop.
 	 *
 	 * @return always {@code true}
 	 */
 	private boolean presentDefaultInput() {
 		partitioningReader = new PartitioningReader(
 				new InputStreamReader(defaultInput, StandardCharsets.UTF_8),
 				jrt.getRSString());
 		currentReaderIsDefaultInput = true;
 		currentPresentedToLoop = true;
 		jrt.setFILENAMEViaJrt(jrt.toInputScalar(""));
 		beginFileState(0);
 		return true;
 	}
 
 	/**
 	 * Resets the per-file special variables observed by BEGINFILE rules: FNR
 	 * and {@code $0} are cleared, ERRNO is emptied, and ARGIND designates the
 	 * ARGV entry being processed.
 	 *
 	 * @param argvIndex the ARGV index of the new current file, or {@code 0}
 	 *        for the default input stream
 	 */
 	private void beginFileState(int argvIndex) {
 		jrt.setFNR(0L);
 		jrt.setERRNO("");
 		jrt.setARGIND(Long.valueOf(argvIndex));
 		jrt.setInputLine("");
 	}
 
 	/**
 	 * Attempts to open the given filename as the current input file.
 	 *
 	 * @param arg the filename to open
 	 * @return {@code null} on success, or a gawk-style error description when
 	 *         the file cannot be opened for reading
 	 */
 	private String openCurrentFile(String arg) {
 		if ("-".equals(arg)) {
 			try {
 				partitioningReader = openFileListReader(arg);
 				return null;
 			} catch (IOException e) {
 				return e.getMessage();
 			}
 		}
 		File file = new File(arg);
 		if (file.isDirectory()) {
 			return "Is a directory";
 		}
 		if (!file.exists()) {
 			return "No such file or directory";
 		}
 		try {
 			partitioningReader = openFileListReader(arg);
 			return null;
 		} catch (IOException e) {
 			String message = e.getMessage();
 			if (message == null || message.isEmpty()) {
 				return "Permission denied";
 			}
 			// Java prefixes the failing path: "path (reason)". Keep the reason.
 			int open = message.lastIndexOf('(');
 			if (open >= 0 && message.endsWith(")")) {
 				return message.substring(open + 1, message.length() - 1);
 			}
 			return message;
 		}
 	}
 
 	/**
 	 * Opens a reader for the given {@code ARGV} filename entry. The
 	 * conventional {@code -} filename designates the default input stream
 	 * (usually stdin), as required by POSIX; any other name is opened as a
 	 * regular file.
 	 *
 	 * @param arg the filename from the {@code ARGV} file list
 	 * @return a reader presenting the argument as a file-list input
 	 * @throws IOException if the file cannot be opened for reading
 	 */
 	private PartitioningReader openFileListReader(String arg) throws IOException {
 		boolean isDefaultInput = "-".equals(arg);
 		// Open the stream before publishing the flag: if the open fails, the
 		// still-current reader must keep its own classification, so that
 		// cleanup does not close the caller-provided default input stream.
 		InputStream stream = isDefaultInput ? defaultInput : new FileInputStream(arg);
 		PartitioningReader reader = new PartitioningReader(
 				new InputStreamReader(stream, StandardCharsets.UTF_8),
 				jrt.getRSString(),
 				true);
 		currentReaderIsDefaultInput = isDefaultInput;
 		return reader;
 	}
 
 	/**
 	 * Closes the current {@link PartitioningReader} if it wraps a file stream
 	 * (not {@code defaultInput}). This prevents file-descriptor leaks when
 	 * traversing multiple ARGV files.
 	 */
 	private void closeCurrentReaderIfFileStream() {
 		if (partitioningReader != null && partitioningReader.fromFilenameList() && !currentReaderIsDefaultInput) {
 			try {
 				partitioningReader.close();
 			} catch (IOException ignored) {
 				// Best-effort close; the file is no longer needed.
 			}
 		}
 	}
 
 	/**
 	 * Releases any open file-backed reader held by this source.
 	 * <p>
 	 * This method is idempotent and safe to call multiple times. It does
 	 * <em>not</em> close the default input stream ({@code System.in}).
 	 * </p>
 	 *
 	 * @throws IOException never thrown; signature required by {@link Closeable}
 	 */
 	@Override
 	public void close() throws IOException {
 		closeCurrentReaderIfFileStream();
 	}
 
 	/**
 	 * Parse a {@code name=value} argument from the command line and assign it
 	 * to the corresponding AWK variable.
 	 *
 	 * @param nameValue argument in the form {@code name=value}
 	 */
 	private void setFilelistVariable(String nameValue) {
 		int eqIdx = nameValue.indexOf('=');
 		if (eqIdx == 0) {
 			throw new IllegalArgumentException(
 					"Must have a non-blank variable name in a name=value variable assignment argument.");
 		}
 		String name = nameValue.substring(0, eqIdx);
 		if (name.startsWith("awk::")) {
 			name = name.substring("awk::".length());
 		}
 		String value = nameValue.substring(eqIdx + 1);
 		vm.assignVariable(name, jrt.toInputScalar(value));
 	}
 }