// Copyright 2018-2023 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.

//! Mercurial concepts for handling revision history

pub mod node;

pub mod nodemap;

mod nodemap_docket;

pub mod path_encode;

pub use node::{FromHexError, Node, NodePrefix};

pub mod changelog;

pub mod filelog;

pub mod index;

pub mod manifest;

pub mod patch;

use std::borrow::Cow;

use std::io::Read;

use std::ops::Deref;

use std::path::Path;

use flate2::read::ZlibDecoder;

use sha1::{Digest, Sha1};

use zstd;

use self::node::{NODE_BYTES_LENGTH, NULL_NODE};

use self::nodemap_docket::NodeMapDocket;

use super::index::Index;

use super::nodemap::{NodeMap, NodeMapError};

use crate::errors::HgError;

use crate::vfs::Vfs;

/// Mercurial revision numbers

///

/// As noted in revlog.c, revision numbers are actually encoded in

/// 4 bytes, and are liberally converted to ints, whence the i32

pub type Revision = i32;

/// Marker expressing the absence of a parent

///

/// Independently of the actual representation, `NULL_REVISION` is guaranteed

/// to be smaller than all existing revisions.

pub const NULL_REVISION: Revision = -1;

/// Same as `mercurial.node.wdirrev`

///

/// This is also equal to `i32::max_value()`, but it's better to spell

/// it out explicitely, same as in `mercurial.node`

#[allow(clippy::unreadable_literal)]

pub const WORKING_DIRECTORY_REVISION: Revision = 0x7fffffff;

pub const WORKING_DIRECTORY_HEX: &str =

    "ffffffffffffffffffffffffffffffffffffffff";

/// The simplest expression of what we need of Mercurial DAGs.

pub trait Graph {

    /// Return the two parents of the given `Revision`.

    ///

    /// Each of the parents can be independently `NULL_REVISION`

    fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError>;

}

#[derive(Clone, Debug, PartialEq)]

pub enum GraphError {

    ParentOutOfRange(Revision),

    WorkingDirectoryUnsupported,

}

/// The Mercurial Revlog Index

///

/// This is currently limited to the minimal interface that is needed for

/// the [`nodemap`](nodemap/index.html) module

pub trait RevlogIndex {

    /// Total number of Revisions referenced in this index

    fn len(&self) -> usize;

    fn is_empty(&self) -> bool {

        self.len() == 0

    }

    /// Return a reference to the Node or `None` if rev is out of bounds

    ///

    /// `NULL_REVISION` is not considered to be out of bounds.

    fn node(&self, rev: Revision) -> Option<&Node>;

}

const REVISION_FLAG_CENSORED: u16 = 1 << 15;

const REVISION_FLAG_ELLIPSIS: u16 = 1 << 14;

const REVISION_FLAG_EXTSTORED: u16 = 1 << 13;

const REVISION_FLAG_HASCOPIESINFO: u16 = 1 << 12;

// Keep this in sync with REVIDX_KNOWN_FLAGS in

// mercurial/revlogutils/flagutil.py

const REVIDX_KNOWN_FLAGS: u16 = REVISION_FLAG_CENSORED

    | REVISION_FLAG_ELLIPSIS

    | REVISION_FLAG_EXTSTORED

    | REVISION_FLAG_HASCOPIESINFO;

const NULL_REVLOG_ENTRY_FLAGS: u16 = 0;

#[derive(Debug, derive_more::From)]

pub enum RevlogError {

    InvalidRevision,

    /// Working directory is not supported

    WDirUnsupported,

    /// Found more than one entry whose ID match the requested prefix

    AmbiguousPrefix,

    #[from]

    Other(HgError),

}

impl From<NodeMapError> for RevlogError {

    fn from(error: NodeMapError) -> Self {

        match error {

            NodeMapError::MultipleResults => RevlogError::AmbiguousPrefix,

            NodeMapError::RevisionNotInIndex(rev) => RevlogError::corrupted(

                format!("nodemap point to revision {} not in index", rev),

            ),

        }

    }

}

fn corrupted<S: AsRef<str>>(context: S) -> HgError {

    HgError::corrupted(format!("corrupted revlog, {}", context.as_ref()))

}

impl RevlogError {

    fn corrupted<S: AsRef<str>>(context: S) -> Self {

        RevlogError::Other(corrupted(context))

    }

}

/// Read only implementation of revlog.

pub struct Revlog {

    /// When index and data are not interleaved: bytes of the revlog index.

    /// When index and data are interleaved: bytes of the revlog index and

    /// data.

    index: Index,

    /// When index and data are not interleaved: bytes of the revlog data

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

    /// When present on disk: the persistent nodemap for this revlog

    nodemap: Option<nodemap::NodeTree>,

}

impl Revlog {

    /// Open a revlog index file.

    ///

    /// It will also open the associated data file if index and data are not

    /// interleaved.

    pub fn open(

        store_vfs: &Vfs,

        index_path: impl AsRef<Path>,

        data_path: Option<&Path>,

        use_nodemap: bool,

    ) -> Result<Self, HgError> {

        let index_path = index_path.as_ref();

        let index = {

            match store_vfs.mmap_open_opt(&index_path)? {

                None => Index::new(Box::new(vec![])),

                Some(index_mmap) => {

                    let index = Index::new(Box::new(index_mmap))?;

                    Ok(index)

                }

            }

        }?;

        let default_data_path = index_path.with_extension("d");

        // type annotation required

        // won't recognize Mmap as Deref<Target = [u8]>

        let data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>> =

            if index.is_inline() {

                None

            } else {

                let data_path = data_path.unwrap_or(&default_data_path);

                let data_mmap = store_vfs.mmap_open(data_path)?;

                Some(Box::new(data_mmap))

            };

        let nodemap = if index.is_inline() || !use_nodemap {

            None

        } else {

            NodeMapDocket::read_from_file(store_vfs, index_path)?.map(

                |(docket, data)| {

                    nodemap::NodeTree::load_bytes(

                        Box::new(data),

                        docket.data_length,

                    )

                },

            )

        };

        Ok(Revlog {

            index,

            data_bytes,

            nodemap,

        })

    }

    /// Return number of entries of the `Revlog`.

    pub fn len(&self) -> usize {

        self.index.len()

    }

    /// Returns `true` if the `Revlog` has zero `entries`.

    pub fn is_empty(&self) -> bool {

        self.index.is_empty()

    }

    /// Returns the node ID for the given revision number, if it exists in this

    /// revlog

    pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> {

        if rev == NULL_REVISION {

            return Some(&NULL_NODE);

        }

        Some(self.index.get_entry(rev)?.hash())

    }

    /// Return the revision number for the given node ID, if it exists in this

    /// revlog

    pub fn rev_from_node(

        &self,

        node: NodePrefix,

    ) -> Result<Revision, RevlogError> {

        if node.is_prefix_of(&NULL_NODE) {

            return Ok(NULL_REVISION);

        }

        if let Some(nodemap) = &self.nodemap {

            return nodemap

                .find_bin(&self.index, node)?

                .ok_or(RevlogError::InvalidRevision);

        }

        // Fallback to linear scan when a persistent nodemap is not present.

        // This happens when the persistent-nodemap experimental feature is not

        // enabled, or for small revlogs.

        //

        // TODO: consider building a non-persistent nodemap in memory to

        // optimize these cases.

        let mut found_by_prefix = None;

        for rev in (0..self.len() as Revision).rev() {

            let index_entry = self.index.get_entry(rev).ok_or_else(|| {

                HgError::corrupted(

                    "revlog references a revision not in the index",

                )

            })?;

            if node == *index_entry.hash() {

                return Ok(rev);

            }

            if node.is_prefix_of(index_entry.hash()) {

                if found_by_prefix.is_some() {

                    return Err(RevlogError::AmbiguousPrefix);

                }

                found_by_prefix = Some(rev)

            }

        }

        found_by_prefix.ok_or(RevlogError::InvalidRevision)

    }

    /// Returns whether the given revision exists in this revlog.

    pub fn has_rev(&self, rev: Revision) -> bool {

        self.index.get_entry(rev).is_some()

    }

    /// Return the full data associated to a revision.

    ///

    /// All entries required to build the final data out of deltas will be

    /// retrieved as needed, and the deltas will be applied to the inital

    /// snapshot to rebuild the final data.

    pub fn get_rev_data(

        &self,

        rev: Revision,

    ) -> Result<Cow<[u8]>, RevlogError> {

        if rev == NULL_REVISION {

            return Ok(Cow::Borrowed(&[]));

        };

        Ok(self.get_entry(rev)?.data()?)

    }

    /// Check the hash of some given data against the recorded hash.

    pub fn check_hash(

        &self,

        p1: Revision,

        p2: Revision,

        expected: &[u8],

        data: &[u8],

    ) -> bool {

        let e1 = self.index.get_entry(p1);

        let h1 = match e1 {

            Some(ref entry) => entry.hash(),

            None => &NULL_NODE,

        };

        let e2 = self.index.get_entry(p2);

        let h2 = match e2 {

            Some(ref entry) => entry.hash(),

            None => &NULL_NODE,

        };

        hash(data, h1.as_bytes(), h2.as_bytes()) == expected

    }

    /// Build the full data of a revision out its snapshot

    /// and its deltas.

    fn build_data_from_deltas(

        snapshot: RevlogEntry,

        deltas: &[RevlogEntry],

    ) -> Result<Vec<u8>, HgError> {

        let snapshot = snapshot.data_chunk()?;

        let deltas = deltas

            .iter()

            .rev()

            .map(RevlogEntry::data_chunk)

            .collect::<Result<Vec<_>, _>>()?;

        let patches: Vec<_> =

            deltas.iter().map(|d| patch::PatchList::new(d)).collect();

        let patch = patch::fold_patch_lists(&patches);

        Ok(patch.apply(&snapshot))

    }

    /// Return the revlog data.

    fn data(&self) -> &[u8] {

        match &self.data_bytes {

            Some(data_bytes) => data_bytes,

            None => panic!(

                "forgot to load the data or trying to access inline data"

            ),

        }

    }

    pub fn make_null_entry(&self) -> RevlogEntry {

        RevlogEntry {

            revlog: self,

            rev: NULL_REVISION,

            bytes: b"",

            compressed_len: 0,

            uncompressed_len: 0,

            base_rev_or_base_of_delta_chain: None,

            p1: NULL_REVISION,

            p2: NULL_REVISION,

            flags: NULL_REVLOG_ENTRY_FLAGS,

            hash: NULL_NODE,

        }

    }

    /// Get an entry of the revlog.

    pub fn get_entry(

        &self,

        rev: Revision,

    ) -> Result<RevlogEntry, RevlogError> {

        if rev == NULL_REVISION {

            return Ok(self.make_null_entry());

        }

        let index_entry = self

            .index

            .get_entry(rev)

            .ok_or(RevlogError::InvalidRevision)?;

        let start = index_entry.offset();