//! Validator and parser types.

#![allow(clippy::type_complexity)]
use std::ops::RangeInclusive;

/// A trait to create validator functions.
pub trait Validator {
    /// The output of the validator function.
    type Output;

    /// The error type returned from the validator function.
    type Error;

    /// Create a validator function from the given parameters.
    fn to_fn(&self) -> Box<dyn Fn(String) -> Result<Self::Output, Self::Error>>;
}

/// A PIN could not be validated from the given input.
#[derive(thiserror::Error, Debug)]
pub enum PinError {
    /// The provided PIN was too short.
    #[error("PIN too short: {0} < {1}")]
    TooShort(usize, usize),

    /// The provided PIN was too long.
    #[error("PIN too long: {0} > {1}")]
    TooLong(usize, usize),

    /// The PIN contained invalid characters.
    #[error("PIN contained invalid characters (found {0} at position {1})")]
    InvalidCharacters(char, usize),
}

/// Validate that a PIN is of a certain length and matches a range of characters.
#[derive(Default, Clone)]
pub struct PinValidator {
    /// The minimum length of provided PINs.
    pub min_length: Option<usize>,

    /// The maximum length of provided PINs.
    pub max_length: Option<usize>,

    /// The characters allowed by the PIN parser.
    pub range: Option<RangeInclusive<char>>,
}

impl Validator for PinValidator {
    type Output = String;
    type Error = PinError;

    fn to_fn(&self) -> Box<dyn Fn(String) -> Result<String, PinError>> {
        let min_len = self.min_length.unwrap_or(usize::MIN);
        let max_len = self.max_length.unwrap_or(usize::MAX);
        let range = self.range.clone().unwrap_or('0'..='9');
        Box::new(move |mut s: String| {
            s.truncate(s.trim_end().len());
            let len = s.len();
            if len < min_len {
                return Err(PinError::TooShort(len, min_len));
            }
            if len > max_len {
                return Err(PinError::TooLong(len, max_len));
            }
            for (index, ch) in s.chars().enumerate() {
                if !range.contains(&ch) {
                    return Err(PinError::InvalidCharacters(ch, index));
                }
            }
            Ok(s)
        })
    }
}

#[cfg(feature = "mnemonic")]
pub mod mnemonic {
    //! Validators for mnemonics.

    use std::{ops::Range, str::FromStr};

    use super::Validator;

    use keyfork_mnemonic_util::{Mnemonic, MnemonicFromStrError};

    /// A mnemonic could not be validated from the given input.
    #[derive(thiserror::Error, Debug)]
    pub enum MnemonicValidationError {
        /// The provided mnemonic had an unexpected word length.
        #[error("Invalid word length: {0} does not match {1:?}")]
        InvalidLength(usize, WordLength),

        /// A mnemonic could not be parsed from the given mnemonic.
        #[error("{0}")]
        MnemonicFromStrError(#[from] MnemonicFromStrError),
    }

    /// The mnemonic had an unexpected word length.
    #[derive(Clone, Debug)]
    pub enum WordLength {
        /// The bounds of a mnemonic.
        Range(Range<usize>),

        /// The exact count of words.
        Count(usize),
    }

    impl WordLength {
        fn matches(&self, word_count: usize) -> bool {
            match self {
                WordLength::Range(r) => r.contains(&word_count),
                WordLength::Count(c) => c == &word_count,
            }
        }
    }

    /// Validate a mnemonic of a range of word lengths or a specific length.
    #[derive(Default, Clone)]
    pub struct MnemonicValidator {
        /// The allowed word length of provided mnemonics.
        pub word_length: Option<WordLength>,
    }

    impl Validator for MnemonicValidator {
        type Output = Mnemonic;
        type Error = MnemonicValidationError;

        fn to_fn(&self) -> Box<dyn Fn(String) -> Result<Mnemonic, Self::Error>> {
            let word_length = self.word_length.clone();
            Box::new(move |s: String| match word_length.as_ref() {
                Some(wl) => {
                    let count = s.split_whitespace().count();
                    if !wl.matches(count) {
                        return Err(Self::Error::InvalidLength(count, wl.clone()));
                    }
                    let m = Mnemonic::from_str(&s)?;
                    Ok(m)
                }
                None => {
                    let m = Mnemonic::from_str(&s)?;
                    Ok(m)
                }
            })
        }
    }

    /// A mnemonic in the set of mnemonics could not be validated from the given inputs.
    #[derive(thiserror::Error, Debug)]
    pub enum MnemonicSetValidationError {
        /// The provided mnemonic did not have the correct amount of words.
        #[error("Invalid word length in set {0}: {1} != expected {2}")]
        InvalidSetLength(usize, usize, usize),

        /// A mnemonic could not be parsed from the provided mnemonics.
        #[error("Error parsing mnemonic set {0}: {1}")]
        MnemonicFromStrError(usize, MnemonicFromStrError),
    }

    /// Validate a set of mnemonics of a specific word length.
    #[derive(Clone)]
    pub struct MnemonicSetValidator<const N: usize> {
        /// The exact word lengths of all mnemonics. Unlike [`MnemonicValidator`], ranges of words
        /// are not allowed.
        pub word_lengths: [usize; N],
    }

    impl<const N: usize> Validator for MnemonicSetValidator<N> {
        type Output = [Mnemonic; N];
        type Error = MnemonicSetValidationError;

        fn to_fn(&self) -> Box<dyn Fn(String) -> Result<Self::Output, Self::Error>> {
            let word_lengths = self.word_lengths;
            Box::new(move |s: String| {
                let mut counter: usize = 0;
                let mut output = Vec::with_capacity(N);
                for (word_set, word_length) in word_lengths.into_iter().enumerate() {
                    let words = s
                        .split_whitespace()
                        .skip(counter)
                        .take(word_length)
                        .collect::<Vec<_>>();
                    if words.len() != word_length {
                        return Err(MnemonicSetValidationError::InvalidSetLength(
                            word_set,
                            words.len(),
                            word_length,
                        ));
                    }
                    let mnemonic = match Mnemonic::from_str(&words.join(" ")) {
                        Ok(m) => m,
                        Err(e) => return Err(Self::Error::MnemonicFromStrError(word_set, e)),
                    };
                    output.push(mnemonic);
                    counter += word_length;
                }

                Ok(output
                    .try_into()
                    .expect("vec with capacity of const N was not filled"))
            })
        }
    }
}