#[macro_use]
extern crate log;
extern crate chrono;
#[macro_use]
extern crate bitflags;

extern crate sanakirja;
extern crate byteorder;
extern crate flate2;
extern crate ring;
extern crate untrusted;
extern crate libc;
extern crate rand;
extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate bincode;
extern crate hex;
extern crate base64;
extern crate tempdir;
#[macro_use]
extern crate error_chain;

use std::path::Path;
use std::collections::HashSet;
use base64::URL_SAFE_NO_PAD;
use std::io::Write;
use std::path::PathBuf;
pub use sanakirja::Transaction;

error_chain! {
    foreign_links {
        IO(std::io::Error);
        Sanakirja(sanakirja::Error);
        Bincode(bincode::Error);
        Utf8(std::str::Utf8Error);
        Ring(ring::error::Unspecified);
    }
    errors {
        AlreadyAdded {}
        FileNotInRepo(path: PathBuf) {}
        NoDb(root: backend::Root) {}
        WrongHash {}
        WrongPatchSignature {}
        BranchNameAlreadyExists {}
    }
}

impl Error {
    pub fn lacks_space(&self) -> bool {
        match self.0 {
            ErrorKind::Sanakirja(sanakirja::Error::NotEnoughSpace) => true,
            _ => false
        }
    }
}

#[macro_use]
mod backend;
pub mod fs_representation;
mod file_operations;

pub mod signature;
pub mod patch;
mod conflict;
pub mod graph;
mod optimal_diff;
mod record;
mod apply;
mod output;
mod unrecord;

pub use backend::{DEFAULT_BRANCH, Repository, MutTxn, LineId, PatchId, FOLDER_EDGE, PARENT_EDGE,
                  DELETED_EDGE, PSEUDO_EDGE, EdgeFlags, Hash, HashRef, Key, Edge, Txn, Branch,
                  Inode, ROOT_INODE, ROOT_KEY, SmallString, SmallStr, ApplyTimestamp};

pub use record::InodeUpdate;
pub use patch::{Patch, PatchHeader};
pub use sanakirja::value::Value;
pub use signature::KeyPair;
use fs_representation::ID_LENGTH;
use std::io::Read;
use rand::Rng;

impl<'env, T: rand::Rng> backend::MutTxn<'env, T> {
    pub fn output_changes_file<P: AsRef<Path>>(&mut self,
                                               branch: &Branch,
                                               path: P)
                                               -> Result<()> {
        let changes_file = fs_representation::branch_changes_file(path.as_ref(),
                                                                  branch.name.as_str());
        let mut branch_id: Vec<u8> = vec![b'\n'; ID_LENGTH + 1];
        {
            if let Ok(mut file) = std::fs::File::open(&changes_file) {
                file.read_exact(&mut branch_id)?;
            }
        }
        let mut branch_id = if let Ok(s) = String::from_utf8(branch_id) {
            s
        } else {
            "\n".to_string()
        };
        if branch_id.as_bytes()[0] == b'\n' {
            branch_id.truncate(0);
            let mut rng = rand::thread_rng();
            branch_id.extend(rng.gen_ascii_chars().take(ID_LENGTH));
            branch_id.push('\n');
        }

        let mut file = std::fs::File::create(&changes_file)?;
        file.write_all(&branch_id.as_bytes())?;
        for (s, hash) in self.iter_applied(&branch, None) {
            let hash_ext = self.get_external(hash).unwrap();
            writeln!(file, "{}:{}", hash_ext.to_base64(URL_SAFE_NO_PAD), s)?
        }
        Ok(())
    }

    pub fn branch_patches(&mut self, branch: &Branch) -> HashSet<(backend::Hash, ApplyTimestamp)> {
        self.iter_patches(branch, None)
            .map(|(patch, time)| (self.external_hash(patch).to_owned(), time))
            .collect()
    }

    pub fn fork(&mut self, branch: &Branch, new_name: &str) -> Result<Branch> {
        if branch.name.as_str() == new_name {
            Err(ErrorKind::BranchNameAlreadyExists.into())
        } else {
            Ok(Branch {
                   db: self.txn.fork(&mut self.rng, &branch.db)?,
                   patches: self.txn.fork(&mut self.rng, &branch.patches)?,
                   revpatches: self.txn.fork(&mut self.rng, &branch.revpatches)?,
                   name: SmallString::from_str(new_name),
                   apply_counter: 0,
               })
        }
    }
    pub fn add_file<P: AsRef<Path>>(&mut self, path: P, is_dir: bool) -> Result<()> {
        self.add_inode(None, path.as_ref(), is_dir)
    }


    fn file_nodes_fold_<A, F: FnMut(A, &Key<PatchId>) -> A>(&self,
                                                            branch: &Branch,
                                                            root: &Key<PatchId>,
                                                            level: usize,
                                                            mut init: A,
                                                            f: &mut F)
                                                            -> Result<A> {

        for (k, v) in self.iter_nodes(&branch, Some((root, None)))
            .take_while(|&(k, v)| k == root && v.flag.contains(FOLDER_EDGE)
                        && !v.flag.contains(PARENT_EDGE)) {

                debug!("file_nodes_fold_: {:?} {:?}", k, v);
                if level & 1 == 0 && level > 0 {
                    init = f(init, k)
                }
                init = self.file_nodes_fold_(branch, &v.dest, level + 1, init, f)?

            }
        Ok(init)
    }

    pub fn file_nodes_fold<A, F: FnMut(A, &Key<PatchId>) -> A>(&self,
                                                               branch: &Branch,
                                                               init: A,
                                                               mut f: F)
                                                               -> Result<A> {

        self.file_nodes_fold_(branch, &ROOT_KEY, 0, init, &mut f)

    }

}

impl<T: Transaction, R> backend::T<T, R> {
    /// Tells whether a `key` is alive in `branch`, i.e. is either the
    /// root, or has at least one alive edge pointing to it.
    fn is_alive(&self, branch: &Branch, key: &Key<PatchId>) -> bool {
        *key == ROOT_KEY || self.has_edge(branch, &key, PARENT_EDGE, false) ||
        self.has_edge(branch, &key, PARENT_EDGE | FOLDER_EDGE, false)
    }

    /// Test whether `key` has a neighbor with flag `flag0`. If
    /// `include_pseudo`, this includes pseudo-neighbors.
    pub fn has_edge(&self,
                    branch: &Branch,
                    key: &Key<PatchId>,
                    flag: EdgeFlags,
                    include_pseudo: bool)
                    -> bool {

        let e = Edge::zero(flag);
        if let Some((k, v)) = self.iter_nodes(&branch, Some((key, Some(&e)))).next() {
            if include_pseudo {
                k == key && (v.flag <= flag | PSEUDO_EDGE)
            } else {
                k == key && v.flag == flag
            }
        } else {
            false
        }
    }
}

fn make_remote<'a, I: Iterator<Item = &'a Hash>>
    (target: &Path,
     remote: I)
     -> Result<(Vec<(Hash, Patch)>, usize)> {
    use fs_representation::*;
    use std::io::BufReader;
    use std::fs::File;
    let mut patches = Vec::new();
    let mut patches_dir = patches_dir(target).to_path_buf();
    let mut size_increase = 0;

    for h in remote {

        patches_dir.push(&patch_file_name(h.as_ref()));

        debug!("opening {:?}", patches_dir);
        let file = try!(File::open(&patches_dir));
        let mut file = BufReader::new(file);
        let (h, _, patch) = Patch::from_reader_compressed(&mut file)?;

        size_increase += patch.size_upper_bound();
        patches.push((h.clone(), patch));

        patches_dir.pop();

    }
    Ok((patches, size_increase))
}

/// Apply a number of patches, guessing the new repository size.  If
/// this fails, the repository size is guaranteed to have been
/// increased by at least some pages, and it is safe to call this
/// function again.
///
/// Also, this function takes a file lock on the repository.
pub fn apply_resize<'a, I: Iterator<Item = &'a Hash>>(target: &Path,
                                                      branch_name: &str,
                                                      remote: I)
                                                      -> Result<()> {
    use fs_representation::*;
    let (patches, size_increase) = make_remote(target, remote)?;
    info!("applying patches with size_increase {:?}", size_increase);
    let pristine_dir = pristine_dir(target).to_path_buf();
    let repo = try!(Repository::open(pristine_dir, Some(size_increase as u64)));
    let mut txn = try!(repo.mut_txn_begin(rand::thread_rng()));
    try!(txn.apply_patches(branch_name, target, &patches));
    try!(txn.commit());
    Ok(())
}

/// Apply a number of patches, guessing the new repository size.  If
/// this fails, the repository size is guaranteed to have been
/// increased by at least some pages, and it is safe to call this
/// function again.
///
/// Also, this function takes a file lock on the repository.
pub fn apply_resize_no_output<'a, I: Iterator<Item = &'a Hash>>(target: &Path,
                                                                branch_name: &str,
                                                                remote: I)
                                                                -> Result<()> {
    use fs_representation::*;
    let (patches, size_increase) = make_remote(target, remote)?;
    let pristine_dir = pristine_dir(target).to_path_buf();
    let repo = try!(Repository::open(pristine_dir, Some(size_increase as u64)));
    let mut txn = try!(repo.mut_txn_begin(rand::thread_rng()));
    let mut branch = txn.open_branch(branch_name)?;
    let mut new_patches_count = 0;
    for &(ref p, ref patch) in patches.iter() {
        debug!("apply_patches: {:?}", p);
        txn.apply_patches_rec(&mut branch, &patches, p, patch, &mut new_patches_count)?
    }
    txn.commit_branch(branch)?;
    txn.commit()?;
    Ok(())
}

/// Open the repository, and unrecord the patch, without increasing
/// the size. If this fails, the repository file is guaranteed to have
/// been increased by `increase` bytes.
pub fn unrecord_no_resize(repo_dir: &Path,
                          repo_root: &Path,
                          branch_name: &str,
                          selected: &mut Vec<(Hash, Patch)>,
                          increase: u64)
                          -> Result<()> {
    debug!("unrecord_no_resize: {:?}", repo_dir);
    let repo = try!(Repository::open(repo_dir, Some(increase)));

    let mut txn = try!(repo.mut_txn_begin(rand::thread_rng()));
    let mut branch = txn.open_branch(branch_name)?;
    let mut timestamps = Vec::new();
    while let Some((hash, patch)) = selected.pop() {
        let internal = txn.get_internal(hash.as_ref()).unwrap().to_owned();
        debug!("Unrecording {:?}", hash);
        if let Some(ts) = txn.get_patch(&branch.patches, &internal) {
            timestamps.push(ts);
        }
        try!(txn.unrecord(&mut branch, &internal, &patch));
        debug!("Done unrecording {:?}", hash);
    }


    if let Err(e) = txn.output_changes_file(&branch, repo_root) {
        error!("no changes file: {:?}", e)
    }
    try!(txn.commit_branch(branch));
    try!(txn.commit());
    Ok(())
}