pub fn new(config: ArgonConfiguration) -> Self {

        let (sender, receiver) = flume::unbounded();

        let thread = HashingThread {

            receiver,

            algorithm: config.algorithm,

            params: config.params,

            blocks: Vec::default(),

            builder_template: Arc::default(),

        };

        let mut threads = Vec::with_capacity(config.hashers as usize);

        for _ in 0..config.hashers.max(1) {

            let thread = thread.clone();

            threads.push(

                std::thread::Builder::new()

                    .name(String::from("argon2"))

                    .spawn(move || thread.process_requests())

                    .unwrap(),

            );

        }

        Hasher { sender, threads }

    }

    pub fn hash(&self, id: u64, password: SensitiveString) -> Result<SensitiveString, Error> {

        let (result_sender, result_receiver) = flume::bounded(1);

        if self

            .sender

            .send(HashRequest {

                id,

                password,

                verify_against: None,

                result_sender,

            })

            .is_ok()

            match result_receiver.recv()?.map_err(Error::from) {

                Ok(HashResponse::Hash(hash)) => Ok(hash),

    }

    pub fn verify(

        &self,

        id: u64,

        password: SensitiveString,

        saved_hash: SensitiveString,

    ) -> Result<(), Error> {

        let (result_sender, result_receiver) = flume::bounded(1);

        if self

            .sender

            .send(HashRequest {

                id,

                password,

                verify_against: Some(saved_hash),

                result_sender,

            })

            .is_ok()

            match result_receiver.recv()?.map_err(Error::from) {

                Ok(_) => Ok(()),

    }

#[derive(Clone, Debug)]

    fn initialize_builder_template<R: Rng + CryptoRng>(

        &mut self,

        rng: &mut R,

    ) -> Result<ParamsBuilder, ArgonError> {

        match &self.params {

            ArgonParams::Timed(config) => {

                let mut params_builder = ParamsBuilder::new();

                let params = params_builder

                    .m_cost(config.ram_per_hasher / 1_024)

                    .p_cost(config.lanes)

                    .data(AssociatedData::new(&0_u64.to_be_bytes())?);

                let salt = SaltString::generate(rng);

                let mut salt_arr = [0u8; 64];

                let salt_bytes = salt.decode_b64(&mut salt_arr)?;

                let mut output = Vec::default();

                let minimum_duration = config.minimum_duration;

                let mut min_cost = 2; // OWASP sets the minimum iteration count at 2

                let mut total_spent_t = 0;

                let mut total_duration = Duration::ZERO;

                    let t_cost = if total_spent_t > 0 {

                        let average_duration_per_t = total_duration / total_spent_t;

                        u32::try_from(ceil_divide(

                            minimum_duration.as_nanos(),

                            average_duration_per_t.as_nanos(),

                        ))

                        .unwrap()

                        .max(min_cost)

                        min_cost

                    params.t_cost(t_cost);

                    let params = params.clone().build()?;

                    self.allocate_blocks(&params);

                    let output_len = params

                        .output_len()

                        .unwrap_or(argon2::Params::DEFAULT_OUTPUT_LEN);

                    output.resize(output_len, 0);

                    let start = Instant::now();

                    let argon = Argon2::new(self.algorithm, Version::V0x13, params);

                    argon.hash_password_into_with_memory(

                        b"hunter2",

                        salt_bytes,

                        &mut output[..],

                        &mut self.blocks,

                    )?;

                    let Some(elapsed) = Instant::now().checked_duration_since(start) else {

                    if elapsed < minimum_duration {

                        total_spent_t += t_cost;

                        total_duration += elapsed;

                        min_cost = t_cost + 1;

                    } else {

                        break;

                    }

                }

                Ok(params_builder)

    }

    fn process_requests(mut self) {

        let mut rng = thread_rng();

        while let Ok(request) = self.receiver.recv() {

            let result = if let Some(verify_against) = &request.verify_against {

                Self::verify(&request, verify_against)

                self.hash(&request, &mut rng)

            drop(request.result_sender.send(result));

    }

    fn verify(request: &HashRequest, hash: &str) -> Result<HashResponse, Error> {

        let hash = PasswordHash::new(hash)?;

        let algorithm = Algorithm::try_from(hash.algorithm)?;

        let version = hash

            .version

            .map(Version::try_from)

            .transpose()?

            .unwrap_or(Version::V0x13);

        let argon = Argon2::new(algorithm, version, argon2::Params::try_from(&hash)?);

        hash.verify_password(&[&argon], request.password.0.as_bytes())

            .map(|_| HashResponse::Verified)

            .map_err(Error::from)

    }

    fn hash<R: Rng + CryptoRng>(

        &mut self,

        request: &HashRequest,

        rng: &mut R,

    ) -> Result<HashResponse, Error> {

        let builder_template = self.builder_template.clone();

        let mut params =

            match builder_template.get_or_init(|| self.initialize_builder_template(rng)) {

                Ok(template) => template.clone(),

        params.data(AssociatedData::new(&request.id.to_be_bytes())?);

        let params = params.build()?;

        self.allocate_blocks(&params);

        let salt = SaltString::generate(rng);

        let mut salt_arr = [0u8; 64];

        let salt_bytes = salt.decode_b64(&mut salt_arr)?;

        let argon = Argon2::new(self.algorithm, Version::V0x13, params);

        let output_len = argon

            .params()

            .output_len()

            .unwrap_or(argon2::Params::DEFAULT_OUTPUT_LEN);

        let output = argon2::password_hash::Output::init_with(output_len, |out| {

            Ok(argon.hash_password_into_with_memory(

                request.password.as_bytes(),

                salt_bytes,

                out,

                &mut self.blocks,

            )?)

        })?;

                algorithm: self.algorithm.ident(),

                version: Some(Version::V0x13.into()),

                params: ParamsString::try_from(argon.params())?,

                salt: Some(salt.as_salt()),

                hash: Some(output),

            }

            .to_string(),

    }

    fn allocate_blocks(&mut self, params: &argon2::Params) {

        for _ in self.blocks.len()..params.block_count() {

            self.blocks.push(Block::default());

        }

    }

fn ceil_divide(dividend: u128, divisor: u128) -> u128 {

    match divisor {

            let rounding = divisor - 1;

            (dividend + rounding) / divisor

}

#[test]

fn basic_test() {

    use crate::config::SystemDefault;

    let hasher = Hasher::new(ArgonConfiguration::default());

    let password = SensitiveString(String::from("hunter2"));

    let hash = hasher.hash(1, password.clone()).unwrap();

    hasher.verify(1, password, hash).unwrap();

    let Hasher { sender, threads } = hasher;

    drop(sender);

    for thread in threads {

        thread.join().unwrap();

    }

}