// 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 std::cell::RefCell;

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;

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

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

pub type BaseRevision = i32;

/// Mercurial revision numbers

/// In contrast to the more general [`UncheckedRevision`], these are "checked"

/// in the sense that they should only be used for revisions that are

/// valid for a given index (i.e. in bounds).

#[derive(

    Debug,

    derive_more::Display,

    Clone,

    Copy,

    Hash,

    PartialEq,

    Eq,

    PartialOrd,

    Ord,

)]

pub struct Revision(pub BaseRevision);

impl format_bytes::DisplayBytes for Revision {

    fn display_bytes(

        &self,

        output: &mut dyn std::io::Write,

    ) -> std::io::Result<()> {

        self.0.display_bytes(output)

    }

}

/// Unchecked Mercurial revision numbers.

///

/// Values of this type have no guarantee of being a valid revision number

/// in any context. Use method `check_revision` to get a valid revision within

/// the appropriate index object.

#[derive(

    Debug,

    derive_more::Display,

    Clone,

    Copy,

    Hash,

    PartialEq,

    Eq,

    PartialOrd,

    Ord,

)]

pub struct UncheckedRevision(pub BaseRevision);

impl format_bytes::DisplayBytes for UncheckedRevision {

    fn display_bytes(

        &self,

        output: &mut dyn std::io::Write,

    ) -> std::io::Result<()> {

        self.0.display_bytes(output)

    }

}

impl From<Revision> for UncheckedRevision {

    fn from(value: Revision) -> Self {

        Self(value.0)

    }

}

impl From<BaseRevision> for UncheckedRevision {

    fn from(value: BaseRevision) -> Self {

        Self(value)

    }

}

/// 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 = 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: UncheckedRevision =

    UncheckedRevision(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),

}

/// 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` for `NULL_REVISION`

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

    /// Return a [`Revision`] if `rev` is a valid revision number for this

    /// index.

    ///

    /// [`NULL_REVISION`] is considered to be valid.

    fn check_revision(&self, rev: UncheckedRevision) -> Option<Revision> {

        let rev = rev.0;

        if rev == NULL_REVISION.0 || (rev >= 0 && (rev as usize) < self.len())

        {

            Some(Revision(rev))

        } else {

            None

        }

    }

}

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, derive_more::Display)]

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 Graph for Revlog {

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

        self.index.parents(rev)

    }

}

#[derive(Debug, Copy, Clone)]

pub enum RevlogVersionOptions {

    V0,

    V1 { generaldelta: bool },

    V2,

    ChangelogV2 { compute_rank: bool },

}

/// Options to govern how a revlog should be opened, usually from the

/// repository configuration or requirements.

#[derive(Debug, Copy, Clone)]

pub struct RevlogOpenOptions {

    /// The revlog version, along with any option specific to this version

    pub version: RevlogVersionOptions,

    /// Whether the revlog uses a persistent nodemap.

    pub use_nodemap: bool,

    // TODO other non-header/version options,

}

impl RevlogOpenOptions {

    pub fn new() -> Self {

        Self {

            version: RevlogVersionOptions::V1 { generaldelta: true },

            use_nodemap: false,

        }

    }

    fn default_index_header(&self) -> index::IndexHeader {

        index::IndexHeader {

            header_bytes: match self.version {

                RevlogVersionOptions::V0 => [0, 0, 0, 0],

                RevlogVersionOptions::V1 { generaldelta } => {

                    [0, if generaldelta { 3 } else { 1 }, 0, 1]

                }

                RevlogVersionOptions::V2 => 0xDEADu32.to_be_bytes(),

                RevlogVersionOptions::ChangelogV2 { compute_rank: _ } => {

                    0xD34Du32.to_be_bytes()

                }

            },

        }

    }

}

impl Default for RevlogOpenOptions {

    fn default() -> Self {

        Self::new()

    }

}

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>,

        options: RevlogOpenOptions,

    ) -> Result<Self, HgError> {

        Self::open_gen(store_vfs, index_path, data_path, options, None)

    }

    fn open_gen(

        store_vfs: &Vfs,

        index_path: impl AsRef<Path>,

        data_path: Option<&Path>,

        options: RevlogOpenOptions,

        nodemap_for_test: Option<nodemap::NodeTree>,

    ) -> Result<Self, HgError> {

        let index_path = index_path.as_ref();

        let index = {

            match store_vfs.mmap_open_opt(index_path)? {

                None => Index::new(

                    Box::<Vec<_>>::default(),

                    options.default_index_header(),

                ),

                Some(index_mmap) => {

                    let index = Index::new(

                        Box::new(index_mmap),

                        options.default_index_header(),

                    )?;

                    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() || !options.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,

                    )

                },

            )

        };

        let nodemap = nodemap_for_test.or(nodemap);

        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: UncheckedRevision) -> Option<&Node> {

        if rev == NULL_REVISION.into() {

            return Some(&NULL_NODE);

        }