// revlog.rs

//

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

//           2020-2024 Raphaël Gomès <raphael.gomes@octobus.net>

//           2024 Georges Racinet <georges.racinet@cloudcrane.io>

//

// 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 pyo3::buffer::PyBuffer;

use pyo3::conversion::IntoPyObject;

use pyo3::exceptions::{PyIndexError, PyTypeError, PyValueError};

use pyo3::prelude::*;

use pyo3_sharedref::{PyShareable, SharedByPyObject};

use std::collections::HashSet;

use std::sync::{

    atomic::{AtomicUsize, Ordering},

    RwLock, RwLockReadGuard, RwLockWriteGuard,

};

use hg::{

    revlog::{

        inner_revlog::InnerRevlog as CoreInnerRevlog,

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

        options::RevlogOpenOptions,

    },

    utils::files::get_path_from_bytes,

    vfs::FnCacheVfs,

    BaseRevision, Revision, UncheckedRevision, NULL_REVISION,

};

use crate::{

    exceptions::{

        graph_error, map_lock_error, map_try_lock_error, nodemap_error,

        rev_not_in_index, revlog_error_bare, revlog_error_from_msg,

    },

    node::{node_from_py_bytes, node_prefix_from_py_bytes, py_node_for_rev},

    revision::{

        check_revision, rev_pyiter_collect, rev_pyiter_collect_or_else,

        revs_py_list, PyRevision,

    },

    store::PyFnCache,

    util::{new_submodule, take_buffer_with_slice},

};

mod config;

use config::*;

mod index;

use index::{

    py_tuple_to_revision_data_params, revision_data_params_to_py_tuple,

    PySharedIndex,

};

#[pyclass]

struct ReadingContextManager {

    inner_revlog: Py<InnerRevlog>,

}

#[pymethods]

impl ReadingContextManager {

    fn __enter__(slf: PyRef<'_, Self>) -> PyResult<()> {

        let inner_bound = slf.inner_revlog.bind(slf.py());

        let shareable = &inner_bound.borrow().irl;

        // Safety: the owner is correct and we won't use `share()` anyway

        let core_irl =

            unsafe { shareable.borrow_with_owner(inner_bound) }.read();

        core_irl

            .enter_reading_context()

            .map_err(revlog_error_from_msg)

            .inspect_err(|_e| {

                // `__exit__` is not called from Python if `__enter__` fails

                core_irl.exit_reading_context();

            })

    }

    #[pyo3(signature = (*_args))]

    fn __exit__(slf: PyRef<'_, Self>, _args: &Bound<'_, PyTuple>) {

        let inner_bound = slf.inner_revlog.bind(slf.py());

        let shareable = &inner_bound.borrow().irl;

        // Safety: the owner is correct and we won't use `share()` anyway

        let core_irl_ref = unsafe { shareable.borrow_with_owner(inner_bound) };

        core_irl_ref.read().exit_reading_context();

    }

}

#[pyclass]

#[allow(dead_code)]

struct InnerRevlog {

    irl: PyShareable<CoreInnerRevlog>,

    nt: RwLock<Option<CoreNodeTree>>,

    docket: Option<PyObject>,

    // Holds a reference to the mmap'ed persistent nodemap data

    nodemap_mmap: Option<PyBuffer<u8>>,

    // Holds a reference to the mmap'ed persistent index data

    index_mmap: Option<PyBuffer<u8>>,

    revision_cache: Option<PyObject>,

    head_revs_py_list: Option<Py<PyList>>,

    head_node_ids_py_list: Option<Py<PyList>>,

    use_persistent_nodemap: bool,

    nodemap_queries: AtomicUsize,

}

#[pymethods]

impl InnerRevlog {

    #[new]

    // The Python side has authority on this signature.

    #[allow(clippy::too_many_arguments)]

    fn new(

        vfs_base: &Bound<'_, PyBytes>,

        fncache: &Bound<'_, PyAny>,

        vfs_is_readonly: bool,

        index_data: &Bound<'_, PyAny>,

        index_file: &Bound<'_, PyBytes>,

        data_file: &Bound<'_, PyBytes>,

        sidedata_file: &Bound<'_, PyAny>,

        inline: bool,

        data_config: &Bound<'_, PyAny>,

        delta_config: &Bound<'_, PyAny>,

        feature_config: &Bound<'_, PyAny>,

        chunk_cache: &Bound<'_, PyAny>,

        default_compression_header: &Bound<'_, PyAny>,

        revlog_type: usize,

        use_persistent_nodemap: bool,

    ) -> PyResult<Self> {

        // Let clippy accept the unused arguments. This is a bit better than

        // a blank `allow` directive

        let _ = sidedata_file;

        let _ = chunk_cache;

        let _ = default_compression_header;

        let index_file = get_path_from_bytes(index_file.as_bytes()).to_owned();

        let data_file = get_path_from_bytes(data_file.as_bytes()).to_owned();

        let revlog_type = RevlogType::try_from(revlog_type)

            .map_err(revlog_error_from_msg)?;

        let data_config = extract_data_config(data_config, revlog_type)?;

        let delta_config = extract_delta_config(delta_config, revlog_type)?;

        let feature_config =

            extract_feature_config(feature_config, revlog_type)?;

        let options = RevlogOpenOptions::new(

            inline,

            data_config,

            delta_config,

            feature_config,

        );

        // Safety: we keep the buffer around inside the returned instance as

        // `index_mmap`

        let (buf, bytes) = unsafe { take_buffer_with_slice(index_data)? };

        let index = Index::new(bytes, options.index_header())

            .map_err(revlog_error_from_msg)?;

        let base = get_path_from_bytes(vfs_base.as_bytes()).to_owned();

        let core = CoreInnerRevlog::new(

            Box::new(FnCacheVfs::new(

                base,

                vfs_is_readonly,

                Box::new(PyFnCache::new(fncache.clone().unbind())),

            )),

            index,

            index_file,

            data_file,

            data_config,

            delta_config,

            feature_config,

        );

        Ok(Self {

            irl: core.into(),

            nt: None.into(),

            docket: None,

            nodemap_mmap: None,

            index_mmap: buf.into(),

            head_revs_py_list: None,

            head_node_ids_py_list: None,

            revision_cache: None,

            use_persistent_nodemap,

            nodemap_queries: AtomicUsize::new(0),

        })

    }

    fn reading(slf: &Bound<'_, Self>) -> PyResult<ReadingContextManager> {

        Ok(ReadingContextManager {

            inner_revlog: slf.clone().unbind(),

        })

    }

    //

    // -- forwarded index methods --

    //

    fn _index_get_rev(

        slf: &Bound<'_, Self>,

        node: &Bound<'_, PyBytes>,

    ) -> PyResult<Option<PyRevision>> {

        let node = node_from_py_bytes(node)?;

        // Do not rewrite this with `Self::with_index_nt_read`: it makes

        // inconditionally a volatile nodetree, and that is not the intent

        // here: the code below specifically avoids that.

        Self::with_core_read(slf, |self_ref, irl| {

            let idx = &irl.index;

            let prev_queries =

                self_ref.nodemap_queries.fetch_add(1, Ordering::Relaxed);

            // Filelogs have no persistent nodemaps and are often small,

            // use a brute force lookup from the end

            // backwards. If there is a very large filelog

            // (automation file that changes every

            // commit etc.), it also seems to work quite well for

            // all measured purposes so far.

            if !self_ref.use_persistent_nodemap && prev_queries <= 3 {

                return Ok(idx

                    .rev_from_node_no_persistent_nodemap(node.into())

                    .ok()

                    .map(Into::into));

            }

            let opt =

                self_ref.get_nodetree(idx)?.read().map_err(map_lock_error)?;

            let nt = opt.as_ref().expect("nodetree should be set");

            let rust_rev =

                nt.find_bin(idx, node.into()).map_err(nodemap_error)?;

            Ok(rust_rev.map(Into::into))

        })

    }

    /// same as `_index_get_rev()` but raises a bare `error.RevlogError` if

    /// node is not found.

    ///

    /// No need to repeat `node` in the exception, `mercurial/revlog.py`

    /// will catch and rewrap with it

    fn _index_rev(

        slf: &Bound<'_, Self>,

        node: &Bound<'_, PyBytes>,

    ) -> PyResult<PyRevision> {

        Self::_index_get_rev(slf, node)?.ok_or_else(revlog_error_bare)

    }

    /// return True if the node exist in the index

    fn _index_has_node(

        slf: &Bound<'_, Self>,

        node: &Bound<'_, PyBytes>,

    ) -> PyResult<bool> {

        Self::_index_get_rev(slf, node).map(|opt| opt.is_some())

    }

    /// find length of shortest hex nodeid of a binary ID

    fn _index_shortest(

        slf: &Bound<'_, Self>,

        node: &Bound<'_, PyBytes>,

    ) -> PyResult<usize> {

        Self::with_index_nt_read(slf, |idx, nt| {

            match nt.unique_prefix_len_node(idx, &node_from_py_bytes(node)?) {

                Ok(Some(l)) => Ok(l),

                Ok(None) => Err(revlog_error_bare()),

                Err(e) => Err(nodemap_error(e)),

            }

        })

    }

    fn _index_partialmatch<'py>(

        slf: &Bound<'py, Self>,

        node: &Bound<'py, PyBytes>,

    ) -> PyResult<Option<Bound<'py, PyBytes>>> {

        Self::with_index_nt_read(slf, |idx, nt| {

            Ok(nt

                .find_bin(idx, node_prefix_from_py_bytes(node)?)

                .map_err(nodemap_error)?

                .map(|rev| py_node_for_rev(slf.py(), idx, rev)))

        })

    }

    /// append an index entry

    fn _index_append(

        slf: &Bound<'_, Self>,

        tup: &Bound<'_, PyTuple>,

    ) -> PyResult<()> {

        // no need to check length: in PyO3 tup.get_item() does return

        // proper errors

        let node_bytes = tup.get_item(7)?.extract()?;

        let node = node_from_py_bytes(&node_bytes)?;

        Self::with_index_nt_write(slf, |idx, nt| {

            let rev = idx.len() as BaseRevision;

            // This is ok since we will immediately add the revision to the

            // index

            let rev = Revision(rev);

            idx.append(py_tuple_to_revision_data_params(tup)?)

                .map_err(revlog_error_from_msg)?;

            nt.insert(idx, &node, rev).map_err(nodemap_error)?;

            Ok(())

        })

    }

    /// Removes one or several entries from the index.

    ///

    /// Historically, on the Mercurial revlog index, `__delitem__` has always

    /// been both for `del idx[r1]` and `del idx[r1:r2]`. In both cases,

    /// all entries starting from `r1` are removed anyway.

    fn _index___delitem__(

        slf: &Bound<'_, Self>,

        arg: &Bound<'_, PyAny>,

    ) -> PyResult<()> {

        let start = if let Ok(rev) = arg.extract() {

            UncheckedRevision(rev)

        } else {

            // here we could downcast to `PySlice` and use `indices()`, *but*

            // the rust-cpython based version could not do that, and

            // `indices()` does some resolving that makes it not equivalent,

            // e.g., `idx[-1::]` has `start=0`. As we are currently in

            // transition, we keep it the old way (hoping it was consistent

            // with the C index).

            let start = arg.getattr("start")?;

            UncheckedRevision(start.extract()?)

        };

        Self::with_index_nt_write(slf, |idx, nt| {

            // In the case of a slice, the check is possibly already done by

            // `slice.indices`, which is itself an FFI wrapper for CPython's

            // `PySlice_GetIndicesEx`

            // (Python integration tests will tell us)

            let start = idx.check_revision(start).ok_or_else(|| {

                nodemap_error(NodeMapError::RevisionNotInIndex(start))

            })?;

            idx.remove(start).map_err(revlog_error_from_msg)?;

            nt.invalidate_all();

            Self::fill_nodemap(idx, nt)?;

            Ok(())

        })

    }

    /// reachableroots

    #[pyo3(signature = (*args))]

    fn _index_reachableroots2(

        slf: &Bound<'_, Self>,

        py: Python<'_>,

        args: &Bound<'_, PyTuple>,

    ) -> PyResult<Py<PyList>> {

        // TODO what was the point of having a signature with variable args?

        let min_root = UncheckedRevision(args.get_item(0)?.extract()?);

        let heads = args.get_item(1)?;

        let roots = args.get_item(2)?;

        let include_path: bool = args.get_item(3)?.extract()?;

        let as_set = Self::with_index_read(slf, |idx| {

            let heads = rev_pyiter_collect_or_else(&heads, idx, |_rev| {

                PyIndexError::new_err("head out of range")

            })?;

            let roots: Result<_, _> = roots

                .try_iter()?

                .map(|r| {

                    r.and_then(|o| match o.extract::<PyRevision>() {

                        Ok(r) => Ok(UncheckedRevision(r.0)),

                        Err(e) => Err(e),

                    })

                })

                .collect();

            idx.reachable_roots(min_root, heads, roots?, include_path)

                .map_err(graph_error)

        })?;

        revs_py_list(py, as_set)

    }

    #[pyo3(signature = (*args))]

    fn _index_headrevs(

        slf: &Bound<'_, Self>,

        py: Python<'_>,

        args: &Bound<'_, PyTuple>,

    ) -> PyResult<Py<PyList>> {

        let (filtered_revs, stop_rev) = match args.len() {

            0 => Ok((None, None)),

            1 => Ok((Some(args.get_item(0)?), None)),

            2 => Ok((Some(args.get_item(0)?), Some(args.get_item(1)?))),

            _ => Err(PyTypeError::new_err("too many arguments")),

        }?;

        let stop_rev = stop_rev

            .map(|o| o.extract::<Option<i32>>())

            .transpose()?

            .flatten();

        let filtered_revs = filtered_revs.filter(|o| !o.is_none());

        let (from_core, stop_rev) = Self::with_index_read(slf, |idx| {

            let stop_rev = stop_rev

                // should this not just be the normal checking?

                .filter(|rev| 0 <= *rev && *rev < idx.len() as BaseRevision)

                .map(Revision);

            let from_core = if let Some(filtered_revs) = filtered_revs {

                let filtered_revs = rev_pyiter_collect(&filtered_revs, idx)?;

                idx.head_revs_advanced(

                    &filtered_revs,

                    stop_rev,

                    stop_rev.is_none(),

                )

            } else if stop_rev.is_some() {

                idx.head_revs_advanced(&HashSet::new(), stop_rev, false)

            } else {

                idx.head_revs_shortcut()

            }

            .map_err(graph_error)?;

            Ok((from_core, stop_rev))

        })?;

        if stop_rev.is_some() {

            // we don't cache result for now

            let new_heads =

                from_core.expect("this case should not be cached yet");

            revs_py_list(py, new_heads)

        } else {

            if let Some(new_heads) = from_core {

                Self::cache_new_heads_py_list(slf, new_heads)?;

            }

            Ok(slf

                .borrow()

                .head_revs_py_list

                .as_ref()

                .expect("head revs should be cached")

                .clone_ref(py))

        }

    }

    /// True if the object is a snapshot

    fn _index_issnapshot(

        slf: &Bound<'_, Self>,

        rev: PyRevision,

    ) -> PyResult<bool> {

        let rev: UncheckedRevision = rev.into();

        let rev = Self::with_index_read(slf, |idx| {

            idx.check_revision(rev).ok_or_else(|| rev_not_in_index(rev))

        })?;

            irl.is_snapshot(rev)

                .map_err(|e| PyValueError::new_err(e.to_string()))

        })

    }

    fn _index___len__(slf: &Bound<'_, Self>) -> PyResult<usize> {