// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>

//           and Mercurial contributors

//

// This software may be used and distributed according to the terms of the

// GNU General Public License version 2 or any later version.

//! Indexing facilities for fast retrieval of `Revision` from `Node`

//!

//! This provides a variation on the 16-ary radix tree that is

//! provided as "nodetree" in revlog.c, ready for append-only persistence

//! on disk.

//!

//! Following existing implicit conventions, the "nodemap" terminology

//! is used in a more abstract context.

use super::{

    node::NULL_NODE, Node, NodePrefix, Revision, RevlogIndex, NULL_REVISION,

};

use bytes_cast::{unaligned, BytesCast};

use std::cmp::max;

use std::fmt;

use std::mem::{self, align_of, size_of};

use std::ops::Deref;

use std::ops::Index;

#[derive(Debug, PartialEq)]

pub enum NodeMapError {

    MultipleResults,

    /// A `Revision` stored in the nodemap could not be found in the index

    RevisionNotInIndex(Revision),

}

/// Mapping system from Mercurial nodes to revision numbers.

///

/// ## `RevlogIndex` and `NodeMap`

///

/// One way to think about their relationship is that

/// the `NodeMap` is a prefix-oriented reverse index of the `Node` information

/// carried by a [`RevlogIndex`].

///

/// Many of the methods in this trait take a `RevlogIndex` argument

/// which is used for validation of their results. This index must naturally

/// be the one the `NodeMap` is about, and it must be consistent.

///

/// Notably, the `NodeMap` must not store

/// information about more `Revision` values than there are in the index.

/// In these methods, an encountered `Revision` is not in the index, a

/// [`RevisionNotInIndex`] error is returned.

///

/// In insert operations, the rule is thus that the `NodeMap` must always

/// be updated after the `RevlogIndex`

/// be updated first, and the `NodeMap` second.

///

/// [`RevisionNotInIndex`]: enum.NodeMapError.html#variant.RevisionNotInIndex

/// [`RevlogIndex`]: ../trait.RevlogIndex.html

pub trait NodeMap {

    /// Find the unique `Revision` having the given `Node`

    ///

    /// If no Revision matches the given `Node`, `Ok(None)` is returned.

    fn find_node(

        &self,

        index: &impl RevlogIndex,

        node: &Node,

    ) -> Result<Option<Revision>, NodeMapError> {

        self.find_bin(index, node.into())

    }

    /// Find the unique Revision whose `Node` starts with a given binary prefix

    ///

    /// If no Revision matches the given prefix, `Ok(None)` is returned.

    ///

    fn find_bin(

        &self,

        idx: &impl RevlogIndex,

        prefix: NodePrefix,

    ) -> Result<Option<Revision>, NodeMapError>;

    /// Give the size of the shortest node prefix that determines

    /// the revision uniquely.

    ///

    /// From a binary node prefix, if it is matched in the node map, this

    /// returns the number of hexadecimal digits that would had sufficed

    /// to find the revision uniquely.

    ///

    /// Returns `None` if no `Revision` could be found for the prefix.

    ///

    fn unique_prefix_len_bin(

        &self,

        idx: &impl RevlogIndex,

        node_prefix: NodePrefix,

    ) -> Result<Option<usize>, NodeMapError>;

    /// Same as `unique_prefix_len_bin`, with a full `Node` as input

    fn unique_prefix_len_node(

        &self,

        idx: &impl RevlogIndex,

        node: &Node,

    ) -> Result<Option<usize>, NodeMapError> {

        self.unique_prefix_len_bin(idx, node.into())

    }

}

pub trait MutableNodeMap: NodeMap {

    fn insert<I: RevlogIndex>(

        &mut self,

        index: &I,

        node: &Node,

        rev: Revision,

    ) -> Result<(), NodeMapError>;

}

///

/// These are exactly as for instance on persistent storage.

type RawElement = unaligned::I32Be;

/// High level representation of values in NodeTree

/// [`Blocks`](struct.Block.html)

///

/// This is the high level representation that most algorithms should

/// use.

#[derive(Clone, Debug, Eq, PartialEq)]

enum Element {

    Rev(Revision),

    Block(usize),

    None,

}

impl From<RawElement> for Element {

    /// Conversion from low level representation, after endianness conversion.

    ///

    /// See [`Block`](struct.Block.html) for explanation about the encoding.

    fn from(raw: RawElement) -> Element {

        let int = raw.get();

        if int >= 0 {

            Element::Block(int as usize)

        } else if int == -1 {

            Element::None

        } else {

            Element::Rev(-int - 2)

        }

    }

}

impl From<Element> for RawElement {

    fn from(element: Element) -> RawElement {

        RawElement::from(match element {

            Element::None => 0,

            Element::Block(i) => i as i32,

            Element::Rev(rev) => -rev - 2,

        })

    }

}

/// A logical block of the `NodeTree`, packed with a fixed size.

///

/// These are always used in container types implementing `Index<Block>`,

/// such as `&Block`

///

/// As an array of integers, its ith element encodes that the

/// ith potential edge from the block, representing the ith hexadecimal digit

/// (nybble) `i` is either:

///

/// - absent (value -1)

/// - another `Block` in the same indexable container (value ≥ 0)

///  - a `Revision` leaf (value ≤ -2)

///

/// Endianness has to be fixed for consistency on shared storage across

/// different architectures.

///

/// A key difference with the C `nodetree` is that we need to be

/// able to represent the [`Block`] at index 0, hence -1 is the empty marker

/// rather than 0 and the `Revision` range upper limit of -2 instead of -1.

///

/// Another related difference is that `NULL_REVISION` (-1) is not

/// represented at all, because we want an immutable empty nodetree

/// to be valid.

const ELEMENTS_PER_BLOCK: usize = 16; // number of different values in a nybble

#[derive(Copy, Clone, BytesCast, PartialEq)]

#[repr(transparent)]

pub struct Block([RawElement; ELEMENTS_PER_BLOCK]);

impl Block {

    fn new() -> Self {

        let absent_node = RawElement::from(-1);

        Block([absent_node; ELEMENTS_PER_BLOCK])

    }

    fn get(&self, nybble: u8) -> Element {

        self.0[nybble as usize].into()

    }

    fn set(&mut self, nybble: u8, element: Element) {

        self.0[nybble as usize] = element.into()

    }

}

impl fmt::Debug for Block {

    /// sparse representation for testing and debugging purposes

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

        f.debug_map()

            .entries((0..16).filter_map(|i| match self.get(i) {

                Element::None => None,

                element => Some((i, element)),

            }))

            .finish()

    }

}

/// A mutable 16-radix tree with the root block logically at the end

///

/// Because of the append only nature of our node trees, we need to

/// keep the original untouched and store new blocks separately.

///

/// The mutable root `Block` is kept apart so that we don't have to rebump

/// it on each insertion.

pub struct NodeTree {

    readonly: Box<dyn Deref<Target = [Block]> + Send>,

    growable: Vec<Block>,

    root: Block,

    masked_inner_blocks: usize,

}

impl Index<usize> for NodeTree {

    type Output = Block;

    fn index(&self, i: usize) -> &Block {

        let ro_len = self.readonly.len();

        if i < ro_len {

            &self.readonly[i]

        } else if i == ro_len + self.growable.len() {

            &self.root

        } else {

            &self.growable[i - ro_len]

        }

    }

}

/// Return `None` unless the `Node` for `rev` has given prefix in `index`.

fn has_prefix_or_none(

    idx: &impl RevlogIndex,

    prefix: NodePrefix,

    rev: Revision,

) -> Result<Option<Revision>, NodeMapError> {

    idx.node(rev)

        .ok_or(NodeMapError::RevisionNotInIndex(rev))

        .map(|node| {

            if prefix.is_prefix_of(node) {

                Some(rev)

            } else {

                None

            }

        })

}

/// validate that the candidate's node starts indeed with given prefix,

/// and treat ambiguities related to `NULL_REVISION`.

///

/// From the data in the NodeTree, one can only conclude that some

/// revision is the only one for a *subprefix* of the one being looked up.

fn validate_candidate(

    idx: &impl RevlogIndex,

    prefix: NodePrefix,

    candidate: (Option<Revision>, usize),

) -> Result<(Option<Revision>, usize), NodeMapError> {

    let (rev, steps) = candidate;

    if let Some(nz_nybble) = prefix.first_different_nybble(&NULL_NODE) {

        rev.map_or(Ok((None, steps)), |r| {

            has_prefix_or_none(idx, prefix, r)

                .map(|opt| (opt, max(steps, nz_nybble + 1)))

        })

    } else {

        // the prefix is only made of zeros; NULL_REVISION always matches it

        // and any other *valid* result is an ambiguity

        match rev {

            None => Ok((Some(NULL_REVISION), steps + 1)),

            Some(r) => match has_prefix_or_none(idx, prefix, r)? {

                None => Ok((Some(NULL_REVISION), steps + 1)),

                _ => Err(NodeMapError::MultipleResults),

            },

        }

    }

}

impl NodeTree {

    /// Initiate a NodeTree from an immutable slice-like of `Block`

    ///

    /// We keep `readonly` and clone its root block if it isn't empty.

    fn new(readonly: Box<dyn Deref<Target = [Block]> + Send>) -> Self {

        let root = readonly.last().cloned().unwrap_or_else(Block::new);

        NodeTree {

            readonly,

            growable: Vec::new(),

            root,

            masked_inner_blocks: 0,

        }

    }

    /// Create from an opaque bunch of bytes

    ///

    /// The created `NodeTreeBytes` from `buffer`,

    /// of which exactly `amount` bytes are used.

    ///

    /// - `buffer` could be derived from `PyBuffer` and `Mmap` objects.

    /// - `offset` allows for the final file format to include fixed data

    ///   (generation number, behavioural flags)

    /// - `amount` is expressed in bytes, and is not automatically derived from

    ///   `bytes`, so that a caller that manages them atomically can perform

    ///   temporary disk serializations and still rollback easily if needed.

    ///   First use-case for this would be to support Mercurial shell hooks.

    ///

    /// panics if `buffer` is smaller than `amount`

    pub fn load_bytes(

        bytes: Box<dyn Deref<Target = [u8]> + Send>,

        amount: usize,

    ) -> Self {

        NodeTree::new(Box::new(NodeTreeBytes::new(bytes, amount)))

    }

    /// Retrieve added `Block` and the original immutable data

    pub fn into_readonly_and_added(

        self,

    ) -> (Box<dyn Deref<Target = [Block]> + Send>, Vec<Block>) {

        let mut vec = self.growable;

        let readonly = self.readonly;

        if readonly.last() != Some(&self.root) {

            vec.push(self.root);

        }

        (readonly, vec)

    }

    /// Retrieve added `Blocks` as bytes, ready to be written to persistent

    /// storage

    pub fn into_readonly_and_added_bytes(

        self,

    ) -> (Box<dyn Deref<Target = [Block]> + Send>, Vec<u8>) {

        let (readonly, vec) = self.into_readonly_and_added();

        // Prevent running `v`'s destructor so we are in complete control

        // of the allocation.

        let vec = mem::ManuallyDrop::new(vec);

        // Transmute the `Vec<Block>` to a `Vec<u8>`. Blocks are contiguous

        // bytes, so this is perfectly safe.

        let bytes = unsafe {

            // Check for compatible allocation layout.

            // (Optimized away by constant-folding + dead code elimination.)

            assert_eq!(size_of::<Block>(), 64);

            assert_eq!(align_of::<Block>(), 1);

            // /!\ Any use of `vec` after this is use-after-free.

            // TODO: use `into_raw_parts` once stabilized

            Vec::from_raw_parts(

                vec.as_ptr() as *mut u8,

                vec.len() * size_of::<Block>(),

                vec.capacity() * size_of::<Block>(),

            )

        };

        (readonly, bytes)

    }

    /// Total number of blocks

    fn len(&self) -> usize {

        self.readonly.len() + self.growable.len() + 1

    }