//! Repository of entities.

use std::{io, marker::PhantomData, vec};

use rand::{seq::SliceRandom, thread_rng};
use uuid::Uuid;

pub use cursor::*;
pub use error::*;

use crate::{Entity, Serializer, storage, Storage};

mod cursor;
mod error;

/// Repository of entities, backed by provided storage.
///
/// See this [crate](../index.html) root documentation for more information.
///
/// # Example
///
/// ```
/// use dodo::prelude::*;
/// # use serde::{Deserialize, Serialize};
/// # use uuid::Uuid;
/// #
/// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
/// # #[serde(rename_all = "camelCase")]
/// # struct Person { id: Option<Uuid>, age: u64 }
/// #
/// # impl Person {
/// #    fn new() -> Self { Self { id : None, age : 42 } }
/// # }
///
/// type PersonRepository = Repository<Person, Directory, JsonSerializer>;
///
/// fn main() -> Result<(), Box<dyn std::error::Error>> {
/// #   let path  = tempfile::tempdir()?;
///     let directory = Directory::new(&path)?;
///     let mut repository = PersonRepository::new(directory);
///
///     let mut person = Person::new();
///     repository.insert(&mut person)?;
///
///     let entities = repository.find_all()?.collect()?;
///
///     println!("{:?}", entities);
///
///     Ok(())
/// }
/// ```
#[derive(Debug, Clone)]
pub struct Repository<T, S, R> {
    storage: S,
    _t: PhantomData<T>,
    _r: PhantomData<R>,
}

impl<T, S, R> Repository<T, S, R>
    where T: Entity,
          S: Storage,
          R: Serializer {
    /// Create a new repository, using provided storage.
    ///
    /// # Examples
    ///
    /// ```
    /// use dodo::prelude::*;
    /// # use serde::{Deserialize, Serialize};
    /// # use uuid::Uuid;
    /// #
    /// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
    /// # #[serde(rename_all = "camelCase")]
    /// # struct Person { id: Option<Uuid>, age: u64 }
    ///
    /// type PersonRepository = Repository<Person, Directory, JsonSerializer>;
    ///
    /// fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// #   let path  = tempfile::tempdir()?;
    ///     let directory = Directory::new(&path)?;
    ///     let repository = PersonRepository::new(directory);
    ///     Ok(())
    /// }
    /// ```
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _t: PhantomData,
            _r: PhantomData,
        }
    }

    /// Find an specific entity, if it exists.
    ///
    /// Returns an error if not found.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dodo::{prelude::*, storage::Memory};
    /// # use serde::{Deserialize, Serialize};
    /// # use uuid::Uuid;
    /// #
    /// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
    /// # #[serde(rename_all = "camelCase")]
    /// # struct Person { id: Option<Uuid>, age: u64 }
    /// # type PersonRepository = Repository<Person, Memory, JsonSerializer>;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// #     let repository = PersonRepository::new(Memory::new());
    /// #
    /// # let id = Uuid::parse_str("78190929-3d84-4735-9e40-80e3cd5530e9").unwrap();
    /// let person = repository.find(id);
    ///
    /// match person {
    ///     Ok(person) => println!("Found!"),
    ///     Err(dodo::Error::NotFound(_)) => println!("Not found!"),
    ///     Err(_) => println!("Other error!")
    /// }
    /// #
    /// #     Ok(())
    /// # }
    /// ```
    pub fn find(&self, id: Uuid) -> Result<T> {
        let reader = self.storage.read(id)?;
        R::deserialize(reader).map_err(From::from)
    }

    /// Provide a cursor iterating through the entities in this repository.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dodo::{prelude::*, storage::Memory};
    /// # use serde::{Deserialize, Serialize};
    /// # use uuid::Uuid;
    /// #
    /// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
    /// # #[serde(rename_all = "camelCase")]
    /// # struct Person { id: Option<Uuid>, age: u64 }
    /// #
    /// # type PersonRepository = Repository<Person, Memory, JsonSerializer>;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// #     let repository = PersonRepository::new(Memory::new());
    /// #
    /// let persons = repository.find_all()?.collect();
    ///
    /// println!("{:#?}", persons);
    /// #
    /// #     Ok(())
    /// # }
    /// ```
    pub fn find_all(&self) -> Result<RepositoryCursor<T, S, S::Iterator, R>> {
        RepositoryCursor::new(&self.storage)
    }

    /// Insert entity into this repository.
    ///
    /// The repository always assigns a new id to the entity, even if it already has one. Thus, the
    /// entity need to be mutable when inserted.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dodo::{prelude::*, storage::Memory};
    /// # use serde::{Deserialize, Serialize};
    /// # use uuid::Uuid;
    /// #
    /// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
    /// # #[serde(rename_all = "camelCase")]
    /// # struct Person { id: Option<Uuid>, age: u64 }
    /// #
    /// # impl Person {
    /// #    fn new() -> Self { Self { id : None, age : 42 } }
    /// # }
    /// #
    /// # type PersonRepository = Repository<Person, Memory, JsonSerializer>;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// #     let mut repository = PersonRepository::new(Memory::new());
    /// #
    /// let mut person = Person::new();  //Required to be mutable
    /// repository.insert(&mut person)?; //Assign new id to the entity.
    /// #
    /// #     Ok(())
    /// # }
    /// ```
    pub fn insert(&mut self, entity: &mut T) -> Result<()> {
        let (id, writer) = self.storage.new()?;
        let old_id = entity.id(); //Backup old id, in case anything goes wrong.
        entity.set_id(Some(id));
        match R::serialize(writer, entity) {
            Ok(_) => Ok(()),
            Err(e) => {
                entity.set_id(old_id); //Something did go wrong. Restore old id.
                Err(e.into())
            }
        }
    }

    /// Update entity in this repository to a new version.
    ///
    /// The entity must exist in the repository and have an id.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dodo::{prelude::*, storage::Memory};
    /// # use serde::{Deserialize, Serialize};
    /// # use uuid::Uuid;
    /// #
    /// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
    /// # #[serde(rename_all = "camelCase")]
    /// # struct Person { id: Option<Uuid>, age: u64 }
    /// #
    /// # impl Person {
    /// #    fn new() -> Self { Self { id : None, age : 42 } }
    /// # }
    /// #
    /// # type PersonRepository = Repository<Person, Memory, JsonSerializer>;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// #     let mut repository = PersonRepository::new(Memory::new());
    /// #
    /// let mut person = Person::new();
    /// repository.insert(&mut person)?;
    ///
    /// person.age = 1337;
    /// repository.update(&person)?;
    /// #
    /// #     Ok(())
    /// # }
    /// ```
    pub fn update(&mut self, entity: &T) -> Result<()> {
        let id = entity.id().ok_or(Error::Unidentified)?;
        let writer = self.storage.overwrite(id)?;
        R::serialize(writer, entity).map_err(From::from)
    }

    /// Update or insert entity into this repository.
    ///
    /// The entity is created if it doesn't exists, using the id currently assigned to it. You
    /// will receive an error if the entity doesn't have an id.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dodo::{prelude::*, storage::Memory};
    /// # use serde::{Deserialize, Serialize};
    /// # use uuid::Uuid;
    /// #
    /// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
    /// # #[serde(rename_all = "camelCase")]
    /// # struct Person { id: Option<Uuid>, age: u64 }
    /// #
    /// # impl Person {
    /// #    fn new() -> Self { Self { id : None,  age : 42 } }
    /// # }
    /// #
    /// # type PersonRepository = Repository<Person, Memory, JsonSerializer>;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// #     let mut repository = PersonRepository::new(Memory::new());
    /// #
    /// let mut person = Person::new();
    /// person.id = Some(Uuid::parse_str("78190929-3d84-4735-9e40-80e3cd5530e9").unwrap());
    /// repository.upsert(&mut person)?; //Doesn't exist ? No problem here!
    ///
    /// let mut person = Person::new();
    /// repository.insert(&mut person)?;
    /// person.age = 1337;
    /// repository.upsert(&mut person)?; //Already exist ? No problem too!
    /// #
    /// #     Ok(())
    /// # }
    /// ```
    pub fn upsert(&mut self, entity: &T) -> Result<()> {
        let id = entity.id().ok_or(Error::Unidentified)?;
        let writer = self.storage.write(id)?;
        R::serialize(writer, entity).map_err(From::from)
    }

    /// Delete entity with provided id.
    ///
    /// This does not fail if the entity doesn't exist.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dodo::{prelude::*, storage::Memory};
    /// # use serde::{Deserialize, Serialize};
    /// # use uuid::Uuid;
    /// #
    /// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
    /// # #[serde(rename_all = "camelCase")]
    /// # struct Person { id: Option<Uuid>, age: u64 }
    /// #
    /// # impl Person {
    /// #    fn new() -> Self { Self { id : None, age : 42 } }
    /// # }
    /// #
    /// # type PersonRepository = Repository<Person, Memory, JsonSerializer>;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// #     let mut repository = PersonRepository::new(Memory::new());
    /// #
    /// let mut person = Person::new();
    /// repository.insert(&mut person)?; //Inserted here.
    /// repository.delete(person.id.unwrap())?; //Deleted here.
    ///
    /// let id : Uuid = Uuid::parse_str("78190929-3d84-4735-9e40-80e3cd5530e9").unwrap();
    /// repository.delete(id)?; //Doesn't exist ? No problem!
    /// #
    /// #     Ok(())
    /// # }
    /// ```
    pub fn delete(&mut self, id: Uuid) -> Result<()> {
        self.storage.delete(id).map_err(From::from)
    }

    /// Delete every entity in this repository.
    ///
    /// Everything in this repository will be deleted. Use at your own risks.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dodo::{prelude::*, storage::Memory};
    /// # use serde::{Deserialize, Serialize};
    /// # use uuid::Uuid;
    /// #
    /// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
    /// # #[serde(rename_all = "camelCase")]
    /// # struct Person { id: Option<Uuid>, age: u64 }
    /// #
    /// # impl Person {
    /// #    fn new() -> Self { Self { id : None, age : 42 } }
    /// # }
    /// #
    /// # type PersonRepository = Repository<Person, Memory, JsonSerializer>;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// #     let mut repository = PersonRepository::new(Memory::new());
    /// #
    /// repository.insert(&mut Person::new())?;
    /// repository.insert(&mut Person::new())?;
    ///
    /// repository.clear();
    /// #
    /// #     Ok(())
    /// # }
    /// ```
    pub fn clear(&mut self) -> Result<()> {
        self.storage.clear().map_err(From::from)
    }
}

/// Repository cursor, yeilding all entities inside the repository.
///
/// # Example
///
/// ```
/// # use dodo::prelude::*;
/// # use serde::{Deserialize, Serialize};
/// # use uuid::Uuid;
/// #
/// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
/// # #[serde(rename_all = "camelCase")]
/// # struct Person { id: Option<Uuid>, age: u64 }
/// #
/// # impl Person {
/// #    fn new() -> Self { Self { id : None, age : 42 } }
/// # }
/// #
/// # type PersonRepository = Repository<Person, Directory, JsonSerializer>;
/// #
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// #   let path  = tempfile::tempdir()?;
/// #    let directory = Directory::new(&path)?;
/// #    let mut repository = PersonRepository::new(directory);
/// #
/// let entities = repository.find_all()?
///                          .filter(|person| person.age > 20)
///                          .skip(1)
///                          .take(3)?;
/// #
/// #     Ok(())
/// # }
/// ```
#[derive(Debug)]
pub struct RepositoryCursor<'a, T, S, I, R> {
    storage: &'a S,
    iterator: I,
    _t: PhantomData<T>,
    _r: PhantomData<R>,
}

impl<'a, T, S, R> RepositoryCursor<'a, T, S, S::Iterator, R>
    where T: Entity,
          S: Storage,
          R: Serializer {
    fn new(storage: &'a S) -> Result<Self> {
        let iterator = storage.iter()?;
        Ok(Self {
            storage,
            iterator,
            _t: PhantomData,
            _r: PhantomData,
        })
    }

    /// Shuffles the order the entities are yielded.
    ///
    /// Use this if you need to shuffle the entire repository contents. When done this early, this
    /// shuffles ids, not entities, so it is pretty lightweight. Nevertheless, this still has some
    /// serious performance implications, as this collects every id in the storage. With a small
    /// repository, this shouldn't be a problem, but with a large one, this will allocate a
    /// substantial amount of memory.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dodo::{prelude::*, storage::Memory};
    /// # use serde::{Deserialize, Serialize};
    /// # use uuid::Uuid;
    /// #
    /// # #[derive(Debug, Entity, Serialize, Deserialize, Eq, PartialEq)]
    /// # #[serde(rename_all = "camelCase")]
    /// # struct Person { id: Option<Uuid>, age: u64 }
    /// #
    /// # impl Person {
    /// #    fn new() -> Self { Self { id : None, age : 42 } }
    /// # }
    /// #
    /// # type PersonRepository = Repository<Person, Memory, JsonSerializer>;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// #     let mut repository = PersonRepository::new(Memory::new());
    /// #
    /// let mut person1 = Person::new();
    /// let mut person2 = Person::new();
    /// repository.insert(&mut person1)?;
    /// repository.insert(&mut person2)?;
    ///
    /// let persons : Vec<Person> = repository.find_all()?
    ///                                       .shuffled()
    ///                                       .collect()?;
    ///
    /// assert!(persons.contains(&person1), "Person1 should be in the results.");
    /// assert!(persons.contains(&person2), "Person2 should be in the results.");
    /// #
    /// #     Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn shuffled(self) -> RepositoryCursor<'a, T, S, vec::IntoIter<storage::Result<Uuid>>, R> {
        let Self { storage, iterator, .. } = self;

        let mut entries: Vec<storage::Result<Uuid>> = iterator.collect();
        entries.shuffle(&mut thread_rng());

        RepositoryCursor {
            iterator: entries.into_iter(),
            storage,
            _t: PhantomData,
            _r: PhantomData,
        }
    }
}

impl<'a, T, S, I, R> Cursor for RepositoryCursor<'a, T, S, I, R>
    where T: Entity,
          S: Storage,
          I: Iterator<Item=storage::Result<Uuid>>,
          R: Serializer {
    type Item = T;

    #[inline]
    fn next(&mut self) -> Result<Option<Self::Item>> {
        let Self { storage, iterator, .. } = self;

        //Map Storage Result to Repository Result.
        let into_result = |result: storage::Result<Uuid>| -> Result<Uuid> {
            result.map_err(From::from)
        };
        //Map Id to Reader.
        let into_reader = |result: Result<Uuid>| -> Result<S::Read> {
            result.and_then(|id| {
                storage.read(id).map_err(From::from)
            })
        };
        //Map Reader to Entity
        let into_entity = |result: Result<S::Read>| -> Result<Self::Item> {
            result.and_then(|reader| {
                R::deserialize(reader).map_err(From::from)
            })
        };
        //Repository might be modified while we are iterating over it. If an entry is deleted
        //before we have time to read it, we simply ignore it.
        let ignore_not_found = |result: &Result<Self::Item>| -> bool {
            match result {
                Err(Error::Io(e)) if e.kind() == io::ErrorKind::NotFound => false,
                _ => true
            }
        };

        iterator
            .next()
            .map(into_result)
            .map(into_reader)
            .map(into_entity)
            .filter(ignore_not_found)
            .transpose()
    }
}