/*
	Copyright 2023-2024 Gabriel Bjørnager Jensen.

	This file is part of eAS.

	eAS is free software: you can redistribute it
	and/or modify it under the terms of the GNU
	General Public License as published by the Free
	Software Foundation, either version 3 of the
	License, or (at your option) any later version.

	eAS 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 Public License for more details.

	You should have received a copy of the GNU
	General Public License along with eAS. If not,
	see <https://www.gnu.org/licenses/>.
*/

use crate::app::App;
use crate::configuration::Configuration;
use crate::encoding::Encoding;
use crate::error::Error;
use crate::processor::Processor;
use crate::format::Format;

use std::env::args;
use std::str::FromStr;

struct ConfigurationTemporary {
	pub input:     Option<String>,
	pub output:    Option<String>,

	pub encoding:  Option<String>,
	pub processor: Option<String>,
	pub format:    Option<String>,
}

impl Configuration {
	pub fn from_arguments() -> Result<Self, Error> {
		if args().len() < 0x2 { return Err(Error::MissingInputFile) };

		let mut temporary = ConfigurationTemporary {
			input:     None,
			output:    None,

			encoding:  None,
			processor: None,
			format:    None,
		};

		for argument in args().skip(0x1) {
			// Skip the first, we assume that it's just the
			// executable invoked.

			if argument.is_empty() { continue };
			let argument: Vec<char> = argument.chars().collect();

			if argument[0x0] != '-' {
				// This argument is the input path.

				temporary.input = Some(argument.into_iter().collect());
				continue;
			}

			match argument.get(0x1) {
				Some('-') => handle_long_argument( &mut temporary, argument.into_iter().skip(0x2).collect())?,
				Some(_)   => handle_short_argument(&mut temporary, &argument[0x1..])?,

				_ => return Err(Error::MissingShortArgument),
			}
		}

		// Check if any of the mandatory parameters have
		// been set.
		if temporary.input.is_none()     { return Err(Error::MissingInputFile) };
		if temporary.processor.is_none() { return Err(Error::MissingTargetProcessor) };

		// The output path defaults to "a.out".
		// TODO: Do something better.
		if temporary.output.is_none() { temporary.output = Some(String::from("a.out")) };

		let processor = Processor::from_str(&temporary.processor.unwrap())?;

		let encoding = match temporary.encoding {
			Some(format) => Encoding::from_str(&format)?,
			_            => Encoding::default(),
		};

		let format = match temporary.format {
			Some(format) => Format::from_str(&format)?,
			_            => Format::default(),
		};

		return Ok(Self {
			input:  temporary.input.unwrap(),
			output: temporary.output.unwrap(),

			encoding,
			processor,
			format,
		});
	}
}

fn handle_short_argument(temporary: &mut ConfigurationTemporary, argument: &[char]) -> Result<(), Error> {
	macro_rules! use_remainder_as_value {
		($argument: expr, $index: expr) => {{
			let argument: &[char] = $argument;
			let index:    usize   = $index;

			let next_index = index + 0x1;

			if argument.len() <= next_index {
				// There are no more characters, and thus no values.
				let c = argument[index];
				Err(Error::MissingShortValue(c))
			} else {
				let value: String = argument[next_index..].iter().collect();
				Ok(value)
			}
		}};
	}

	for (index, c) in argument.iter().enumerate() {
		match c {
			'c' => { temporary.encoding  = Some(use_remainder_as_value!(&argument, index)?); break; },
			'f' => { temporary.format    = Some(use_remainder_as_value!(&argument, index)?); break; },
			'm' => { temporary.processor = Some(use_remainder_as_value!(&argument, index)?); break; },
			'o' => { temporary.output    = Some(use_remainder_as_value!(&argument, index)?); break; },

			'h' => App::print_help(),

			_ => return Err(Error::InvalidShortParameter(*c)),
		};
	}

	return Ok(());
}

fn handle_long_argument(_temporary: &mut ConfigurationTemporary, argument: String) -> Result<(), Error> {
	match argument.as_str() {
		"help"    => App::print_help(),
		"version" => App::print_version(),

		_ => return Err(Error::InvalidLongParameter(argument.to_string())),
	};

	return Ok(());
}