// 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::types::{

    PyBool, PyBytes, PyBytesMethods, PyDict, PyList, PySet, PyTuple,

};

use pyo3_sharedref::{PyShareable, SharedByPyObject};

use std::collections::{HashMap, HashSet};

use std::sync::{

    atomic::{AtomicUsize, Ordering},

    RwLock, RwLockReadGuard, RwLockWriteGuard,

};

use hg::{

    errors::HgError,

    revlog::{

        index::{

            Index, Phase, RevisionDataParams, SnapshotsCache, INDEX_ENTRY_SIZE,

        },

        inner_revlog::InnerRevlog as CoreInnerRevlog,

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

        options::RevlogOpenOptions,

        RevlogError, RevlogIndex, RevlogType,

    },

    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, revs_py_set, 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();

    }

}

struct PySnapshotsCache<'a, 'py: 'a>(&'a Bound<'py, PyDict>);

impl<'a, 'py> PySnapshotsCache<'a, 'py> {

    fn insert_for_with_py_result(

        &self,

        rev: BaseRevision,

        value: BaseRevision,

    ) -> PyResult<()> {

        match self.0.get_item(rev)? {

            Some(obj) => obj.downcast::<PySet>()?.add(value),

            None => {

                let set = PySet::new(self.0.py(), vec![value])?;

                self.0.set_item(rev, set)

            }

        }

    }

}

impl<'a, 'py> SnapshotsCache for PySnapshotsCache<'a, 'py> {

    fn insert_for(

        &mut self,

        rev: BaseRevision,

        value: BaseRevision,

    ) -> Result<(), RevlogError> {

        self.insert_for_with_py_result(rev, value).map_err(|_| {

            RevlogError::Other(HgError::unsupported(

                "Error in Python caches handling",

            ))

        })

    }

}

#[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(())

        })

    }

    /// return the gca set of the given revs

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

    fn _index_ancestors(

        slf: &Bound<'_, Self>,

        revs: &Bound<'_, PyTuple>,

    ) -> PyResult<PyObject> {

        Self::with_index_read(slf, |idx| {

            let revs: Vec<_> = rev_pyiter_collect(revs, idx)?;

            Ok(PyList::new(

                slf.py(),

                idx.ancestors(&revs)

                    .map_err(graph_error)?

                    .into_iter()

                    .map(PyRevision::from),

            )?

            .into_any()

            .unbind())

        })

    }

    /// return the heads of the common ancestors of the given revs

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

    fn _index_commonancestorsheads(

        slf: &Bound<'_, Self>,

        revs: &Bound<'_, PyTuple>,

    ) -> PyResult<Py<PyList>> {

        Self::with_index_read(slf, |idx| {

            let revs: Vec<_> = rev_pyiter_collect(revs, idx)?;

            revs_py_list(

                slf.py(),

                idx.common_ancestor_heads(&revs).map_err(graph_error)?,

            )

        })

    }

    /// Clear the index caches and inner py_class data.

    /// It is Python's responsibility to call `update_nodemap_data` again.

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

        Self::with_index_write(slf, |idx| {

            idx.clear_caches();

            Ok(())

        })?;

        let mut self_ref = slf.borrow_mut();

        self_ref.nt.write().map_err(map_lock_error)?.take();

        self_ref.docket.take();

        self_ref.nodemap_mmap.take();

        self_ref.head_revs_py_list.take();

        self_ref.head_node_ids_py_list.take();

        Ok(())

    }

    /// return the raw binary string representing a revision

    fn _index_entry_binary(

        slf: &Bound<'_, Self>,

        rev: PyRevision,

    ) -> PyResult<Py<PyBytes>> {

        let rev: UncheckedRevision = rev.into();

        Self::with_index_read(slf, |idx| {

            idx.check_revision(rev)

                .and_then(|r| idx.entry_binary(r))

                .map(|rust_bytes| PyBytes::new(slf.py(), rust_bytes).unbind())

                .ok_or_else(|| rev_not_in_index(rev))

        })

    }

    /// return a binary packed version of the header

    fn _index_pack_header(

        slf: &Bound<'_, Self>,

        header: i32,

    ) -> PyResult<Py<PyBytes>> {

        let packed =

            Self::with_index_read(slf, |idx| Ok(idx.pack_header(header)))?;

        Ok(PyBytes::new(slf.py(), &packed).unbind())

    }

    /// compute phases

    fn _index_computephasesmapsets(

        slf: &Bound<'_, Self>,

        py: Python<'_>,

        roots: &Bound<'_, PyDict>,

    ) -> PyResult<Py<PyTuple>> {

        let (len, phase_maps) = Self::with_index_read(slf, |idx| {

            let extracted_roots: PyResult<HashMap<Phase, Vec<Revision>>> =

                roots

                    .iter()

                    .map(|(phase, revs)| {

                        let phase = Phase::try_from(phase.extract::<usize>()?)

                            .map_err(|_| revlog_error_bare())?;

                        let revs: Vec<Revision> =

                            rev_pyiter_collect(&revs, idx)?;

                        Ok((phase, revs))

                    })

                    .collect();

            idx.compute_phases_map_sets(extracted_roots?)

                .map_err(graph_error)

        })?;

        // Ugly hack, but temporary (!)

        const IDX_TO_PHASE_NUM: [usize; 4] = [1, 2, 32, 96];

        let py_phase_maps = PyDict::new(py);

        for (i, roots) in phase_maps.into_iter().enumerate() {

            py_phase_maps.set_item(

                IDX_TO_PHASE_NUM[i],

                revs_py_set(py, roots)?.into_any(),

            )?;

        }

        Ok((len, py_phase_maps).into_pyobject(py)?.unbind())

    }

    /// 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()?);