use crate::{error::Result, users::User};
use indradb::{
    Datastore, EdgeKey, Identifier, MemoryDatastore, SpecificEdgeQuery, SpecificVertexQuery,
    Vertex, VertexPropertyQuery, VertexQuery, VertexQueryExt,
};

// Create an in-memory datastore

// Create a couple of vertices

pub struct Server<T>
where
    T: Datastore,
{
    pub datastore: T,
}

impl Server<MemoryDatastore> {
    pub fn memory() -> Self {
        Self {
            datastore: MemoryDatastore::default(),
        }
    }
}

impl<T: Datastore + Clone> Server<T> {
    pub fn create_user(&self, external_id: Option<String>) -> Result<User<T>> {
        let v = Vertex::new(Identifier::new("user")?);
        self.datastore.create_vertex(&v)?;
        self.datastore.set_vertex_properties(
            SpecificVertexQuery::single(v.id).property(Identifier::new("external_id")?),
            external_id.clone().into(),
        )?;

        Ok(User {
            id: v.id,
            external_id,
            datastore: self.datastore.clone(),
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_server() -> Result<()> {
        let server = Server::memory();

        let out_v = Vertex::new(Identifier::new("person")?);

        let in_v = Vertex::new(Identifier::new("movie")?);
        server.datastore.create_vertex(&out_v)?;
        server.datastore.create_vertex(&in_v)?;

        // Add an edge between the vertices
        let key = EdgeKey::new(out_v.id, Identifier::new("likes")?, in_v.id);
        server.datastore.create_edge(&key)?;

        // Query for the edge
        let e = server
            .datastore
            .get_edges(SpecificEdgeQuery::single(key.clone()).into())?;
        assert_eq!(e.len(), 1);
        assert_eq!(key, e[0].key);
        Ok(())
    }
}