//! # Persy - Transactional Persistence Engine
//!
//! Simple single file, durable, paginated, transactional, persistence engine, based on copy on write, write
//! ahead log, two phase commit.
//!
//! # Basic Example
//!
//! ```rust
//! # use persy::{Persy,PRes,Config};
//! # fn foo() -> PRes<()> {
//!     Persy::create("./open.persy")?;
//!     let persy = Persy::open("./open.persy",Config::new())?;
//!     let mut tx = persy.begin()?;
//!     persy.create_segment(&mut tx, "seg")?;
//!     let data = vec![1;20];
//!     persy.insert_record(&mut tx, "seg", &data)?;
//!     let prepared = persy.prepare_commit(tx)?;
//!     persy.commit(prepared)?;
//!     for x in persy.scan_records("seg")? {
//!         //....
//!     }
//! # Ok(())
//! # }
//! ```
//!
//!
extern crate byteorder;

mod allocator;
mod address;
mod transaction;
mod discref;
mod journal;
mod config;
mod segment;
mod persy;
use persy::PersyImpl;
use persy::RecordScanner;
use persy::TransactionFinalize;
use transaction::Transaction;
use persy::RecRef;
use std::sync::Arc;
pub use config::Config;
pub use persy::PRes;
pub use persy::PersyError;

#[derive(Clone)]
pub struct Persy {
    persy_impl: Arc<PersyImpl>,
}

impl Persy {
    /// Create a new database file.
    ///
    /// # Errors
    /// if the file already exist fail.
    ///
    pub fn create<P: Into<String>>(path: P) -> PRes<()> {
        PersyImpl::create(path)
    }

    /// Open a database file.
    ///
    /// The file should have been created with [`Persy::create`]
    ///
    ///
    /// # Errors
    ///
    /// if the file does not exist fail.
    ///
    /// [`Persy::create`]: struct.Persy.html#method.create
    pub fn open<P: Into<String>>(path: P, config: Config) -> PRes<Persy> {
        Ok(Persy { persy_impl: Arc::new(PersyImpl::open(path, config)?) })
    }


    /// Begin a new transaction.
    ///
    /// The isolation level is 'read_commited', for commit it call [`prepare_commit`] and
    /// [`commit`]
    ///
    /// [`prepare_commit`]:struct.Persy.html#method.prepare_commit
    /// [`commit`]:struct.Persy.html#method.commit
    pub fn begin(&self) -> PRes<Transaction> {
        self.persy_impl.begin()
    }


    pub fn create_segment(&self, tx: &mut Transaction, segment: &str) -> PRes<()> {
        self.persy_impl.create_segment(tx, segment)
    }

    pub fn drop_segment(&self, tx: &mut Transaction, segment: &str) -> PRes<()> {
        self.persy_impl.drop_segment(tx, segment)
    }

    pub fn exists_segment(&self, segment: &str) -> PRes<bool> {
        self.persy_impl.exists_segment(segment)
    }

    pub fn exists_segment_tx(&self, tx: &Transaction, segment: &str) -> PRes<bool> {
        self.persy_impl.exists_segment_tx(tx, segment)
    }

    /// create a new record
    ///
    /// This function return an id that can be used by [`read_record`] and [`read_record_tx`],
    /// the record content can be read only with the [`read_record_tx`] till the transacion is commited.
    ///
    /// [`read_record_tx`]:struct.Persy.html#method.read_record_tx
    /// [`read_record`]:struct.Persy.html#method.read_record
    ///
    pub fn insert_record(&self, tx: &mut Transaction, segment: &str, rec: &Vec<u8>) -> PRes<RecRef> {
        self.persy_impl.insert_record(tx, segment, rec)
    }

    /// Read the record content considering eventual in transaction changes.
    ///
    ///
    pub fn read_record_tx(&self, tx: &Transaction, segment: &str, rec_ref: &RecRef) -> PRes<Option<Vec<u8>>> {
        self.persy_impl.read_record_tx(tx, segment, rec_ref)
    }

    /// Read the record content from persistent data.
    ///
    ///
    pub fn read_record(&self, segment: &str, rec_ref: &RecRef) -> PRes<Option<Vec<u8>>> {
        self.persy_impl.read_record(segment, rec_ref)
    }

    /// Scan for persistent records
    ///
    ///
    pub fn scan_records(&self, segment: &str) -> PRes<RecordScanner> {
        self.persy_impl.scan_records(segment)
    }


    /// update the record content.
    ///
    ///
    /// This updated content can be read only with the [`read_record_tx`] till the transacion is commited.
    ///
    /// [`read_record_tx`]:struct.Persy.html#method.read_record_tx
    ///
    pub fn update_record(&self, tx: &mut Transaction, segment: &str, rec_ref: &RecRef, rec: &Vec<u8>) -> PRes<()> {
        self.persy_impl.update_record(tx, segment, rec_ref, rec)
    }


    /// delete a record.
    ///
    ///
    /// The record will result deleted only reading it whit [`read_record_tx`] till the transacion is commited.
    ///
    /// [`read_record_tx`]:struct.Persy.html#method.read_record_tx
    ///
    pub fn delete_record(&self, tx: &mut Transaction, segment: &str, rec_ref: &RecRef) -> PRes<()> {
        self.persy_impl.delete_record(tx, segment, rec_ref)
    }

    /// Rollback a not yet prepared transaction.
    ///
    pub fn rollback(&self, tx: Transaction) -> PRes<()> {
        self.persy_impl.rollback(tx)
    }


    /// Prepare to commit a transaction, it will lock all the records involved in the transaction
    /// till a [`commit`] or [`rollback_prepared`] is called.
    ///
    /// [`commit`]:struct.Persy.html#method.commit
    /// [`rollback_prepared`]:struct.Persy.html#method.prepare_commit
    pub fn prepare_commit(&self, tx: Transaction) -> PRes<TransactionFinalize> {
        self.persy_impl.prepare_commit(tx)
    }

    /// Rollback a prepared commit.
    ///
    ///
    pub fn rollback_prepared(&self, finalizer: TransactionFinalize) -> PRes<()> {
        self.persy_impl.rollback_prepared(finalizer)
    }


    /// Finalize the commit result of a prepared commit.
    ///
    pub fn commit(&self, finalizer: TransactionFinalize) -> PRes<()> {
        self.persy_impl.commit(finalizer)
    }
}