use crate::changelog::Changelog;

use crate::config::{Config, ConfigError, ConfigParseError};

use crate::dirstate::DirstateParents;

use crate::dirstate_tree::dirstate_map::{

    DirstateIdentity, DirstateMapWriteMode,

};

use crate::dirstate_tree::on_disk::Docket as DirstateDocket;

use crate::dirstate_tree::owning::OwningDirstateMap;

use crate::errors::HgResultExt;

use crate::errors::{HgError, IoResultExt};

use crate::lock::{try_with_lock_no_wait, LockError};

use crate::manifest::{Manifest, Manifestlog};

use crate::revlog::filelog::Filelog;

use crate::revlog::RevlogError;

use crate::utils::debug::debug_wait_for_file_or_print;

use crate::utils::files::get_path_from_bytes;

use crate::utils::hg_path::HgPath;

use crate::utils::SliceExt;

use crate::vfs::{is_dir, is_file, VfsImpl};

use crate::{

};

use std::cell::{Ref, RefCell, RefMut};

use std::collections::HashSet;

use std::io::Seek;

use std::io::SeekFrom;

use std::io::Write as IoWrite;

use std::path::{Path, PathBuf};

const V2_MAX_READ_ATTEMPTS: usize = 5;

/// Docket file identity, data file uuid and the data size

type DirstateV2Identity = (Option<DirstateIdentity>, Option<Vec<u8>>, usize);

/// A repository on disk

pub struct Repo {

    working_directory: PathBuf,

    dot_hg: PathBuf,

    store: PathBuf,

    requirements: HashSet<String>,

    config: Config,

    dirstate_parents: LazyCell<DirstateParents>,

    dirstate_map: LazyCell<OwningDirstateMap>,

    changelog: LazyCell<Changelog>,

    manifestlog: LazyCell<Manifestlog>,

}

#[derive(Debug, derive_more::From)]

pub enum RepoError {

    NotFound {

        at: PathBuf,

    },

    #[from]

    ConfigParseError(ConfigParseError),

    #[from]

    Other(HgError),

}

impl From<ConfigError> for RepoError {

    fn from(error: ConfigError) -> Self {

        match error {

            ConfigError::Parse(error) => error.into(),

            ConfigError::Other(error) => error.into(),

        }

    }

}

impl From<RepoError> for HgError {

    fn from(value: RepoError) -> Self {

        match value {

            RepoError::NotFound { at } => HgError::abort(

                format!(

                    "abort: no repository found in '{}' (.hg not found)!",

                    at.display()

                ),

                exit_codes::ABORT,

                None,

            ),

            RepoError::ConfigParseError(config_parse_error) => {

                HgError::Abort {

                    message: String::from_utf8_lossy(

                        &config_parse_error.message,

                    )

                    .to_string(),

                    detailed_exit_code: exit_codes::CONFIG_PARSE_ERROR_ABORT,

                    hint: None,

                }

            }

            RepoError::Other(hg_error) => hg_error,

        }

    }

}

impl Repo {

    /// tries to find nearest repository root in current working directory or

    /// its ancestors

    pub fn find_repo_root() -> Result<PathBuf, RepoError> {

        let current_directory = crate::utils::current_dir()?;

        // ancestors() is inclusive: it first yields `current_directory`

        // as-is.

        for ancestor in current_directory.ancestors() {

            if is_dir(ancestor.join(".hg"))? {

                return Ok(ancestor.to_path_buf());

            }

        }

        Err(RepoError::NotFound {

            at: current_directory,

        })

    }

    /// Find a repository, either at the given path (which must contain a `.hg`

    /// sub-directory) or by searching the current directory and its

    /// ancestors.

    ///

    /// A method with two very different "modes" like this usually a code smell

    /// to make two methods instead, but in this case an `Option` is what rhg

    /// sub-commands get from Clap for the `-R` / `--repository` CLI argument.

    /// Having two methods would just move that `if` to almost all callers.

    pub fn find(

        config: &Config,

        explicit_path: Option<PathBuf>,

    ) -> Result<Self, RepoError> {

        if let Some(root) = explicit_path {

            if is_dir(root.join(".hg"))? {

                Self::new_at_path(root, config)

            } else if is_file(&root)? {

                Err(HgError::unsupported("bundle repository").into())

            } else {

                Err(RepoError::NotFound { at: root })

            }

        } else {

            let root = Self::find_repo_root()?;

            Self::new_at_path(root, config)

        }

    }

    /// To be called after checking that `.hg` is a sub-directory

    fn new_at_path(

        working_directory: PathBuf,

        config: &Config,

    ) -> Result<Self, RepoError> {

        let dot_hg = working_directory.join(".hg");

        let mut repo_config_files =

            vec![dot_hg.join("hgrc"), dot_hg.join("hgrc-not-shared")];

        let hg_vfs = VfsImpl {

            base: dot_hg.to_owned(),

        };

        let mut reqs = requirements::load_if_exists(&hg_vfs)?;

        let relative =

            reqs.contains(requirements::RELATIVE_SHARED_REQUIREMENT);

        let shared =

            reqs.contains(requirements::SHARED_REQUIREMENT) || relative;

        // From `mercurial/localrepo.py`:

        //

        // if .hg/requires contains the sharesafe requirement, it means

        // there exists a `.hg/store/requires` too and we should read it

        // NOTE: presence of SHARESAFE_REQUIREMENT imply that store requirement

        // is present. We never write SHARESAFE_REQUIREMENT for a repo if store

        // is not present, refer checkrequirementscompat() for that

        //

        // However, if SHARESAFE_REQUIREMENT is not present, it means that the

        // repository was shared the old way. We check the share source

        // .hg/requires for SHARESAFE_REQUIREMENT to detect whether the

        // current repository needs to be reshared

        let share_safe = reqs.contains(requirements::SHARESAFE_REQUIREMENT);

        let store_path;

        if !shared {

            store_path = dot_hg.join("store");

        } else {

            let bytes = hg_vfs.read("sharedpath")?;

            let mut shared_path =

                get_path_from_bytes(bytes.trim_end_matches(|b| b == b'\n'))

                    .to_owned();

            if relative {

                shared_path = dot_hg.join(shared_path)

            }

            if !is_dir(&shared_path)? {

                return Err(HgError::corrupted(format!(

                    ".hg/sharedpath points to nonexistent directory {}",

                    shared_path.display()

                ))

                .into());

            }

            store_path = shared_path.join("store");

            let source_is_share_safe = requirements::load(VfsImpl {

                base: shared_path.to_owned(),

            })?

            .contains(requirements::SHARESAFE_REQUIREMENT);

            if share_safe != source_is_share_safe {

                return Err(HgError::unsupported("share-safe mismatch").into());

            }

            if share_safe {

                repo_config_files.insert(0, shared_path.join("hgrc"))

            }

        }

        if share_safe {

            reqs.extend(requirements::load(VfsImpl {

                base: store_path.to_owned(),

            })?);

        }

        let repo_config = if std::env::var_os("HGRCSKIPREPO").is_none() {

            config.combine_with_repo(&repo_config_files)?

        } else {

            config.clone()

        };

        let repo = Self {

            requirements: reqs,

            working_directory,

            store: store_path,

            dot_hg,

            config: repo_config,

            dirstate_parents: LazyCell::new(),

            dirstate_map: LazyCell::new(),

            changelog: LazyCell::new(),

            manifestlog: LazyCell::new(),

        };

        requirements::check(&repo)?;

        Ok(repo)

    }

    pub fn working_directory_path(&self) -> &Path {

        &self.working_directory

    }

    pub fn requirements(&self) -> &HashSet<String> {

        &self.requirements

    }

    pub fn config(&self) -> &Config {

        &self.config

    }

    /// For accessing repository files (in `.hg`), except for the store

    /// (`.hg/store`).

    pub fn hg_vfs(&self) -> VfsImpl {

        VfsImpl {

            base: self.dot_hg.to_owned(),

        }

    }

    /// For accessing repository store files (in `.hg/store`)

    pub fn store_vfs(&self) -> VfsImpl {

        VfsImpl {

            base: self.store.to_owned(),

        }

    }

    /// For accessing the working copy

    pub fn working_directory_vfs(&self) -> VfsImpl {

        VfsImpl {

            base: self.working_directory.to_owned(),

        }

    }

    pub fn try_with_wlock_no_wait<R>(

        &self,

        f: impl FnOnce() -> R,

    ) -> Result<R, LockError> {

        try_with_lock_no_wait(&self.hg_vfs(), "wlock", f)

    }

    /// Whether this repo should use dirstate-v2.

    /// The presence of `dirstate-v2` in the requirements does not mean that

    /// the on-disk dirstate is necessarily in version 2. In most cases,

    /// a dirstate-v2 file will indeed be found, but in rare cases (like the

    /// upgrade mechanism being cut short), the on-disk version will be a

    /// v1 file.

    /// Semantically, having a requirement only means that a client cannot

    /// properly understand or properly update the repo if it lacks the support

    /// for the required feature, but not that that feature is actually used

    /// in all occasions.

    pub fn use_dirstate_v2(&self) -> bool {

        self.requirements

            .contains(requirements::DIRSTATE_V2_REQUIREMENT)

    }

    pub fn has_sparse(&self) -> bool {

        self.requirements.contains(requirements::SPARSE_REQUIREMENT)

    }

    pub fn has_narrow(&self) -> bool {

        self.requirements.contains(requirements::NARROW_REQUIREMENT)

    }

    pub fn has_nodemap(&self) -> bool {

        self.requirements

            .contains(requirements::NODEMAP_REQUIREMENT)

    }

    fn dirstate_file_contents(&self) -> Result<Vec<u8>, HgError> {

        Ok(self

            .hg_vfs()

            .read("dirstate")

            .io_not_found_as_none()?

            .unwrap_or_default())

    }

    fn dirstate_identity(&self) -> Result<Option<DirstateIdentity>, HgError> {

        Ok(self

            .hg_vfs()

            .symlink_metadata("dirstate")

            .io_not_found_as_none()?

            .map(DirstateIdentity::from))

    }

    pub fn dirstate_parents(&self) -> Result<DirstateParents, HgError> {

        Ok(*self

            .dirstate_parents

            .get_or_init(|| self.read_dirstate_parents())?)

    }

    fn read_dirstate_parents(&self) -> Result<DirstateParents, HgError> {

        let dirstate = self.dirstate_file_contents()?;

        let parents = if dirstate.is_empty() {

            DirstateParents::NULL

        } else if self.use_dirstate_v2() {

            let docket_res =

                crate::dirstate_tree::on_disk::read_docket(&dirstate);

            match docket_res {

                Ok(docket) => docket.parents(),

                Err(_) => {

                    log::info!(

                        "Parsing dirstate docket failed, \

                        falling back to dirstate-v1"

                    );

                    *crate::dirstate::parsers::parse_dirstate_parents(

                        &dirstate,

                    )?

                }

            }

        } else {

            *crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?

        };

        self.dirstate_parents.set(parents);

        Ok(parents)

    }

    /// Returns the information read from the dirstate docket necessary to

    /// check if the data file has been updated/deleted by another process

    /// since we last read the dirstate.

    /// Namely the docket file identity, data file uuid and the data size.

    fn get_dirstate_data_file_integrity(

        &self,

    ) -> Result<DirstateV2Identity, HgError> {

        assert!(

            self.use_dirstate_v2(),

            "accessing dirstate data file ID without dirstate-v2"

        );

        // Get the identity before the contents since we could have a race

        // between the two. Having an identity that is too old is fine, but

        // one that is younger than the content change is bad.

        let identity = self.dirstate_identity()?;

        let dirstate = self.dirstate_file_contents()?;

        if dirstate.is_empty() {

            Ok((identity, None, 0))

        } else {

            let docket_res =

                crate::dirstate_tree::on_disk::read_docket(&dirstate);

            match docket_res {

                Ok(docket) => {

                    self.dirstate_parents.set(docket.parents());

                    Ok((

                        identity,

                        Some(docket.uuid.to_owned()),

                        docket.data_size(),

                    ))

                }

                Err(_) => {

                    log::info!(

                        "Parsing dirstate docket failed, \

                        falling back to dirstate-v1"

                    );

                    let parents =

                        *crate::dirstate::parsers::parse_dirstate_parents(

                            &dirstate,

                        )?;

                    self.dirstate_parents.set(parents);

                    Ok((identity, None, 0))

                }

            }

        }

    }

    fn new_dirstate_map(&self) -> Result<OwningDirstateMap, DirstateError> {

        if self.use_dirstate_v2() {

            // The v2 dirstate is split into a docket and a data file.

            // Since we don't always take the `wlock` to read it

            // (like in `hg status`), it is susceptible to races.

            // A simple retry method should be enough since full rewrites

            // only happen when too much garbage data is present and

            // this race is unlikely.

            let mut tries = 0;

            while tries < V2_MAX_READ_ATTEMPTS {

                tries += 1;

                match self.read_docket_and_data_file() {

                    Ok(m) => {

                        return Ok(m);

                    }

                    Err(e) => match e {

                        DirstateError::Common(HgError::RaceDetected(

                            context,

                        )) => {

                            log::info!(

                                "dirstate read race detected {} (retry {}/{})",

                                context,

                                tries,

                                V2_MAX_READ_ATTEMPTS,

                            );

                            continue;

                        }

                        _ => {

                            log::info!(

                                "Reading dirstate v2 failed, \

                                falling back to v1"

                            );

                            return self.new_dirstate_map_v1();

                        }

                    },

                }

            }

            let error = HgError::abort(

                format!("dirstate read race happened {tries} times in a row"),

                255,

                None,

            );

            Err(DirstateError::Common(error))

        } else {

            self.new_dirstate_map_v1()

        }

    }

    fn new_dirstate_map_v1(&self) -> Result<OwningDirstateMap, DirstateError> {

        debug_wait_for_file_or_print(self.config(), "dirstate.pre-read-file");

        let identity = self.dirstate_identity()?;

        let dirstate_file_contents = self.dirstate_file_contents()?;

        let parents = self.dirstate_parents()?;

        if dirstate_file_contents.is_empty() {

            self.dirstate_parents.set(parents);

            Ok(OwningDirstateMap::new_empty(Vec::new(), identity))

        } else {

            // Ignore the dirstate on-disk parents, they may have been set in

            // the repo before

            let (map, _) =

                OwningDirstateMap::new_v1(dirstate_file_contents, identity)?;

            self.dirstate_parents.set(parents);

            Ok(map)

        }

    }

    fn read_docket_and_data_file(

        &self,

    ) -> Result<OwningDirstateMap, DirstateError> {

        debug_wait_for_file_or_print(self.config(), "dirstate.pre-read-file");

        let dirstate_file_contents = self.dirstate_file_contents()?;

        let identity = self.dirstate_identity()?;

        if dirstate_file_contents.is_empty() {

            return Ok(OwningDirstateMap::new_empty(Vec::new(), identity));

        }

        let docket = crate::dirstate_tree::on_disk::read_docket(

            &dirstate_file_contents,

        )?;

        debug_wait_for_file_or_print(

            self.config(),

            "dirstate.post-docket-read-file",

        );

        self.dirstate_parents.set(docket.parents());

        let uuid = docket.uuid.to_owned();

        let data_size = docket.data_size();

        let context = "between reading dirstate docket and data file";