//! An example to normalize an IRI from the CLI argument.

use iri_string::format::ToDedicatedString;
use iri_string::types::{RiStr, RiString};

const USAGE: &str = "\
USAGE:
    normalize [FLAGS] [--] IRI

FLAGS:
    -h, --help      Prints this help
    -i, --iri       Handle the input as an IRI (RFC 3987)
    -u, --uri       Handle the input as an URI (RFC 3986)
    -a, --ascii     Converts the output to an URI (RFC 3986)
    -w, --whatwg    Serialize normalization result according to WHATWG URL Standard.

ARGS:
    <IRI>           IRI
";

fn print_help() {
    eprintln!("{USAGE}");
}

fn help_and_exit() -> ! {
    print_help();
    std::process::exit(1);
}

fn die(msg: impl std::fmt::Display) -> ! {
    eprintln!("ERROR: {msg}");
    eprintln!();
    print_help();
    std::process::exit(1);
}

/// Syntax specification.
#[derive(Debug, Clone, Copy)]
enum Spec {
    /// RFC 3986 URI.
    Uri,
    /// RFC 3987 IRI.
    Iri,
}

impl Default for Spec {
    #[inline]
    fn default() -> Self {
        Self::Iri
    }
}

/// CLI options.
#[derive(Default, Debug, Clone)]
struct CliOpt {
    /// IRI.
    iri: String,
    /// Syntax spec.
    spec: Spec,
    /// Whether to convert output to ASCII URI or not.
    output_ascii: bool,
    /// Whether to serialize in WHATWG URL Standard way.
    whatwg_serialization: bool,
}

impl CliOpt {
    fn parse() -> Self {
        let mut args = std::env::args();
        // Skip `argv[0]`.
        args.next();

        let mut iri = None;
        let mut spec = None;
        let mut output_ascii = false;
        let mut whatwg_serialization = false;

        for arg in args.by_ref() {
            match arg.as_str() {
                "--ascii" | "-a" => output_ascii = true,
                "--iri" | "-i" => spec = Some(Spec::Iri),
                "--uri" | "-u" => spec = Some(Spec::Uri),
                "--whatwg" | "-w" => whatwg_serialization = true,
                "--help" | "-h" => help_and_exit(),
                opt if opt.starts_with('-') => die(format_args!("Unknown option: {opt}")),
                _ => {
                    if iri.replace(arg).is_some() {
                        die("IRI can be specified at most once");
                    }
                }
            }
        }

        for arg in args {
            if iri.replace(arg).is_some() {
                eprintln!("ERROR: IRI can be specified at most once");
            }
        }

        let iri = iri.unwrap_or_else(|| die("IRI should be specified"));
        let spec = spec.unwrap_or_default();
        Self {
            iri,
            spec,
            output_ascii,
            whatwg_serialization,
        }
    }
}

fn main() {
    let opt = CliOpt::parse();

    match opt.spec {
        Spec::Iri => process_iri(&opt),
        Spec::Uri => process_uri(&opt),
    }
}

fn process_iri(opt: &CliOpt) {
    let mut normalized = normalize::<iri_string::spec::IriSpec>(opt);
    if opt.output_ascii {
        normalized.encode_to_uri_inline();
    }
    println!("{normalized}");
}

fn process_uri(opt: &CliOpt) {
    let normalized = normalize::<iri_string::spec::UriSpec>(opt);
    println!("{normalized}");
}

fn normalize<S: iri_string::spec::Spec>(opt: &CliOpt) -> RiString<S> {
    let raw = &opt.iri.as_str();
    let iri = match RiStr::<S>::new(raw) {
        Ok(v) => v,
        Err(e) => die(format_args!("Failed to parse {raw:?}: {e:?}")),
    };
    let normalized = iri.normalize();
    if !opt.whatwg_serialization {
        if let Err(e) = normalized.ensure_rfc3986_normalizable() {
            die(format_args!("Failed to normalize: {e:?}"));
        }
    }
    normalized.to_dedicated_string()
}