// revlog.rs

//

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

//

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

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

#![allow(non_snake_case)]

use crate::{

    conversion::{rev_pyiter_collect, rev_pyiter_collect_or_else},

    pybytes_deref::{PyBufferDeref, PyBytesDeref},

    utils::{node_from_py_bytes, node_from_py_object},

    PyRevision,

};

use cpython::{

    buffer::{Element, PyBuffer},

    exc::{IndexError, ValueError},

    ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyInt, PyList,

    PyModule, PyObject, PyResult, PySet, PyTuple, PyType, Python,

    PythonObject, ToPyObject, UnsafePyLeaked,

};

use hg::{

    errors::HgError,

    fncache::FnCache,

    index::{Phase, RevisionDataParams, SnapshotsCache, INDEX_ENTRY_SIZE},

    nodemap::{Block, NodeMapError, NodeTree as CoreNodeTree},

    revlog::{

        compression::CompressionConfig,

        inner_revlog::{InnerRevlog as CoreInnerRevlog, RevisionBuffer},

        nodemap::NodeMap,

        options::{

            RevlogDataConfig, RevlogDeltaConfig, RevlogFeatureConfig,

            RevlogOpenOptions,

        },

        Graph, NodePrefix, RevlogError, RevlogIndex,

    },

    transaction::Transaction,

    utils::files::{get_bytes_from_path, get_path_from_bytes},

    vfs::FnCacheVfs,

    BaseRevision, Node, Revision, RevlogType, UncheckedRevision,

    NULL_REVISION,

};

use std::{

    cell::{Cell, RefCell},

    collections::{HashMap, HashSet},

    sync::OnceLock,

};

use vcsgraph::graph::Graph as VCSGraph;

pub struct PySharedIndex {

    /// The underlying hg-core index

    pub(crate) inner: &'static hg::index::Index,

}

/// Return a Struct implementing the Graph trait

pub(crate) fn py_rust_index_to_graph(

    py: Python,

    index_proxy: PyObject,

) -> PyResult<UnsafePyLeaked<PySharedIndex>> {

    let inner_revlog = index_proxy.getattr(py, "inner")?;

    let inner_revlog = inner_revlog.extract::<InnerRevlog>(py)?;

    let leaked = inner_revlog.inner(py).leak_immutable();

    // Safety: we don't leak the "faked" reference out of the `UnsafePyLeaked`

    Ok(unsafe { leaked.map(py, |idx| PySharedIndex { inner: &idx.index }) })

}

impl Clone for PySharedIndex {

    fn clone(&self) -> Self {

        Self { inner: self.inner }

    }

}

impl Graph for PySharedIndex {

    #[inline(always)]

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

        self.inner.parents(rev)

    }

}

impl VCSGraph for PySharedIndex {

    #[inline(always)]

    fn parents(

        &self,

        rev: BaseRevision,

    ) -> Result<vcsgraph::graph::Parents, vcsgraph::graph::GraphReadError>

    {

        // FIXME This trait should be reworked to decide between Revision

        // and UncheckedRevision, get better errors names, etc.

        match Graph::parents(self, Revision(rev)) {

            Ok(parents) => {

                Ok(vcsgraph::graph::Parents([parents[0].0, parents[1].0]))

            }

            Err(hg::GraphError::ParentOutOfRange(rev)) => {

                Err(vcsgraph::graph::GraphReadError::KeyedInvalidKey(rev.0))

            }

        }

    }

}

impl RevlogIndex for PySharedIndex {

    fn len(&self) -> usize {

        self.inner.len()

    }

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

        self.inner.node(rev)

    }

}

/// Take a (potentially) mmap'ed buffer, and return the underlying Python

/// buffer along with the Rust slice into said buffer. We need to keep the

/// Python buffer around, otherwise we'd get a dangling pointer once the buffer

/// is freed from Python's side.

///

/// # Safety

///

/// The caller must make sure that the buffer is kept around for at least as

/// long as the slice.

#[deny(unsafe_op_in_unsafe_fn)]

unsafe fn mmap_keeparound(

    py: Python,

    data: PyObject,

) -> PyResult<(

    PyBuffer,

    Box<dyn std::ops::Deref<Target = [u8]> + Send + Sync + 'static>,

)> {

    let buf = PyBuffer::get(py, &data)?;

    let len = buf.item_count();

    // Build a slice from the mmap'ed buffer data

    let cbuf = buf.buf_ptr();

    let bytes = if std::mem::size_of::<u8>() == buf.item_size()

        && buf.is_c_contiguous()

        && u8::is_compatible_format(buf.format())

    {

        unsafe { std::slice::from_raw_parts(cbuf as *const u8, len) }

    } else {

        return Err(PyErr::new::<ValueError, _>(

            py,

            "buffer has an invalid memory representation".to_string(),

        ));

    };

    Ok((buf, Box::new(bytes)))

}

fn py_tuple_to_revision_data_params(

    py: Python,

    tuple: PyTuple,

) -> PyResult<RevisionDataParams> {

    if tuple.len(py) < 8 {

        // this is better than the panic promised by tup.get_item()

        return Err(PyErr::new::<IndexError, _>(

            py,

            "tuple index out of range",

        ));

    }

    let offset_or_flags: u64 = tuple.get_item(py, 0).extract(py)?;

    let node_id = tuple

        .get_item(py, 7)

        .extract::<PyBytes>(py)?

        .data(py)

        .try_into()

        .expect("nodeid should be set");

    let flags = (offset_or_flags & 0xFFFF) as u16;

    let data_offset = offset_or_flags >> 16;

    Ok(RevisionDataParams {

        flags,

        data_offset,

        data_compressed_length: tuple.get_item(py, 1).extract(py)?,

        data_uncompressed_length: tuple.get_item(py, 2).extract(py)?,

        data_delta_base: tuple.get_item(py, 3).extract(py)?,

        link_rev: tuple.get_item(py, 4).extract(py)?,

        parent_rev_1: tuple.get_item(py, 5).extract(py)?,

        parent_rev_2: tuple.get_item(py, 6).extract(py)?,

        node_id,

        ..Default::default()

    })

}

fn revision_data_params_to_py_tuple(

    py: Python,

    params: RevisionDataParams,

) -> PyTuple {

    PyTuple::new(

        py,

        &[

            params.data_offset.into_py_object(py).into_object(),

            params

                .data_compressed_length

                .into_py_object(py)

                .into_object(),

            params

                .data_uncompressed_length

                .into_py_object(py)

                .into_object(),

            params.data_delta_base.into_py_object(py).into_object(),

            params.link_rev.into_py_object(py).into_object(),

            params.parent_rev_1.into_py_object(py).into_object(),

            params.parent_rev_2.into_py_object(py).into_object(),

            PyBytes::new(py, &params.node_id)

                .into_py_object(py)

                .into_object(),

            params._sidedata_offset.into_py_object(py).into_object(),

            params

                ._sidedata_compressed_length

                .into_py_object(py)

                .into_object(),

            params

                .data_compression_mode

                .into_py_object(py)

                .into_object(),

            params

                ._sidedata_compression_mode

                .into_py_object(py)

                .into_object(),

            params._rank.into_py_object(py).into_object(),

        ],

    )

}

struct PySnapshotsCache<'p> {

    py: Python<'p>,

    dict: PyDict,

}

impl<'p> SnapshotsCache for PySnapshotsCache<'p> {

    fn insert_for(

        &mut self,

        rev: BaseRevision,

        value: BaseRevision,

    ) -> Result<(), RevlogError> {

        let pyvalue = value.into_py_object(self.py).into_object();

        match self.dict.get_item(self.py, rev) {

            Some(obj) => obj

                .extract::<PySet>(self.py)

                .and_then(|set| set.add(self.py, pyvalue)),

            None => PySet::new(self.py, vec![pyvalue])

                .and_then(|set| self.dict.set_item(self.py, rev, set)),

        }

        .map_err(|_| {

            RevlogError::Other(HgError::unsupported(

                "Error in Python caches handling",

            ))

        })

    }

}

// There are no static generics in Rust (because their implementation is hard,

// I'm guessing it's due to different compilation stages, etc.).

// So manually generate all three caches and use them in `with_filelog_cache`.

static DELTA_CONFIG_CACHE: OnceLock<(PyObject, RevlogDeltaConfig)> =

    OnceLock::new();

static DATA_CONFIG_CACHE: OnceLock<(PyObject, RevlogDataConfig)> =

    OnceLock::new();

static FEATURE_CONFIG_CACHE: OnceLock<(PyObject, RevlogFeatureConfig)> =

    OnceLock::new();

/// Cache the first conversion from Python -> Rust config for all filelogs to

/// save on conversion time when called in a loop.

fn with_filelog_cache<T: Copy>(

    py: Python,

    py_config: &PyObject,

    revlog_type: RevlogType,

    cache: &OnceLock<(PyObject, T)>,

    callback: impl Fn() -> PyResult<T>,

) -> PyResult<T> {

    let mut was_cached = false;

    if revlog_type == RevlogType::Filelog {

        if let Some((cached_py_config, rust_config)) = cache.get() {

            was_cached = true;

            // All filelogs in a given repository *most likely* have the

            // exact same config, but it's not impossible that some extensions

            // do some magic with configs or that this code will be used

            // for longer-running processes. So compare the source `PyObject`

            // in case the source changed, at the cost of some overhead.

            // We can't use `py_config.eq(cached_py_config)` because all config

            // objects are different in Python and `a is b` is false.

            if py_config.compare(py, cached_py_config)?.is_eq() {

                return Ok(*rust_config);

            }

        }

    }

    let config = callback()?;

    // Do not call the lock unnecessarily if it's already been set.

    if !was_cached && revlog_type == RevlogType::Filelog {

        cache.set((py_config.clone_ref(py), config)).ok();

    }

    Ok(config)

}

fn extract_delta_config(

    py: Python,

    py_config: PyObject,

    revlog_type: RevlogType,

) -> PyResult<RevlogDeltaConfig> {

    let get_delta_config = || {

        let max_deltachain_span = py_config

            .getattr(py, "max_deltachain_span")?

            .extract::<i64>(py)?;

        let revlog_delta_config = RevlogDeltaConfig {

            general_delta: py_config

                .getattr(py, "general_delta")?

                .extract(py)?,

            sparse_revlog: py_config

                .getattr(py, "sparse_revlog")?

                .extract(py)?,

            max_chain_len: py_config

                .getattr(py, "max_chain_len")?

                .extract(py)?,

            max_deltachain_span: if max_deltachain_span < 0 {

                None

            } else {

                Some(max_deltachain_span as u64)

            },

            upper_bound_comp: py_config

                .getattr(py, "upper_bound_comp")?

                .extract(py)?,

            delta_both_parents: py_config

                .getattr(py, "delta_both_parents")?

                .extract(py)?,

            candidate_group_chunk_size: py_config

                .getattr(py, "candidate_group_chunk_size")?

                .extract(py)?,

            debug_delta: py_config.getattr(py, "debug_delta")?.extract(py)?,

            lazy_delta: py_config.getattr(py, "lazy_delta")?.extract(py)?,

            lazy_delta_base: py_config

                .getattr(py, "lazy_delta_base")?

                .extract(py)?,

        };

        Ok(revlog_delta_config)

    };

    with_filelog_cache(

        py,

        &py_config,

        revlog_type,

        &DELTA_CONFIG_CACHE,

        get_delta_config,

    )

}

fn extract_data_config(

    py: Python,

    py_config: PyObject,

    revlog_type: RevlogType,

) -> PyResult<RevlogDataConfig> {

    let get_data_config = || {

        Ok(RevlogDataConfig {

            try_pending: py_config.getattr(py, "try_pending")?.extract(py)?,

            try_split: py_config.getattr(py, "try_split")?.extract(py)?,

            check_ambig: py_config.getattr(py, "check_ambig")?.extract(py)?,

            mmap_large_index: py_config

                .getattr(py, "mmap_large_index")?

                .extract(py)?,

            mmap_index_threshold: py_config

                .getattr(py, "mmap_index_threshold")?

                .extract(py)?,

            chunk_cache_size: py_config

                .getattr(py, "chunk_cache_size")?

                .extract(py)?,

            uncompressed_cache_factor: py_config

                .getattr(py, "uncompressed_cache_factor")?

                .extract(py)?,

            uncompressed_cache_count: py_config

                .getattr(py, "uncompressed_cache_count")?

                .extract(py)?,

            with_sparse_read: py_config

                .getattr(py, "with_sparse_read")?

                .extract(py)?,

            sr_density_threshold: py_config

                .getattr(py, "sr_density_threshold")?

                .extract(py)?,

            sr_min_gap_size: py_config

                .getattr(py, "sr_min_gap_size")?

                .extract(py)?,

            general_delta: py_config

                .getattr(py, "generaldelta")?

                .extract(py)?,

        })

    };

    with_filelog_cache(

        py,

        &py_config,

        revlog_type,

        &DATA_CONFIG_CACHE,

        get_data_config,

    )

}

fn extract_feature_config(

    py: Python,

    py_config: PyObject,

    revlog_type: RevlogType,

) -> PyResult<RevlogFeatureConfig> {

    let get_feature_config = || {

        let engine_bytes = &py_config

            .getattr(py, "compression_engine")?

            .extract::<PyBytes>(py)?;

        let compression_engine = engine_bytes.data(py);

        let compression_engine = match compression_engine {

            b"zlib" => {

                let compression_options = &py_config

                    .getattr(py, "compression_engine_options")?

                    .extract::<PyDict>(py)?;

                let zlib_level = compression_options

                    .get_item(py, PyBytes::new(py, &b"zlib.level"[..]));

                let level = if let Some(level) = zlib_level {

                    if level.is_none(py) {

                        None

                    } else {

                        Some(level.extract(py)?)

                    }

                } else {

                    None

                };

                let mut engine = CompressionConfig::default();

                if let Some(level) = level {

                    engine

                        .set_level(level)

                        .expect("invalid compression level from Python");

                }

                engine

            }

            b"zstd" => {

                let compression_options = &py_config

                    .getattr(py, "compression_engine_options")?

                    .extract::<PyDict>(py)?;

                let zstd_level = compression_options

                    .get_item(py, PyBytes::new(py, &b"zstd.level"[..]));

                let level = if let Some(level) = zstd_level {

                    if level.is_none(py) {

                        None

                    } else {

                        Some(level.extract(py)?)

                    }

                } else {

                    let level = compression_options

                        .get_item(py, PyBytes::new(py, &b"level"[..]));

                    if let Some(level) = level {

                        if level.is_none(py) {

                            None

                        } else {

                            Some(level.extract(py)?)

                        }

                    } else {

                        None

                    }

                };

                CompressionConfig::zstd(level)

                    .expect("invalid compression level from Python")

            }

            b"none" => CompressionConfig::None,

            e => {

                return Err(PyErr::new::<ValueError, _>(

                    py,

                    format!(

                        "invalid compression engine {}",

                        String::from_utf8_lossy(e)

                    ),

                ))

            }

        };

        let revlog_feature_config = RevlogFeatureConfig {

            compression_engine,

            censorable: py_config.getattr(py, "censorable")?.extract(py)?,

            has_side_data: py_config

                .getattr(py, "has_side_data")?

                .extract(py)?,

            compute_rank: py_config

                .getattr(py, "compute_rank")?

                .extract(py)?,

            canonical_parent_order: py_config

                .getattr(py, "canonical_parent_order")?

                .extract(py)?,

            enable_ellipsis: py_config

                .getattr(py, "enable_ellipsis")?

                .extract(py)?,

        };

        Ok(revlog_feature_config)

    };

    with_filelog_cache(

        py,

        &py_config,

        revlog_type,

        &FEATURE_CONFIG_CACHE,

        get_feature_config,

    )

}

fn revlog_error_from_msg(py: Python, e: impl ToString) -> PyErr {

    let msg = e.to_string();