/*
 * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
 * SPDX-License-Identifier: LGPL-3.0-or-later
 *
 * 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see https://www.gnu.org/licenses/.
 */

use std::ffi::{ c_int, c_char, CString, CStr };

/* binding to getopt(3p) */
extern "C" {
	static mut optarg: *mut c_char;
	static mut _opterr: c_int;
	static mut optind: c_int;
	static mut optopt: c_int;

	fn getopt(
		___argc: c_int,
		___argv: *const *mut c_char,
		__shortopts: *const c_char,
	) -> c_int;
}

pub struct Opt {
	pub arg: Option<String>,
	ind: *mut i32,
	pub opt: String,
}

impl Opt {
	pub fn index(&self) -> usize { unsafe { *self.ind as usize } }

	pub fn set_index(&self, ind: i32) { unsafe { *self.ind = ind; } }
}

pub enum OptError {
	MissingArg(String),
	UnknownOpt(String),
}

/* function signature */
pub trait GetOpt {
	fn getopt(&self, optstring: &str) -> Option<Result<Opt, OptError>>;
}

impl GetOpt for Vec<String> {
    fn getopt(&self, optstring: &str) -> Option<Result<Opt, OptError>> {
        let c_strings: Vec<_> = self
			.iter()
			.cloned()
			.map(CString::new)
			.map(Result::unwrap)
			.collect();

		/* these operations must be separated out into separate operations so
		 * the CStrings can live long enough */
        let argv: Vec<_> = c_strings.iter().map(|x| x.as_ptr()).collect();
        let argv_ptr = argv.as_ptr() as *const *mut c_char;
        let opts = CString::new(optstring).unwrap().into_raw();
        let len = self.len() as c_int;

        unsafe {
            match getopt(len, argv_ptr, opts) { 
				/* From getopt(3p):
				 *
				 * The getopt() f unction shall return the next option character
				 * specified on the command line.
				 *
				 * A <colon> (':') shall be returned if getopt() detects a
				 * missing argument and the first character of optstring was a
				 * <colon> (':').
				 *
				 * A <question-mark> ('?') shall be returned if getopt()
				 * encounters an option character not in optstring or detects a
				 * missing argument and the first character of optstring was not
				 * a <colon> (':').
				 *
				 * Otherwise, getopt() shall return -1 when all command line
				 * options are parsed. */
				58 => { /* numerical ASCII value for ':' */
					Some(Err(OptError::MissingArg(optopt.to_string())))
				},
				63 => { /* numerical ASCII value for '?' */
					Some(Err(OptError::UnknownOpt(optopt.to_string())))
				},
				/* From getopt(3p):
				 *
				 * If, when getopt() is called:
				 *
				 * argv[optind]  is a null pointer
				 * *argv[optind]  is not the character -
				 * argv[optind]  points to the string "-"
				 *
				 * getopt() shall return -1 without changing optind.  If:
				 *
				 * argv[optind]   points to the string "--"
				 *
				 * getopt() shall return -1 after incrementing optind. */
                -1 => return None,
                opt => {
					let arg = CStr::from_ptr(optarg)
						.to_string_lossy()
						.into_owned();

					Some(Ok(Opt {
						arg: Some(arg), /* opt argument */
						/* From getopt(3p):
						 *
						 * The variable optind is the index of the next element
						 * of the argv[] vector to be processed. It shall be
						 * initialized to 1 by the system, and getopt() shall
						 * update it when it finishes with each element of
						 * argv[]. If the application sets optind to zero 
						 * before calling getopt(), the behavior is unspecified.
						 * When an element of argv[] contains multiple option
						 * characters, it is unspecified how getopt()
						 * determines which options have already been processed.
						 *
						 * This API is can be utilized with the index() and
						 * set_index() methods implemented for Opt. */
						ind: std::ptr::addr_of_mut!(optind),
						opt: opt.to_string(), /* option itself */
					}))
				},
            }
        }
    }
}