use rpds::HashTrieMapSync;

use crate::ty::common::Symbol;
use crate::ty::internal::Value;

pub struct Env {
    last: Option<Box<Env>>,
    map: HashTrieMapSync<Symbol, Value>,
}

#[derive(Debug, Clone)]
pub struct LockedEnv {
    map: HashTrieMapSync<Symbol, Value>
}

impl Env {
    pub fn empty() -> Env {
        Env {
            last: None,
            map: HashTrieMapSync::new_sync(),
        }
    }

    pub fn lookup(&self, symbol: Symbol) -> Option<Value> {
        self.map.get(&symbol).cloned()
    }

    pub fn insert(&mut self, symbol: Symbol, value: Value) {
        self.map.insert_mut(symbol, value);
    }

    pub fn enter(&mut self, new: HashTrieMapSync<Symbol, Value>) {
        let mut map = self.map.clone();
        for (k, v) in new.iter() {
            map.insert_mut(k.clone(), v.clone());
        }
        let last = std::mem::replace(self, Env { last: None, map });
        self.last = Some(Box::new(last));
    }

    pub fn leave(&mut self) {
        let last = std::mem::replace(&mut self.last, None).unwrap();
        let _ = std::mem::replace(&mut self.last, last.last);
        self.map = last.map;
    }

    pub fn locked(&self) -> LockedEnv {
        LockedEnv { map: self.map.clone() }
    }
}

impl LockedEnv {
    pub fn lookup(&self, symbol: Symbol) -> Option<Value> {
        self.map.get(&symbol).cloned()
    }

    pub fn unlocked(self) -> Env {
        Env {
            map: self.map,
            last: None
        }
    }
}