//! This module contains the [Bijection] type.

use super::HashMapWithDefault;
use log::error;
use std::{borrow::Borrow, hash::Hash};

pub struct Bijection<K, V> {
    k2v: HashMapWithDefault<K, V>,
    v2k: HashMapWithDefault<V, K>,
}

impl<K, V> Bijection<K, V> {
    pub fn new(default_key: K, default_value: V) -> Self {
        let k2v = HashMapWithDefault::new(default_value);
        let v2k = HashMapWithDefault::new(default_key);
        Self { k2v, v2k }
    }

    pub fn k2v(&self) -> &HashMapWithDefault<K, V> {
        &self.k2v
    }

    pub fn v2k(&self) -> &HashMapWithDefault<V, K> {
        &self.v2k
    }
}

impl<K: Clone + Hash + Eq, V: Clone + Hash + Eq> Bijection<K, V> {
    pub fn insert(&mut self, key: K, value: V) -> Option<(K, V)> {
        let key_clone = key.clone();
        let value_clone = value.clone();
        let old_value = self.k2v.get_mut().insert(key, value);
        let old_key = self.v2k.get_mut().insert(value_clone, key_clone);
        match (old_key, old_value) {
            (Some(old_key), Some(old_value)) => Some((old_key, old_value)),
            (None, None) => None,
            _ => {
                error!("logic error: unmatched key-value pair encountered in bijection insert");
                None
            }
        }
    }
}

impl<K: Hash + Eq, V> Bijection<K, V> {
    pub fn value<Q: ?Sized + Hash + Eq>(&self, key: &Q) -> &V
    where
        K: Borrow<Q>,
    {
        self.k2v.get(key)
    }
}

impl<K, V: Hash + Eq> Bijection<K, V> {
    pub fn key<R: ?Sized + Hash + Eq>(&self, value: &R) -> &K
    where
        V: Borrow<R>,
    {
        self.v2k.get(value)
    }
}