/*
 * Copyright (c) 2023–2025 Emma Tebibyte <emma@tebibyte.media>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Affero 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 Affero General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see https://www.gnu.org/licenses/.
 */

use std::{
	env::args,
	io::{ Error, Write, stdin, stdout },
	process::{ Command, ExitCode, Stdio, exit },
};

extern crate delimit;
extern crate getopt;
extern crate strerror;
extern crate sysexits;

use delimit::Delimited;
use getopt::GetOpt;
use strerror::StrError;
use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };

#[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
#[cfg(target_os="openbsd")] extern crate openbsd;
#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };

fn err(argv0: &String, e: Error) {
	eprintln!("{}: {}", argv0, e.strerror());
}

fn usage(argv0: &String) -> u8 {
	eprintln!("Usage: {} [-d delimiter] index command [args...]", argv0);
	EX_USAGE
}

fn main() -> ExitCode {
	let argv = args().collect::<Vec<String>>();
	let mut d = '\u{1E}'.to_string(); /* ASCII record separator */
	let mut optind = 1;

	#[cfg(target_os="openbsd")] {
		let promises = Promises::new("exec proc stdio unveil");
		if let Err(e) = pledge(Some(promises), None) {
			err(&argv[0], e);
			return ExitCode::from(EX_OSERR);
		}

		if let Err(e) = unveil(None, None) {
			err(&argv[0], e);
			return ExitCode::from(EX_OSERR);
		}
	}

	if argv.len() == 1 { return ExitCode::from(usage(&argv[0])); }

	while let Some(opt) = argv.getopt("d:") {
		match opt.opt() {
			Ok("d") => {
				/* delimiter */
				d = opt.arg().unwrap();
				optind = opt.ind();
			},
			_ => {
				return ExitCode::from(usage(&argv[0]));
			}
		};
	}

	/* parse the specified index as a number we can use */
	let index = argv[optind].parse::<usize>().unwrap_or_else(|e| {
		eprintln!("{}: {}: {}", argv[0], argv[1], e);
		exit(EX_DATAERR.into());
	});

	/* index of the argv[0] for the operator command */
	let command_arg = optind as usize + 1;

	/* argv[0] of the operator command */
	let operator = argv.get(command_arg).unwrap_or_else(|| {
		exit(usage(&argv[0]).into());
	});

	let stdin = stdin().lock();

	let mut input = Delimited::new(stdin, d.clone());
	let mut n = 0;

	let mut fopped = false;

	while let Some(i) = input.next() {
		let v = match i {
			Ok(v) => v,
			Err(e) => {
				err(&argv[0], e);
				return EX_IOERR.into();
			},
		};

		let mut out = Vec::new();

		if n == index { /* fop it */
			/* collect arguments for the operator command */
			let command_args = argv
				.iter()
				.clone()
				.skip(command_arg + 1) /* skip the command name */
				.collect::<Vec<&String>>();

			/* spawn the command to operate on the field */
			let mut spawned = Command::new(operator)
				.args(command_args) /* spawn with the specified arguments */
				.stdin(Stdio::piped())
				/* piped stdout to handle output ourselves */
				.stdout(Stdio::piped()) 
				.spawn()
				.unwrap_or_else( |e| {
					err(&argv[0], e);
					exit(EX_UNAVAILABLE.into());
				});

			/* feed the spawned program’s stdin the field value */
			if let Some(mut child_stdin) = spawned.stdin.take() {
				let _ = child_stdin.write_all(&v);
				drop(child_stdin); /* stay safe! drop your children! */

				let output = spawned.wait_with_output().unwrap_or_else(|e| {
					err(&argv[0], e);
					exit(EX_IOERR.into());
				});

				/* get the output with which the original field will
				 * be replaced */
				let mut replace = output.stdout.clone();

				/* pop trailing newline out if the input did not contain it */
				if v.iter().last() != Some(&b'\n')
					&& replace.pop() != Some(b'\n')
				{
					out = output.stdout;
				} else {
					out = replace;
				}
			}

			fopped = true;
		} else {
			out = v;
		}

		/* since we cannot know when we’re done, place a new delimiter before
		 * each index unless it is the 0th */
		if n != 0 {
			stdout().write_all(d.as_bytes()).unwrap_or_else(|e| {
				err(&argv[0], e);
				exit(EX_IOERR.into());
			});
		}

		stdout().write_all(&out).unwrap_or_else(|e| {
			err(&argv[0], e);
			exit(EX_IOERR.into());
		});

		n += 1;
	}

	if fopped {
		return ExitCode::SUCCESS;
	} else {
		eprintln!("{}: {}: no such index in input", argv[0], index);
		return EX_DATAERR.into();
	}
}