/*
    wearechat - generic multiplayer game with voip
    Copyright (C) 2025 metamuffin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, version 3 of the License only.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
use crate::packets::{ReadWrite, Resource};
use anyhow::Result;
use redb::{Database, TableDefinition};
use sha2::{Digest, Sha256};
use std::{collections::HashMap, marker::PhantomData, path::Path, sync::Mutex};

const T_ENTRIES: TableDefinition<[u8; 32], &[u8]> = TableDefinition::new("e");

pub enum ResourceStore {
    Redb(Database),
    Memory(Mutex<HashMap<Resource, Vec<u8>>>),
}
impl ResourceStore {
    pub fn new_persistent(path: &Path) -> Result<Self> {
        Ok(Self::Redb(Database::create(path)?))
    }
    pub fn new_memory() -> Self {
        Self::Memory(HashMap::new().into())
    }
    pub fn get<T: ReadWrite>(&self, key: Resource<T>) -> Result<Option<T>> {
        self.get_raw(Resource(key.0, PhantomData))?
            .map(|b| T::read(&mut b.as_slice()))
            .transpose()
    }
    pub fn set<T: ReadWrite>(&self, value: &T) -> Result<Resource<T>> {
        Ok(Resource(self.set_raw(&value.write_alloc())?.0, PhantomData))
    }
    pub fn get_raw(&self, key: Resource) -> Result<Option<Vec<u8>>> {
        match self {
            ResourceStore::Redb(database) => {
                let txn = database.begin_read()?;
                let ent = txn.open_table(T_ENTRIES)?;
                match ent.get(key.0)? {
                    Some(x) => Ok(Some(x.value().to_vec())),
                    None => Ok(None),
                }
            }
            ResourceStore::Memory(map) => Ok(map.lock().unwrap().get(&key).map(|x| x.to_vec())),
        }
    }
    pub fn set_raw(&self, value: &[u8]) -> Result<Resource> {
        let key = Resource(sha256(value), PhantomData);
        match self {
            ResourceStore::Redb(database) => {
                let txn = database.begin_write()?;
                let mut ent = txn.open_table(T_ENTRIES)?;
                ent.insert(key.0, value)?;
                drop(ent);
                txn.commit()?;
            }
            ResourceStore::Memory(map) => {
                map.lock().unwrap().insert(key, value.to_vec());
            }
        }
        Ok(key)
    }
    pub fn iter(&self, mut cb: impl FnMut(&[u8])) -> Result<()> {
        match self {
            ResourceStore::Redb(_database) => todo!(),
            ResourceStore::Memory(mutex) => {
                mutex.lock().unwrap().values().for_each(|v| cb(v));
                Ok(())
            }
        }
    }
}

pub fn sha256(x: &[u8]) -> [u8; 32] {
    let mut hasher = Sha256::new();
    hasher.update(x);
    hasher.finalize().into()
}