//! Loose object store (spec §13.1): one file per object under

//! `objects/loose/<hh>/<rest>`, written atomically and verified on read.

//! Packs come later.

use crate::attest::Attest;

use crate::hash::{hash_object, header, ObjectRef, ObjectType};

use crate::identity::{Identity, Signature};

use crate::objects::{Change, ObjectError, StateObject};

use rand::RngCore;

use std::fs;

use std::io::{self, Write};

use std::path::{Path, PathBuf};

#[derive(Debug, thiserror::Error)]

pub enum StoreError {

    #[error("io: {0}")]

    Io(#[from] io::Error),

    #[error("corrupt object {0}: {1}")]

    Corrupt(ObjectRef, String),

    #[error("object {0}")]

    Object(#[from] ObjectError),

    #[error("object {0} is a {1}, expected {2}")]

    WrongType(ObjectRef, &'static str, &'static str),

    #[error("object {0} not found")]

    NotFound(ObjectRef),

}

pub type Result<T> = std::result::Result<T, StoreError>;

#[derive(Debug, Clone)]

pub struct Store {

    dir: PathBuf,

}

impl Store {

    pub fn open(dir: impl Into<PathBuf>) -> io::Result<Store> {

        let dir = dir.into();

        fs::create_dir_all(dir.join("loose"))?;

        Ok(Store { dir })

    }

    pub fn dir(&self) -> &Path {

        &self.dir

    }

    fn path_for(&self, r: &ObjectRef) -> PathBuf {

        let h = r.to_hex();

        self.dir.join("loose").join(&h[..2]).join(&h[2..])

    }

    pub fn has(&self, r: &ObjectRef) -> bool {

        self.path_for(r).is_file()

    }

    /// Store `body` as an object of type `ty`; idempotent.

    pub fn put(&self, ty: ObjectType, body: &[u8]) -> Result<ObjectRef> {

        let r = hash_object(ty, body);

        let path = self.path_for(&r);

        if path.is_file() {

            return Ok(r);

        }

        fs::create_dir_all(path.parent().unwrap())?;

        let mut nonce = [0u8; 8];

        rand::rngs::OsRng.fill_bytes(&mut nonce);

        let tmp = self.dir.join("loose").join(format!("tmp-{}", hex::encode(nonce)));

        {

            let mut f = fs::File::create(&tmp)?;

            f.write_all(&header(ty, body.len()))?;

            f.write_all(body)?;

            f.sync_all()?;

        }

        fs::rename(&tmp, &path)?;

        Ok(r)

    }

    /// Read and verify an object.

    pub fn get(&self, r: &ObjectRef) -> Result<(ObjectType, Vec<u8>)> {

        let path = self.path_for(r);

        let data = match fs::read(&path) {

            Ok(d) => d,

            Err(e) if e.kind() == io::ErrorKind::NotFound => return Err(StoreError::NotFound(*r)),

            Err(e) => return Err(e.into()),

        };

        let nul = data.iter().position(|&b| b == 0).ok_or_else(|| StoreError::Corrupt(*r, "no header".into()))?;

        let head = std::str::from_utf8(&data[..nul]).map_err(|_| StoreError::Corrupt(*r, "header not UTF-8".into()))?;

        let mut parts = head.split(' ');

        let (Some("oxy1"), Some(ty), Some(len), None) = (parts.next(), parts.next(), parts.next(), parts.next()) else {

            return Err(StoreError::Corrupt(*r, format!("bad header {head:?}")));

        };

        let ty = ObjectType::from_name(ty).ok_or_else(|| StoreError::Corrupt(*r, format!("unknown type {ty}")))?;

        let len: usize = len.parse().map_err(|_| StoreError::Corrupt(*r, "bad length".into()))?;

        let body = &data[nul + 1..];

        if body.len() != len {

            return Err(StoreError::Corrupt(*r, format!("length {} != header {len}", body.len())));

        }

        if hash_object(ty, body) != *r {

            return Err(StoreError::Corrupt(*r, "hash mismatch".into()));

        }

        Ok((ty, body.to_vec()))

    }

    pub fn get_typed(&self, r: &ObjectRef, want: ObjectType) -> Result<Vec<u8>> {

        let (ty, body) = self.get(r)?;

        if ty != want {

            return Err(StoreError::WrongType(*r, ty.name(), want.name()));

        }

        Ok(body)

    }

    pub fn put_change(&self, c: &Change) -> Result<ObjectRef> {

        self.put(ObjectType::Change, &c.encode())

    }

    pub fn get_change(&self, r: &ObjectRef) -> Result<Change> {

        Ok(Change::decode(&self.get_typed(r, ObjectType::Change)?)?)

    }

    pub fn put_chunk(&self, bytes: &[u8]) -> Result<ObjectRef> {

        self.put(ObjectType::Chunk, bytes)

    }

    pub fn put_state(&self, st: &StateObject) -> Result<ObjectRef> {

        self.put(ObjectType::State, &st.encode())

    }

    pub fn get_state(&self, r: &ObjectRef) -> Result<StateObject> {

        Ok(StateObject::decode(&self.get_typed(r, ObjectType::State)?)?)

    }

    pub fn put_attest(&self, a: &Attest) -> Result<ObjectRef> {

        self.put(ObjectType::Attest, &a.encode())

    }

    pub fn get_attest(&self, r: &ObjectRef) -> Result<Attest> {

        Ok(Attest::decode(&self.get_typed(r, ObjectType::Attest)?)?)

    }

    fn seal_index_path(&self, change: &ObjectRef) -> PathBuf {

        let h = change.to_hex();

        self.dir.join("seals").join(&h[..2]).join(&h[2..])

    }

    /// Record that seal attestation `attest` covers `change`.

    pub fn index_seal(&self, change: &ObjectRef, attest: &ObjectRef) -> Result<()> {

        let mut seals = self.seals_for(change)?;

        if seals.contains(attest) {

            return Ok(());

        }

        seals.push(*attest);

        seals.sort();

        let path = self.seal_index_path(change);

        fs::create_dir_all(path.parent().unwrap())?;

        let text: String = seals.iter().map(|s| format!("{}\n", s.to_hex())).collect();

        let tmp = path.with_extension("tmp");

        fs::write(&tmp, text)?;

        fs::rename(&tmp, &path)?;

        Ok(())

    }

    /// Seal attestations known to cover `change`.

    pub fn seals_for(&self, change: &ObjectRef) -> Result<Vec<ObjectRef>> {

        match fs::read_to_string(self.seal_index_path(change)) {

            Ok(t) => Ok(t.lines().filter_map(ObjectRef::from_hex).collect()),

            Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(vec![]),

            Err(e) => Err(e.into()),

        }

    }

    pub fn put_identity(&self, id: &Identity) -> Result<ObjectRef> {

        self.put(ObjectType::Identity, &id.encode())

    }

    pub fn get_identity(&self, r: &ObjectRef) -> Result<Identity> {

        Ok(Identity::decode(&self.get_typed(r, ObjectType::Identity)?)?)

    }

    fn sig_path(&self, r: &ObjectRef) -> PathBuf {

        let h = r.to_hex();

        self.dir.join("sigs").join(&h[..2]).join(&h[2..])

    }

    /// Signatures stored alongside object `r` (spec §5.4). Empty if none.

    pub fn signatures(&self, r: &ObjectRef) -> Result<Vec<Signature>> {

        match fs::read(self.sig_path(r)) {

            Ok(b) => Ok(Signature::decode_list(&b)?),

            Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(vec![]),

            Err(e) => Err(e.into()),

        }

    }

    /// Attach a signature to object `r`, replacing any earlier one by the same key.

    pub fn put_signature(&self, r: &ObjectRef, sig: &Signature) -> Result<()> {

        let mut sigs = self.signatures(r)?;

        sigs.retain(|s| s.key != sig.key);

        sigs.push(sig.clone());

        sigs.sort_by_key(|s| s.key);

        let path = self.sig_path(r);

        fs::create_dir_all(path.parent().unwrap())?;

        let mut nonce = [0u8; 8];

        rand::rngs::OsRng.fill_bytes(&mut nonce);

        let tmp = self.dir.join(format!("sigs-tmp-{}", hex::encode(nonce)));

        {

            let mut f = fs::File::create(&tmp)?;

            f.write_all(&Signature::encode_list(&sigs))?;

            f.sync_all()?;

        }

        fs::rename(&tmp, &path)?;

        Ok(())

    }

    /// Every object reference in the store (slow; for gc and tests).

    pub fn list(&self) -> io::Result<Vec<ObjectRef>> {

        let mut out = Vec::new();

        let loose = self.dir.join("loose");

        for d in fs::read_dir(&loose)? {

            let d = d?;

            if !d.file_type()?.is_dir() {

                continue;

            }

            let prefix = d.file_name().to_string_lossy().to_string();

            for f in fs::read_dir(d.path())? {

                let f = f?;

                let name = f.file_name().to_string_lossy().to_string();

                if let Some(r) = ObjectRef::from_hex(&format!("{prefix}{name}")) {

                    out.push(r);

                }

            }

        }

        out.sort();

        Ok(out)

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn put_get_verify() {

        let dir = tempfile::tempdir().unwrap();

        let s = Store::open(dir.path().join("objects")).unwrap();

        let r = s.put(ObjectType::Chunk, b"hello").unwrap();

        assert!(s.has(&r));

        assert_eq!(s.get(&r).unwrap(), (ObjectType::Chunk, b"hello".to_vec()));

        assert_eq!(s.put(ObjectType::Chunk, b"hello").unwrap(), r);

        assert_eq!(s.list().unwrap(), vec![r]);

        assert!(matches!(s.get_typed(&r, ObjectType::Blob), Err(StoreError::WrongType(..))));

        assert!(matches!(s.get(&ObjectRef([9; 32])), Err(StoreError::NotFound(_))));

        // Tamper: flip a byte, read must fail.

        let path = s.path_for(&r);

        let mut data = fs::read(&path).unwrap();

        let last = data.len() - 1;

        data[last] ^= 1;

        fs::write(&path, data).unwrap();

        assert!(matches!(s.get(&r), Err(StoreError::Corrupt(..))));

    }

    #[test]

    fn signatures_are_stored_beside_objects() {

        use crate::identity::{Domain, SecretKey};

        let dir = tempfile::tempdir().unwrap();

        let s = Store::open(dir.path()).unwrap();

        let r = s.put(ObjectType::Chunk, b"x").unwrap();

        assert!(s.signatures(&r).unwrap().is_empty());

        let sk = SecretKey { ed_seed: [1; 32], ml_seed: [2; 32] };

        let id = sk.identity("a", "b", 0);

        let key = s.put_identity(&id).unwrap();

        assert_eq!(s.get_identity(&key).unwrap(), id);

        let sig = sk.sign(Domain::Change, &key, &r);

        s.put_signature(&r, &sig).unwrap();

        s.put_signature(&r, &sig).unwrap();

        assert_eq!(s.signatures(&r).unwrap(), vec![sig]);

        // The object itself is untouched by its signatures.

        assert_eq!(s.get(&r).unwrap().1, b"x");

    }

    #[test]

    fn change_round_trip_through_store() {

        let dir = tempfile::tempdir().unwrap();

        let s = Store::open(dir.path()).unwrap();

        let c = crate::objects::tests::sample_change();

        let r = s.put_change(&c).unwrap();

        assert_eq!(r, c.hash());

        assert_eq!(s.get_change(&r).unwrap(), c);

    }

}