use ink_core::storage;
use ink_lang2 as ink;

#[ink::contract(version = "0.1.0")]
mod flipper {
    /// The storage of the flipper contract.
    #[ink(storage)]
    struct Flipper {
        /// The single `bool` value.
        value: storage::Value<bool>,
    }

    impl Flipper {
        /// Instantiates a new Flipper contract and initializes `value` to `init_value`.
        #[ink(constructor)]
        fn new(&mut self, init_value: bool) {
            self.value.set(init_value);
        }

        /// Instantiates a new Flipper contract and initializes `value` to `false` by default.
        #[ink(constructor)]
        fn default(&mut self) {
            self.new(false)
        }

        /// Flips `value` from `true` to `false` or vice versa.
        #[ink(message)]
        fn flip(&mut self) {
            *self.value = !self.get();
        }

        /// Returns the current state of `value`.
        #[ink(message)]
        fn get(&self) -> bool {
            *self.value
        }
    }

    /// As in normal Rust code we are able to define tests like below.
    ///
    /// Simply execute `cargo test` in order to test your contract.
    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn default_works() {
            // Note that `#[ink(constructor)]` functions that above have been
            // defined as `&mut self` can be used as normal Rust constructors
            // in test mode.
            let flipper = Flipper::default();
            assert_eq!(flipper.get(), false);
        }

        #[test]
        fn it_works() {
            let mut flipper = Flipper::new(false);
            assert_eq!(flipper.get(), false);
            flipper.flip();
            assert_eq!(flipper.get(), true);
        }
    }
}