/*
 * Copyright (c) 2023–2024 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::{ Read, stdin, stdout, Write },
	process::{ Command, exit, Stdio },
};

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

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 };

fn main() {
	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("stdio proc exec");
		if let Err(e) = pledge(Some(promises), None) {
			eprintln!("{}: {}", argv[0], e.strerror());
			exit(EX_OSERR);
		}
	}

	let usage = format!(
		"Usage: {} [-d delimiter] index command [args...]",
		argv[0],
	);

	while let Some(opt) = argv.getopt("d:") {
		match opt.opt() {
			Ok("d") => {
				/* delimiter */
				d = opt.arg().unwrap();
				optind = opt.ind();
			},
			_ => {
				eprintln!("{}", usage);
				exit(EX_USAGE);
			}
		};
	}

	/* 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);
	});

	/* 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(|| {
		eprintln!("{}", usage);
		exit(EX_USAGE);
	});

	/* read entire standard input into memory */
	let mut buf = String::new();
	if let Err(e) = stdin().read_to_string(&mut buf) {
		eprintln!("{}: {}", argv[0], e.strerror());
		exit(EX_IOERR);
	};

	/* split the buffer by the delimiter (by default, '\u{1E}') */
	let mut fields = buf.split(&d).collect::<Vec<&str>>();

	/* 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())
		.stdout(Stdio::piped()) /* piped stdout to handle output ourselves */
		.spawn()
		.unwrap_or_else( |e| {
			eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
			exit(EX_UNAVAILABLE);
		});

	/* get field we want to pipe into spawned program */
	let field = fields.get(index).unwrap_or_else(|| {
		eprintln!(
			"{}: {}: No such index in input",
			argv[0],
			index.to_string(),
		);
		exit(EX_DATAERR);
	});

	/* get the stdin of the newly spawned program and feed it the field val */
	if let Some(mut child_stdin) = spawned.stdin.take() {
		let _ = child_stdin.write_all(field.as_bytes());
		drop(child_stdin); /* stay safe! drop your children! */
	}

	let output = spawned.wait_with_output().unwrap_or_else(|e| {
		eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
		exit(EX_IOERR);
	});

	/* 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 fields[index].chars().last() != Some('\n') /* no newline */
		&& replace.pop() != Some(b'\n') { /* pop last char of replacement */
		/* restore replacement to original command output if popped char was not
		 * a newline */
		replace = output.stdout;
	}

	/* convert the output of the program to UTF-8 */
	let new_field = String::from_utf8(replace).unwrap_or_else(|e| {
		eprintln!("{}: {}: {}", argv[0], argv[command_arg], e);
		exit(EX_IOERR);
	});

	/* store the new field in the old fields vector */
	fields[index] = &new_field;

	/* fop it */ 
	stdout().write_all(
		fields.join(&d.to_string()).as_bytes()
	).unwrap_or_else(|e| {
		eprintln!("{}: {}", argv[0], e.strerror());
		exit(EX_IOERR);
	});
}