//! The logic for applying the updates contained in a party.
use crate::account;
use crate::party::{self, SetOrKeep};
use crate::primitives::*;
use crate::sequence_event;

/// Compute the new value, given the original value and a [`SetOrKeep`] update.
/// If the update is `Keep`, return the original value.
/// If the value is `Set(new_value)`, return `new_value`.
pub fn set_or_keep<T>(original: T, update: SetOrKeep<T>) -> T {
    match update {
        SetOrKeep::Keep => original,
        SetOrKeep::Set(new_value) => new_value,
    }
}

/// Compute the update for the app state, by applying [`set_or_keep`] to each pair of values from
/// the original and the update:
/// ```rust
/// [
///     set_or_keep(original[0], update[0]),
///     set_or_keep(original[1], update[1]),
///     set_or_keep(original[2], update[2]),
///     set_or_keep(original[3], update[3]),
///     set_or_keep(original[4], update[4]),
///     set_or_keep(original[5], update[5]),
///     set_or_keep(original[6], update[6]),
///     set_or_keep(original[7], update[7]),
/// ]
/// ```
pub fn compute_app_state_update(original: [Fp; 8], update: [SetOrKeep<Fp>; 8]) -> [Fp; 8] {
    [
        set_or_keep(original[0], update[0]),
        set_or_keep(original[1], update[1]),
        set_or_keep(original[2], update[2]),
        set_or_keep(original[3], update[3]),
        set_or_keep(original[4], update[4]),
        set_or_keep(original[5], update[5]),
        set_or_keep(original[6], update[6]),
        set_or_keep(original[7], update[7]),
    ]
}

/// Update the `app_state` field of [`account::SnappAccount`] with the new value from the
/// [`party::PartyUpdate`].
///
/// Using [`compute_app_state_update`]:
/// ```rust
/// snapp_account.app_state = compute_app_state_update(snapp_account.app_state, update.app_state)
/// ```
pub fn apply_snapp_app_state_update<'a>(
    mut snapp_account: account::SnappAccount<'a>,
    update: &party::PartyUpdate,
) -> account::SnappAccount<'a> {
    snapp_account.app_state = compute_app_state_update(snapp_account.app_state, update.app_state);
    snapp_account
}

/// Returns true if any of the updates are [`SetOrKeep::Set`], false otherwise.
pub fn any_are_set<'a>(app_state_updates: &[SetOrKeep<Fp>; 8]) -> bool {
    for app_state_update in app_state_updates {
        match app_state_update {
            SetOrKeep::Set(_) => {
                return true;
            }
            SetOrKeep::Keep => (),
        }
    }
    return false;
}

/// Returns true if all of the updates are [`SetOrKeep::Set`], false otherwise.
pub fn all_are_set<'a>(app_state_updates: &[SetOrKeep<Fp>; 8]) -> bool {
    for app_state_update in app_state_updates {
        match app_state_update {
            SetOrKeep::Keep => {
                return false;
            }
            SetOrKeep::Set(_) => (),
        }
    }
    return true;
}

/// Update the `proved_state` field of [`account::SnappAccount`] with the new computed value.
///
/// * If the authorization is [`Signature`](`party::PartyAuthorization::Signature`) or
/// [`NoneGiven`](`party::PartyAuthorization::NoneGiven`), and if `any_are_set(update.app_state)`
///   is true, then set `snapp_account.proved_state` to `false`.
/// * If the authorization is [`Proof`](`party::PartyAuthorization::Proof`) and
///   `all_are_set(update.app_state)` is true, then set `snapp_account.proved_state` to `true`.
/// * Otherwise, leave `proved_state` unchanged.
pub fn apply_snapp_proved_state_update<'a>(
    mut snapp_account: account::SnappAccount<'a>,
    update: &party::PartyUpdate,
    authorization: &party::PartyAuthorization,
) -> account::SnappAccount<'a> {
    match authorization {
        party::PartyAuthorization::Proof(_) => {
            if all_are_set(&update.app_state) {
                snapp_account.proved_state = true
            }
        }
        party::PartyAuthorization::Signature(_) | party::PartyAuthorization::NoneGiven => {
            if any_are_set(&update.app_state) {
                snapp_account.proved_state = false
            }
        }
    }
    snapp_account
}

/// Update the `delegate` field of [`account::Account`] with the new value from the
/// [`party::PartyUpdate`].
///
/// Using [`set_or_keep`]:
/// ```rust
/// account.delegate = set_or_keep(account.delegate, update.delegate)
/// ```
pub fn apply_delegate_update<'a>(
    mut account: account::Account<'a>,
    update: &party::PartyUpdate,
) -> account::Account<'a> {
    account.delegate = set_or_keep(account.delegate, update.delegate);
    account
}

/// Update the `verification_key` field of [`account::SnappAccount`] with the new value from the
/// [`party::PartyUpdate`].
///
/// Using [`set_or_keep`]:
/// ```rust
/// snapp_account.verification_key =
///     set_or_keep(snapp_account.verification_key, update.verification_key)
/// ```
pub fn apply_verification_key_update<'a>(
    mut snapp_account: account::SnappAccount<'a>,
    update: &party::PartyUpdate,
) -> account::SnappAccount<'a> {
    snapp_account.verification_key = set_or_keep(
        snapp_account.verification_key.clone(),
        update.verification_key.clone(),
    );
    snapp_account
}

/// Update the `permissions` field of [`account::Account`] with the new value from the
/// [`party::PartyUpdate`].
///
/// Using [`set_or_keep`]:
/// ```rust
/// account.permissions = set_or_keep(account.permissions, update.permissions)
/// ```
pub fn apply_permissions_update<'a>(
    mut account: account::Account<'a>,
    update: &party::PartyUpdate,
) -> account::Account<'a> {
    account.permissions = set_or_keep(account.permissions, update.permissions);
    account
}

/// Convert a [`SetOrKeep<account::TimingInfo>`] in an [`account::AccountTiming::Timed`].
/// If the value is `Keep`, return `Keep`.
/// Otherwise, if the value is `Set(timing_info)`, return
/// `Set(account::AccountTiming::Timed(timing_info)`.
pub fn wrap_set_or_keep_timing_info(
    timing_info: SetOrKeep<account::TimingInfo>,
) -> SetOrKeep<account::AccountTiming> {
    match timing_info {
        SetOrKeep::Keep => SetOrKeep::Keep,
        SetOrKeep::Set(timing_info) => SetOrKeep::Set(account::AccountTiming::Timed(timing_info)),
    }
}

/// Update the `timing` field of [`account::Account`] with the new value from the
/// [`party::PartyUpdate`].
///
/// Using [`set_or_keep`] and [`wrap_set_or_keep_timing_info`]:
/// ```rust
/// account.timing = set_or_keep(account.timing, wrap_set_or_keep_timing_info(update.timing))
/// ```
pub fn apply_timing_update<'a>(
    mut account: account::Account<'a>,
    update: &party::PartyUpdate,
) -> account::Account<'a> {
    account.timing = set_or_keep(account.timing, wrap_set_or_keep_timing_info(update.timing));
    account
}

/// Update the `balance` field of [`account::Account`] by adding the `balance_change` from
/// [`party::PartyUpdate`] using [`party::wrapping_add_signed`].
/// ```rust
/// account.balance = party::wrapping_add_signed(account.balance, balance_change);
/// ```
pub fn apply_balance_change<'a>(
    mut account: account::Account<'a>,
    balance_change: party::SignedAmount,
) -> account::Account<'a> {
    account.balance = party::wrapping_add_signed(account.balance, balance_change);
    account
}

/// Update the `voting_for` field of [`account::Account`] with the new value from the
/// [`party::PartyUpdate`].
///
/// Using [`set_or_keep`]:
/// ```rust
/// account.voting_for = set_or_keep(account.voting_for, update.voting_for)
/// ```
pub fn apply_voting_for_update<'a>(
    mut account: account::Account<'a>,
    update: &party::PartyUpdate,
) -> account::Account<'a> {
    account.voting_for = set_or_keep(account.voting_for, update.voting_for);
    account
}

/// Update the `sequence_event` field of [`account::SnappAccount`] with the new sequence events at
/// the given global slot (since genesis).
///
/// This calls [`sequence_event::SequenceState::push_sequence_events`]:
/// ```rust
/// snapp.sequence_state = sequence_event::SequenceState::push_sequence_events(
///     snapp.sequence_state,
///     sequence_events,
///     global_slot,
/// )
/// ```
pub fn apply_sequence_event_update<'a>(
    mut snapp: account::SnappAccount<'a>,
    sequence_events: &sequence_event::SequenceEvents,
    global_slot: u32,
) -> account::SnappAccount<'a> {
    snapp.sequence_state = sequence_event::SequenceState::push_sequence_events(
        snapp.sequence_state,
        sequence_events,
        global_slot,
    );
    snapp
}

/// Update the `uri` field of [`account::SnappAccount`] with the new value from the
/// [`party::PartyUpdate`].
///
/// Using [`set_or_keep`]:
/// ```rust
/// snapp_account.uri = set_or_keep(snapp_account.uri, update.uri)
/// ```
pub fn apply_uri_update<'a>(
    mut snapp_account: account::SnappAccount<'a>,
    update: &party::PartyUpdate<'a>,
) -> account::SnappAccount<'a> {
    snapp_account.uri = set_or_keep(snapp_account.uri.clone(), update.snapp_uri);
    snapp_account
}

/// Update the `token_symbol` field of [`account::SnappAccount`] with the new value from the
/// [`party::PartyUpdate`].
///
/// Using [`set_or_keep`]:
/// ```rust
/// snapp_account.token_symbol = set_or_keep(snapp_account.token_symbol, update.token_symbol)
/// ```
pub fn apply_token_symbol_update<'a>(
    mut snapp_account: account::SnappAccount<'a>,
    update: &party::PartyUpdate<'a>,
) -> account::SnappAccount<'a> {
    snapp_account.token_symbol =
        set_or_keep(snapp_account.token_symbol.clone(), update.token_symbol);
    snapp_account
}

/// Update the [`account::SnappAccount`] with a [`party::PartyUpdate`] and a
/// [`sequence_event::SequenceEvents`].
///
/// This applies, in order:
/// * [`apply_snapp_app_state_update`]
/// * [`apply_snapp_proved_state_update`]
/// * [`apply_verification_key_update`]
/// * [`apply_sequence_event_update`]
/// * [`apply_uri_update`]
/// * [`apply_token_symbol_update`]
pub fn apply_snapp_update<'a>(
    mut snapp: account::SnappAccount<'a>,
    update: &party::PartyUpdate<'a>,
    authorization: &party::PartyAuthorization,
    sequence_events: &sequence_event::SequenceEvents,
    global_slot: u32,
) -> account::SnappAccount<'a> {
    snapp = apply_snapp_app_state_update(snapp, update);
    snapp = apply_snapp_proved_state_update(snapp, update, authorization);
    snapp = apply_verification_key_update(snapp, update);
    snapp = apply_sequence_event_update(snapp, sequence_events, global_slot);
    snapp = apply_uri_update(snapp, update);
    snapp
}

/// Update the `snapp` field of [`account::Account`] with a [`party::PartyUpdate`] and a
/// [`sequence_event::SequenceEvents`].
///
/// In order, this must
/// * get the `snapp` field of the account, or [`account::SnappAccount::empty`] if it is `None`
/// * apply [`apply_snapp_update`] to this value
/// * set the `snapp` field of the account to the result, or to `None` if
///   [`account::SnappAccount::is_empty`] is true.
pub fn apply_snapp_account_update<'a>(
    mut account: account::Account<'a>,
    update: &party::PartyUpdate<'a>,
    authorization: &party::PartyAuthorization,
    sequence_events: &sequence_event::SequenceEvents,
    global_slot: u32,
) -> account::Account<'a> {
    account.snapp = {
        let snapp = match account.snapp {
            Some(snapp) => snapp,
            None => account::SnappAccount::empty(),
        };
        let snapp = apply_snapp_update(snapp, update, authorization, sequence_events, global_slot);
        if account::SnappAccount::is_empty(&snapp) {
            None
        } else {
            Some(snapp)
        }
    };
    account
}

/// Increment the `nonce` field of [`account::Account`] if the `increment_nonce` argument is true;
/// otherwise, leave the account unchanged.
pub fn apply_nonce_update<'a>(
    mut account: account::Account<'a>,
    increment_nonce: bool,
) -> account::Account<'a> {
    if increment_nonce {
        account.nonce = account.nonce + 1
    }
    account
}

/// Update the [`account::Account`] with a [`party::PartyUpdate`] and a
/// [`sequence_event::SequenceEvents`].
///
/// This applies, in order:
/// * [`apply_timing_update`]
/// * [`apply_balance_change`]
/// * [`apply_snapp_account_update`]
/// * [`apply_delegate_update`]
/// * [`apply_nonce_update`]
/// * [`apply_voting_for_update`]
/// * [`apply_permissions_update`]
pub fn apply_update<'a>(
    mut account: account::Account<'a>,
    update: &party::PartyUpdate<'a>,
    authorization: &party::PartyAuthorization,
    sequence_events: &sequence_event::SequenceEvents,
    balance_change: party::SignedAmount,
    global_slot: u32,
    increment_nonce: bool,
) -> account::Account<'a> {
    account = apply_timing_update(account, update);
    account = apply_balance_change(account, balance_change);
    // TODO: Check timing, but not here..
    account =
        apply_snapp_account_update(account, update, authorization, sequence_events, global_slot);
    account = apply_delegate_update(account, update);
    account = apply_nonce_update(account, increment_nonce);
    account = apply_voting_for_update(account, update);
    // Finally, update permissions
    account = apply_permissions_update(account, update);
    account
}