#![allow(non_snake_case)]

    pybytes_deref::{PyBufferDeref, PyBytesDeref},

    vfs::PyVfs,

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

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

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

    revlog::compression::CompressionConfig,

    revlog::inner_revlog::InnerRevlog as CoreInnerRevlog,

    revlog::inner_revlog::RevisionBuffer,

    revlog::options::{

        RevlogDataConfig, RevlogDeltaConfig, RevlogFeatureConfig,

        RevlogOpenOptions,

    transaction::Transaction,

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

    BaseRevision, Node, Revision, RevlogType, UncheckedRevision,

    NULL_REVISION,

    cell::{Cell, RefCell},

    sync::OnceLock,

    index_proxy: PyObject,

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

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

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

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

        .expect("nodeid should be set");

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

    match py

        .import("mercurial.error")