//! Merkle tree test implementation
//!
//! # Usage
//!
//! Add this to your `Cargo.toml`
//!
//! ```toml
//! [dependencies]
//! merkle_test = "0.1"
//! ```
//!
//! ```rust
//! extern crate merkle_test;
//! use merkle_test::MerkleTree;
//! use merkle_test::crypto_reexport::sha2::Sha256;
//!
//! fn main() {
//!     let hashes: Vec<Vec<u8>> = vec![];
//!     let mut tree = MerkleTree::new(Sha256::new()); // use Sha256
//!     hashes.iter().for_each(|hash| tree.add_hash(hash.to_vec())); // add hashes to tree
//!
//!     let root = tree.root(); // calculate merkle root
//!     println!("Merkle root: {:?}", root);
//! }
//! ```
//!

extern crate crypto;

use crypto::digest::Digest;

mod error;
pub use error::MerkleTreeError;

type Hash = Vec<u8>;
type Round = Vec<Hash>;

/// Mercle tree implementation
pub struct MerkleTree<D: Digest> {
    digest: D,
    state: Vec<Hash>,
}
impl<D: Digest> MerkleTree<D> {
    /// Consructs new MerkleTree with specific [Digest](https://docs.rs/rust-crypto/0.2.36/crypto/digest/trait.Digest.html)
    pub fn new(digest: D) -> MerkleTree<D> {
        let state = Vec::new();
        MerkleTree { digest, state }
    }
    /// Add hash to tree (hash must be impl `Into<Vec<u8>>`)
    pub fn add_hash<H: Into<Hash>>(&mut self, hash: H) {
        self.state.push(hash.into());
    }
    /// Calulates root hash of tree state
    pub fn root(&mut self) -> Result<Hash, MerkleTreeError> {
        if self.state.len() < 2 {
            return Err(MerkleTreeError::NotEnoughHashes)
        }

        let mut current_round = self.state.clone() as Round;
        loop {
            current_round = self.round(current_round);
            if current_round.len() == 1 {
                return Ok(current_round[0].clone());
            }
        }
    }
    /// Calculate tree round
    fn round(&mut self, prev_round: Round) -> Round {
        prev_round
            .chunks(2)
            .map(|chunk| if chunk.len() == 2 {
                self.digest.input(&chunk[0]);
                self.digest.input(&chunk[1]);
                let mut pair_hash = vec![0; self.digest.output_bytes()];
                self.digest.result(&mut pair_hash);
                self.digest.reset();
                pair_hash
            } else {
                chunk[0].clone()
            })
            .collect()
    }
}

pub mod crypto_reexport {
    pub use crypto::*;
}