/// A trait to enable running some fuzz tests on a collection.

pub trait FuzzCollection {

    type Collection;

    type Item;

    /// Executes a series of operations on `self` in order to make it

    /// equal to `template`.

    fn equalize(&mut self, template: &Self::Collection);

    /// Takes a value from `self` and puts it into `item`.

    fn assign(&mut self, item: Self::Item);

}

/// Creates two fuzz tests. Both tests have the same flow:

///     - Take two instances of the collection, generated by our fuzzer

///     - Push `instance2` to storage, pull it out and assert that what

///       is pulled out is what was pushed.

///     - Do some mutations on the `pulled` object. Here the two tests

///       behave differently:

///

///         * `fuzz_ $id _mutate_some` Mutates some entries of the data

///           structure based on the content of `instance2`.

///

///         * `fuzz_ $id _mutate_all` Mutates the entire data structure,

///           so that it has the same content as `instance2`.

///

///     - Push the mutated `pulled` object into storage again, pull it

///       out as `pulled2` and assert that both objects are equal.

///     - Clear the object from storage and assert that storage was

///       cleared up properly, without any leftovers.

#[macro_export]

macro_rules! fuzz_storage {

    ($id:literal, $collection_type:ty) => {

        ::paste::paste! {

            /// Does some basic storage interaction tests whilst mutating

            /// *some* of the data structure's entries.

            #[allow(trivial_casts)]

            #[quickcheck]

            fn [< fuzz_ $id _mutate_some >] (

                instance1: $collection_type,

                mut instance2: $collection_type,

            ) {

                ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {

                    // we push the generated object into storage

                    let root_key = ink_primitives::Key::from([0x42; 32]);

                    let ptr = KeyPtr::from(root_key);

                    $crate::traits::push_spread_root(&instance1, &root_key.clone());

                    // we pull what's in storage and assert that this is what was just pushed

                    let mut pulled: $collection_type = $crate::traits::pull_spread_root(&root_key.clone());

                    assert_eq!(instance1, pulled);

                    // we iterate over what was pulled and call `assign` for all entries.

                    // this function may or may not modify elements of `pulled`.

                    pulled.iter_mut().for_each(|item| {

                        // this may leave some entries of `pulled` in `State::Preserved`.

                        // even though the instance which is supposed to be mutated is

                        // `pulled`, we still need to call this on a mutable `instance2`,

                        // since e.g. Vec does a `pop()` in assign, so that we don't always

                        // execute the same operation.

                        (&mut instance2).assign(item);

                    });

                    // we push the `pulled` object, on which we just executed mutations

                    // back into storage and asserts it can be pulled out intact again.

                    $crate::traits::push_spread_root(&pulled, &root_key.clone());

                    let pulled2: $collection_type = $crate::traits::pull_spread_root(&root_key.clone());

                    assert_eq!(pulled, pulled2);

                    // we clear the objects from storage and assert that everything was

                    // removed without any leftovers.

                    SpreadLayout::clear_spread(&pulled2, &mut ptr.clone());

                    SpreadLayout::clear_spread(&pulled, &mut ptr.clone());

                    $crate::test_utils::assert_storage_clean();

                    Ok(())

                })

                    .unwrap()

            }

            /// Does some basic storage interaction tests whilst mutating

            /// *all* the data structure's entries.

            #[allow(trivial_casts)]

            #[quickcheck]

            fn [< fuzz_ $id _mutate_all >] (

                instance1: $collection_type,

                instance2: $collection_type,

            ) {

                ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {

                    // we push the generated object into storage

                    let root_key = ink_primitives::Key::from([0x42; 32]);

                    let ptr = KeyPtr::from(root_key);

                    $crate::traits::push_spread_root(&instance1, &root_key.clone());

                    // we pull what's in storage and assert that this is what was just pushed

                    let mut pulled: $collection_type = $crate::traits::pull_spread_root(&root_key.clone());

                    assert_eq!(instance1, pulled);

                    // `pulled` is going to be equalized to `

                    (&mut pulled).equalize(&instance2);

                    // we push the `pulled` object, on which we just executed mutations

                    // back into storage and assert it can be pulled out intact again and

                    // is equal to `instance2`.

                    $crate::traits::push_spread_root(&pulled, &root_key.clone());

                    let pulled2: $collection_type = $crate::traits::pull_spread_root(&root_key.clone());

                    assert_eq!(pulled, pulled2);

                    assert_eq!(pulled2, instance2);

                    // we clear the objects from storage and assert that everything was

                    // removed without any leftovers.

                    SpreadLayout::clear_spread(&pulled2, &mut ptr.clone());

                    SpreadLayout::clear_spread(&pulled, &mut ptr.clone());

                    $crate::test_utils::assert_storage_clean();

                    Ok(())

                })

                    .unwrap()

            }

        }

    };

}

/// Asserts that the storage is empty, without any leftovers.

#[cfg(all(test, feature = "ink-fuzz-tests"))]

pub fn assert_storage_clean() {

    let contract_id = ink_env::test::callee::<ink_env::DefaultEnvironment>();

    let used_cells =

        ink_env::test::count_used_storage_cells::<ink_env::DefaultEnvironment>(

            &contract_id,

        )

        .expect("used cells must be returned");

    assert_eq!(used_cells, 0);

}

pub(crate) use self::optspec::{

    clear_spread_root_opt,

    pull_packed_root_opt,

    pull_spread_root_opt,

    push_packed_root_opt,

    push_spread_root_opt,

};

use super::{

    KeyPtr,

    PackedLayout,

    SpreadLayout,

};

pub fn pull_spread_root_opt<T>(root_key: &Key) -> Option<T>

where

    T: SpreadLayout,

{

    // In case the contract storage is occupied we handle

    // the Option<T> as if it was a T.

    ink_env::get_contract_storage::<()>(root_key)

        .ok()

        .flatten()

        .map(|_| super::pull_spread_root::<T>(root_key))

}

pub fn push_spread_root_opt<T>(entity: Option<&T>, root_key: &Key)

where

    T: SpreadLayout,

{

    match entity {

        Some(value) => {

            // Handle the Option<T> as if it was a T.

            //

            // Sadly this does not not work well with `Option<Option<T>>`.

            // For this we'd need specialization in Rust or similar.

            super::push_spread_root(value, root_key)

        }

        None => clear_spread_root_opt::<T, _>(root_key, || entity),

    }

}

pub fn clear_spread_root_opt<'a, T: 'a, F>(root_key: &Key, f: F)

where

    T: SpreadLayout,

    F: FnOnce() -> Option<&'a T>,

{

    // We can clean up some storage entity using its `SpreadLayout::clear_spread`

    // implementation or its defined storage footprint.

    //

    // While using its `SpreadLayout::clear_spread` implementation is more precise

    // and will only clean-up what is necessary it requires an actual instance.

    // Loading such an instance if it is not already in the memory cache of some

    // lazy abstraction will incur significant overhead.

    // Using its defined storage footprint this procedure can eagerly clean-up

    // the associated contract storage region, however, this might clean-up more

    // cells than needed.

    //

    // There are types that need a so-called "deep" clean-up. An example for this

    // is `storage::Box<storage::Box<T>>` where the outer storage box definitely

    // needs to propagate clearing signals onto its inner `storage::Box` in order

    // to properly clean-up the whole associate contract storage region.

    // This is when we cannot avoid loading the entity for the clean-up procedure.

    //

    // If the entity that shall be cleaned-up does not require deep clean-up we

    // check if its storage footprint exceeds a certain threshold and only then

    // we will still load it first in order to not clean-up too many unneeded

    // storage cells.

    let footprint = <T as SpreadLayout>::FOOTPRINT;

    if footprint >= super::FOOTPRINT_CLEANUP_THRESHOLD

        || <T as SpreadLayout>::REQUIRES_DEEP_CLEAN_UP

    {

        // We need to load the entity before we remove its associated contract storage

        // because it requires a deep clean-up which propagates clearing to its fields,

        // for example in the case of `T` being a `storage::Box`.

        if let Some(value) = f() {

            super::clear_spread_root(value, root_key);

            return

        }

    }

    // Clean-up eagerly without potentially loading the entity from storage:

    let mut ptr = KeyPtr::from(*root_key);

    for _ in 0..footprint {

        ink_env::clear_contract_storage(ptr.advance_by(1));

    }

}

pub fn push_packed_root_opt<T>(entity: Option<&T>, root_key: &Key)

where

    T: PackedLayout,

{

    match entity {

        Some(value) => {

            // Handle the Option<T> as if it was a T.

            //

            // Sadly this does not work well with `Option<Option<T>>`.

            // For this we'd need specialization in Rust or similar.

            super::push_packed_root(value, root_key);

        }

        None => {

            // Clear the associated storage cell since the entity is `None`.

            ink_env::clear_contract_storage(root_key);

        }

    }

}

            use crate::Pack;

            use crate::Pack;