/*
 * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
 * Copyright (c) 2024 DTB <trinity@trinity.moe>
 * 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,
	fs::File,
	io::{ stdin, stdout, stderr, BufWriter, Read, Write },
	os::fd::{ AsRawFd, FromRawFd },
	process::{ exit, ExitCode },
};

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

use getopt::GetOpt;
use strerror::StrError;
use sysexits::{ EX_IOERR, EX_USAGE };

enum ArgMode{ In, Out }

fn main() -> ExitCode {
	let argv = args().collect::<Vec<_>>();
	let usage = format!("Usage: {} [-aetu] [-i input] [-o output]", argv[0]);

	let mut a = false; /* append to the file */
	let mut e = false; /* use stderr as an output */
	let mut t = true; /* do not truncate the file before writing */
	let mut u = false; /* unbuffer i/o */
	let mut ins = Vec::new(); /* initial input file path vector */
	let mut outs = Vec::new(); /* initial output file path vector */
	let mut mode: Option<ArgMode> = None; /* mode for positional arguments */
	let mut optind = 0;

	while let Some(opt) = argv.getopt("aei:o:tu") {
		match opt.opt() {
			Ok("a") => a = true,
			Ok("e") => e = true, 
			Ok("u") => u = true,
			Ok("t") => t = false,
			Ok("i") => { /* add inputs */
				let input = opt.arg().unwrap();
				ins.push(input);
				mode = Some(ArgMode::In);
			},
			Ok("o") => { /* add output */
				let output = opt.arg().unwrap(); 
				outs.push(output);
				mode = Some(ArgMode::Out);
			},
			Err(_) | Ok(_) => {
				eprintln!("{}", usage);
				return ExitCode::from(EX_USAGE as u8);
			},
		};
		optind = opt.ind();
	}

	let remaining = argv.iter().skip(optind);

	if let Some(m) = mode {
		for arg in remaining {
			match m {
				ArgMode::In => ins.push(arg.to_string()),
				ArgMode::Out => outs.push(arg.to_string()),
			};
		}
	}

	/* use stdin if no inputs are specified */
	if ins.is_empty() { ins.push("-".to_string()); }

	/* use stdout if no outputs are specified */
	if outs.is_empty() && !e { outs.push("-".to_string()); }
	
	/* map all path strings to files */
	let inputs = ins.iter().map(|file| {
		/* if a file is “-”, it is stdin */
		if *file == "-" {
			/* portable way to access stdin as a file */
			return unsafe { File::from_raw_fd(stdin().as_raw_fd()) };
		}

		match File::open(file) {
			Ok(f) => f,
			Err(e) => {
				eprintln!("{}: {}: {}", argv[0], file, e.strerror());
				exit(EX_IOERR);
			},
		}
	}).collect::<Vec<_>>();

	/* map all path strings to files */
	let mut outputs = outs.iter().map(|file| {
		/* of a file is “-”, it is stdout */
		if *file == "-" {
			/* portable way to access stdout as a file */
			return unsafe { File::from_raw_fd(stdout().as_raw_fd()) }; 
		}

		let options = File::options()
			/* don’t truncate if -t is specified, append if -a is specified */
			.truncate(t)
			.append(a)
			/* enable the ability to create and write to files */
			.create(true)
			.write(true)
			/* finally, open the file! */
			.open(file);

		match options {
			Ok(f) => return f,
			Err(e) => {
				eprintln!("{}: {}: {}", argv[0], file, e.strerror());
				exit(EX_IOERR);
			},
		};
	}).collect::<Vec<_>>();

	/* if -e is specified, use stderr */
	if e {
		/* portable way to access stderr as a file */
		outputs.push(unsafe { File::from_raw_fd(stderr().as_raw_fd()) });
	}

	let mut outputs = outputs.iter().map(|o| {
		if u {
			/* unbuffered writing through a buffer of capacity 0 */
			BufWriter::with_capacity(0, o)
		} else {
			/* theoretically buffered writing */
			BufWriter::new(o)
		}
	}).collect::<Vec<_>>();

	for file in inputs {
		for byte in file.bytes().map(|b| {
			b.unwrap_or_else(|e| {
				eprintln!("{}: {}", argv[0], e.strerror());
				exit(EX_IOERR);
			})
		}) {
			for out in &mut outputs {
				if let Err(e) = out.write(&[byte]) {
					eprintln!("{}: {}", argv[0], e.strerror());
					return ExitCode::from(EX_IOERR as u8);
				}

				if u {
					/* immediately flush the output for -u */
					if let Err(e) = out.flush() { 
						eprintln!("{}: {}", argv[0], e.strerror());
						return ExitCode::from(EX_IOERR as u8);
					}
				}
			}
		}
	}

	ExitCode::SUCCESS
}