use crate::MaxLengthString;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Status type
pub type Status = MaxLengthString<10>;

#[derive(Debug, Serialize, Deserialize)]
pub struct StatusManager {
    statuses: Vec<Status>,
    spendable: Vec<Status>,
    default_spendable: Status,
    reverted: Vec<Status>,
    withdrawable: Vec<Status>,
    transition: HashMap<Status, Vec<Status>>,
}

/// Status error object
#[derive(Debug, Serialize, thiserror::Error)]
pub enum Error {
    #[error("Unknown status: {0}")]
    UnknownStatus(String),

    #[error("Invalid transition from {0} to {1}")]
    InvalidTransition(Status, Status),
}

impl StatusManager {
    pub fn new_status(&self, status_name: &str) -> Result<Status, Error> {
        self.statuses
            .iter()
            .find(|status| *status == status_name)
            .cloned()
            .ok_or(Error::UnknownStatus(status_name.to_owned()))
    }

    pub fn spendables(&self) -> &[Status] {
        &self.spendable
    }

    pub fn default_spendable(&self) -> Status {
        self.default_spendable.clone()
    }

    /// Spendable statuses are the final state of a transaction that has finished as successfully
    /// therefore it is spendable.
    pub fn is_spendable(&self, status: &Status) -> bool {
        self.spendable.contains(status)
    }

    /// Reverted transactions are the final state of a transaction that has failed or cancelled and
    /// they inputs payments are reverted and spendedable.
    pub fn is_reverted(&self, status: &Status) -> bool {
        self.reverted.contains(status)
    }

    /// The transaction is final and cannot longer be updated
    pub fn is_final(&self, status: &Status) -> bool {
        self.is_spendable(status) || self.is_reverted(status)
    }

    /// Checks if the status transition is allowed
    pub fn is_valid_transition(&self, from: &Status, to: &Status) -> Result<(), Error> {
        if self.transition.get(from).map_or(false, |v| v.contains(to)) {
            Ok(())
        } else {
            Err(Error::InvalidTransition(from.clone(), to.clone()))
        }
    }
}

impl Default for StatusManager {
    fn default() -> Self {
        let pending: Status = "pending".into();
        let processing: Status = "processing".into();
        let cancelled: Status = "cancelled".into();
        let settled: Status = "settled".into();
        let failed: Status = "failed".into();

        Self {
            statuses: vec![
                pending.clone(),
                processing.clone(),
                cancelled.clone(),
                settled.clone(),
                failed.clone(),
            ],
            default_spendable: settled.clone(),
            spendable: vec![settled.clone()],
            reverted: vec![cancelled.clone(), failed.clone()],
            withdrawable: vec![settled.clone()],
            transition: {
                let mut map = HashMap::new();
                map.insert(
                    pending.clone(),
                    vec![processing.clone(), settled.clone(), cancelled.clone()],
                );
                map.insert(processing.clone(), vec![settled, failed]);
                map
            },
        }
    }
}