// user.rs
use super::address::UserAddressArgs;
use super::address::UserAddressData;
use crate::error::UserStateError;

use ic_cdk::export::{candid::CandidType, serde::Deserialize};
use std::collections::hash_map::DefaultHasher;
use std::collections::HashMap;
use std::hash::{Hash, Hasher};

fn hash_password(password: &str) -> u64 {
    let mut hasher = DefaultHasher::new();
    password.hash(&mut hasher);

    hasher.finish()
}

#[derive(Debug, CandidType, Deserialize, Default, Clone)]
pub struct UserData {
    password: Option<u64>,
    pub name: String,
    pub email: String,
    pub balance: u128,
    pub addresses: Vec<UserAddressData>,
    pub settings: HashMap<String, UserDataSettingValue>,
}

impl UserData {
    // New values for the user data.
    pub fn new(user_args: UserDataArgs, address_args: UserAddressArgs) -> Self {
        let mut user_data = UserData::default();

        user_data.update(user_args);

        user_data.addresses = Vec::with_capacity(256);

        let name = if let Some(name) = address_args.name {
            name
        } else {
            "Account 0".to_string()
        };

        user_data
            .addresses
            .insert(0, UserAddressData::new(address_args.public_key, name));

        user_data
    }

    /// Updates the user's data based on the provided UserDataArgs struct.
    /// Only updates fields that are set to Some(value) in the options.
    pub fn update(&mut self, args: UserDataArgs) -> UserDataArgs {
        if let Some(name) = args.name {
            self.name = name;
        }

        if let Some(email) = args.email {
            self.email = email;
        }

        if let Some(balance) = args.balance {
            self.balance = balance;
        }

        if let Some(settings) = args.settings {
            for (key, value) in settings {
                self.settings.insert(key, value);
            }
        }

        if let Some(password) = args.password {
            self.password = Some(hash_password(&password));
        }

        UserDataArgs {
            name: Some(self.name.clone()),
            email: Some(self.email.clone()),
            balance: Some(self.balance),
            settings: Some(self.settings.clone()),
            password: None,
        }
    }

    /// Adds a new address for the user with the given key and address data.
    /// Returns an error if the key already exists.
    pub fn create_address(
        &mut self,
        args: UserAddressArgs,
    ) -> Result<UserAddressData, UserStateError> {
        let key = self.get_new_key()?;

        let public_key = args.public_key;

        let name = if let Some(name) = args.name {
            name
        } else {
            format!("Account {}", key)
        };

        let address_data = UserAddressData::new(public_key, name);

        self.addresses.insert(key, address_data.clone());

        Ok(address_data)
    }

    /// New derivation path based on the number of addresses created.
    /// Returns the derivation path as a vector of bytes.
    pub fn get_new_key(&self) -> Result<usize, UserStateError> {
        if self.addresses.len() > 255 {
            return Err(UserStateError::AddressLimitReached);
        }

        let key = self.addresses.len();

        Ok(key)
    }

    /// Retrieves the derivation path for the given key.
    /// Returns the derivation path as a vector of bytes.
    pub fn get_key_is_valid(&self, key: usize) -> Result<(), UserStateError> {
        if key > self.addresses.len() {
            return Err(UserStateError::InvalidAddressKey);
        }

        Ok(())
    }

    /// Retrieves an address by key for the user.
    /// Returns the address data if the key is found, or error if the key was not found.
    pub fn get_address(&self, key: usize) -> Result<UserAddressData, UserStateError> {
        self.get_key_is_valid(key)?;

        Ok(self.addresses[key].clone())
    }

    /// Retrieves a mutable reference to the address by key for the user.
    /// Returns the address data if the key is found, or error if the key was not found.
    pub fn get_address_mut(&mut self, key: usize) -> Result<&mut UserAddressData, UserStateError> {
        self.get_key_is_valid(key)?;

        Ok(&mut self.addresses[key])
    }

    /// Retrieves all the addresses created by the user.
    /// Returns a Vec of UserAddressData objects.
    pub fn get_addresses(&self) -> &Vec<UserAddressData> {
        &self.addresses
    }

    /// Sets the password for the user.
    pub fn set_password(&mut self, password: &str) -> Result<(), UserStateError> {
        let hashed_password = hash_password(password);

        self.password = Some(hashed_password);

        Ok(())
    }

    /// Checks if the provided password matches the user's password.
    pub fn check_password(&self, password: &str) -> Result<bool, UserStateError> {
        let input_hash = hash_password(password);

        if let Some(password_hash) = self.password {
            Ok(input_hash == password_hash)
        } else {
            Err(UserStateError::PasswordNotSet)
        }
    }

    /// Retrieves the user's setting.
    /// Returns the value if the key is found, or None if the key was not found.
    pub fn get_setting(&self, key: &str) -> Result<UserDataSettingValue, UserStateError> {
        if let Some(value) = self.settings.get(key) {
            Ok(value.clone())
        } else {
            Err(UserStateError::SettingNotFound)
        }
    }

    /// Retrieves a mutable reference to the user's setting.
    /// Returns the value if the key is found, or None if the key was not found.
    pub fn get_setting_mut(
        &mut self,
        key: &str,
    ) -> Result<&mut UserDataSettingValue, UserStateError> {
        if let Some(value) = self.settings.get_mut(key) {
            Ok(value)
        } else {
            Err(UserStateError::SettingNotFound)
        }
    }

    /// Retrieves a setting value by key for the user.
    /// Returns the value if the key is found, or None if the key was not found.
    pub fn get_settings(&self) -> &HashMap<String, UserDataSettingValue> {
        &self.settings
    }

    /// Sets a setting key-value pair for the user.
    pub fn set_setting(&mut self, key: String, value: UserDataSettingValue) -> () {
        let value = value.into();
        self.settings.insert(key, value);
    }

    /// Removes a setting key for the user.
    /// Returns the removed value if it existed, or None if the key was not found.
    pub fn remove_setting(&mut self, key: &str) -> Result<bool, UserStateError> {
        if self.settings.remove(key).is_some() {
            Ok(true)
        } else {
            Err(UserStateError::SettingNotFound)
        }
    }

    /// Updates all the settings for the user with the new settings.
    pub fn update_settings(&mut self, new_settings: HashMap<String, UserDataSettingValue>) {
        self.settings = new_settings;
    }
}

#[derive(CandidType, Deserialize, Default, Debug, Clone, PartialEq)]
pub struct UserDataArgs {
    pub name: Option<String>,
    pub email: Option<String>,
    pub balance: Option<u128>,
    pub password: Option<String>,
    pub settings: Option<HashMap<String, UserDataSettingValue>>,
}

#[derive(Debug, CandidType, Deserialize, Clone, PartialEq)]
pub enum UserDataSettingValue {
    StringValue(String),
    NumberValue(u128),
    FloatValue(f64),
    BoolValue(bool),
}

impl From<String> for UserDataSettingValue {
    fn from(value: String) -> Self {
        UserDataSettingValue::StringValue(value)
    }
}

impl From<f64> for UserDataSettingValue {
    fn from(value: f64) -> Self {
        UserDataSettingValue::FloatValue(value)
    }
}

impl From<u128> for UserDataSettingValue {
    fn from(value: u128) -> Self {
        UserDataSettingValue::NumberValue(value)
    }
}

impl From<bool> for UserDataSettingValue {
    fn from(value: bool) -> Self {
        UserDataSettingValue::BoolValue(value)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use proptest::prelude::*;

    proptest! {

        #[test]
        fn test_user_data_arbitrary( user_args: UserDataArgs,address_args: UserAddressArgs) {
            let user_data = UserData::new(user_args.clone(), address_args);

            assert_eq!(user_data.name, user_args.name.unwrap_or_default());
            assert_eq!(user_data.email, user_args.email.unwrap_or_default());
            assert_eq!(user_data.balance, user_args.balance.unwrap_or_default());
        }

        #[test]
        fn test_create_address(address_args: UserAddressArgs, address_args2: UserAddressArgs) {
            let args = UserDataArgs {
                name: Some("test".to_string()),
                email: Some("test@example.com".to_string()),
                balance: Some(0),
                password: Some("password".to_string()),
                settings: None,
            };

            let mut user_data = UserData::new(args, address_args);

            let address_data = user_data.create_address(address_args2.clone()).unwrap();

            assert_eq!(address_data.public_key, address_args2.public_key);
        }

        #[test]
        fn test_get_address(user_args: UserDataArgs, address_args: UserAddressArgs, name: String) {
            let mut user_data = UserData::new(user_args, address_args.clone());

            let address_data = user_data.get_address(0).unwrap();

            assert_eq!(address_data.public_key, address_args.public_key);

            let mut address_data2 = user_data.get_address_mut(0).unwrap();

            address_data2.name = name.clone();

            assert_eq!(user_data.get_address(0).unwrap().name, name);
        }

        #[test]
        fn test_update_address(user_args: UserDataArgs, address_args: UserAddressArgs, name: String) {
            let mut user_data = UserData::new(user_args, address_args.clone());

            let mut address_data = user_data.get_address_mut(0).unwrap();

            address_data.name = name.clone();

            assert_eq!(user_data.get_address(0).unwrap().name, name);
        }

        #[test]
        fn test_update_settings(user_args: UserDataArgs, address_args: UserAddressArgs, name: String) {
            let mut user_data = UserData::new(user_args, address_args.clone());

            let mut settings = HashMap::new();
            settings.insert("name".to_string(), name.clone().into());

            user_data.update_settings(settings);

            assert_eq!(user_data.settings.get("name").unwrap(), &name.into());
        }

        #[test]
        fn test_update_password(user_args: UserDataArgs, address_args: UserAddressArgs, password: String) {
            let mut user_data = UserData::new(user_args, address_args.clone());

            user_data.set_password(&password.clone()).unwrap();


            assert!(user_data.check_password(&password).unwrap());
        }

        #[test]
        fn test_update_email(user_args: UserDataArgs, address_args: UserAddressArgs, email: String) {
            let mut user_data = UserData::new(user_args, address_args.clone());

            user_data.email = email.clone();

            assert_eq!(user_data.email, email);
        }

        #[test]
        fn test_update_name(user_args: UserDataArgs, address_args: UserAddressArgs, name: String) {
            let mut user_data = UserData::new(user_args, address_args.clone());

            user_data.name = name.clone();

            assert_eq!(user_data.name, name);
        }

        #[test]
        fn test_update_balance(user_args: UserDataArgs, address_args: UserAddressArgs, balance: u128) {
            let mut user_data = UserData::new(user_args, address_args.clone());

            user_data.balance = balance;

            assert_eq!(user_data.balance, balance);
        }

    }
}