// 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 hg::revlog::index::IndexHeader;

use hg::revlog::nodemap::Block;

use hg::utils::files::get_bytes_from_path;

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::{prelude::*, IntoPyObjectExt};

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,

};

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

        })

    }

    #[getter]

    fn canonical_index_file(

        slf: &Bound<'_, Self>,

        py: Python<'_>,

    ) -> PyResult<Py<PyBytes>> {

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

            let path = irl.canonical_index_file();

            Ok(PyBytes::new(py, &get_bytes_from_path(path)).into())

        })

    }

    #[getter]

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

        Self::with_core_read(slf, |_self_ref, irl| Ok(irl.is_delaying()))

    }

    #[getter]

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

        Self::with_core_read(slf, |_self_ref, irl| Ok(irl.is_inline()))

    }

    #[setter]

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

        Self::with_core_write(slf, |_self_ref, mut irl| {

            irl.inline = inline;

            Ok(())

        })

    }

    #[getter]

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

        Self::with_core_read(slf, |_self_ref, irl| Ok(irl.is_writing()))

    }

    #[getter]

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

        Self::with_core_read(slf, |_self_ref, irl| Ok(irl.is_open()))

    }

    #[getter]

    fn index_file(

        slf: &Bound<'_, Self>,

        py: Python<'_>,

    ) -> PyResult<Py<PyBytes>> {

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

            let path = get_bytes_from_path(&irl.index_file);

            Ok(PyBytes::new(py, &path).unbind())

        })

    }

    #[setter]

    fn set_index_file(

        slf: &Bound<'_, Self>,

        path: &Bound<'_, PyBytes>,

    ) -> PyResult<()> {

        Self::with_core_write(slf, |_self_ref, mut irl| {

            let path = get_path_from_bytes(path.as_bytes());

            path.clone_into(&mut irl.index_file);

            Ok(())

        })

    }

    fn issnapshot(slf: &Bound<'_, Self>, rev: PyRevision) -> PyResult<bool> {

        Self::_index_issnapshot(slf, rev)

    }

    #[pyo3(signature = (rev, stoprev=None))]

    fn _deltachain(

        slf: &Bound<'_, Self>,

        py: Python<'_>,

        rev: PyRevision,

        stoprev: Option<PyRevision>,

    ) -> PyResult<Py<PyTuple>> {

        Self::with_index_read(slf, |idx| {

            let using_general_delta = idx.uses_generaldelta();

            Self::_index_deltachain(

                slf,

                py,

                rev,

                stoprev,

                Some(using_general_delta.into()),

            )

        })

    }

    fn compress(

        slf: &Bound<'_, Self>,

        py: Python<'_>,

        data: &Bound<'_, PyAny>,

    ) -> PyResult<Py<PyTuple>> {

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

            // Safety: we only hold on to the data for as long as `_buf`

            // is alive

            let (_buf, data) = unsafe { take_buffer_with_slice(data)? };

            let compressed =

                irl.compress(&data).map_err(revlog_error_from_msg)?;

            let compressed = compressed.as_deref();

            let header = if compressed.is_some() {

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

            } else {

                PyBytes::new(py, &b"u"[..])

            };

            Ok(PyTuple::new(

                py,

                &[header, PyBytes::new(py, compressed.unwrap_or(&data))],

            )?

            .unbind())

        })

    }

    #[pyo3(signature = (tr, header, new_index_file_path=None))]

    fn split_inline(

        slf: &Bound<'_, Self>,

        py: Python<'_>,

        tr: PyObject,

        header: i32,

        new_index_file_path: Option<&Bound<'_, PyBytes>>,

    ) -> PyResult<Py<PyBytes>> {

        // Also unused in Python, TODO clean this up.

        let _ = tr;

        Self::with_core_write(slf, |_self_ref, mut irl| {

            let new_index_file_path = new_index_file_path

                .map(|path| get_path_from_bytes(path.as_bytes()).to_owned());

            let header = IndexHeader::parse(&header.to_be_bytes())

                .expect("invalid header bytes");

            let old_path = irl

                .split_inline(header, new_index_file_path)

                .map_err(revlog_error_from_msg)?;

            Ok(PyBytes::new(py, &get_bytes_from_path(old_path)).unbind())

        })

    }

    fn get_segment_for_revs(

        slf: &Bound<'_, Self>,

        py: Python<'_>,

        startrev: PyRevision,

        endrev: PyRevision,

    ) -> PyResult<Py<PyTuple>> {

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

            // Here both revisions only come from revlog code, so we assume

            // them to be valid.

            // Panics will alert the offending programmer if not.

            let (offset, data) = irl

                .get_segment_for_revs(Revision(startrev.0), Revision(endrev.0))

                .map_err(revlog_error_from_msg)?;

            let data = PyBytes::new(py, &data);

            Ok(PyTuple::new(

                py,

                &[offset.into_py_any(py)?, data.into_py_any(py)?],

            )?

            .unbind())

        })

    }

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