use bytes_cast::BytesCast;

use std::borrow::Cow;

use std::path::PathBuf;

use super::on_disk;

use super::on_disk::DirstateV2ParseError;

use super::owning::OwningDirstateMap;

use super::path_with_basename::WithBasename;

use crate::dirstate::parsers::pack_entry;

use crate::dirstate::parsers::packed_entry_size;

use crate::dirstate::parsers::parse_dirstate_entries;

use crate::dirstate::CopyMapIter;

use crate::dirstate::DirstateV2Data;

use crate::dirstate::ParentFileData;

use crate::dirstate::StateMapIter;

use crate::dirstate::TruncatedTimestamp;

use crate::matchers::Matcher;

use crate::utils::hg_path::{HgPath, HgPathBuf};

use crate::DirstateEntry;

use crate::DirstateError;

use crate::DirstateMapError;

use crate::DirstateParents;

use crate::DirstateStatus;

use crate::FastHashbrownMap as FastHashMap;

use crate::PatternFileWarning;

use crate::StatusError;

use crate::StatusOptions;

/// Append to an existing data file if the amount of unreachable data (not used

/// anymore) is less than this fraction of the total amount of existing data.

const ACCEPTABLE_UNREACHABLE_BYTES_RATIO: f32 = 0.5;

#[derive(Debug, PartialEq, Eq)]

/// Version of the on-disk format

pub enum DirstateVersion {

    V1,

    V2,

}

#[derive(Debug)]

pub struct DirstateMap<'on_disk> {

    /// Contents of the `.hg/dirstate` file

    pub(super) on_disk: &'on_disk [u8],

    pub(super) root: ChildNodes<'on_disk>,

    /// Number of nodes anywhere in the tree that have `.entry.is_some()`.

    pub(super) nodes_with_entry_count: u32,

    /// Number of nodes anywhere in the tree that have

    /// `.copy_source.is_some()`.

    pub(super) nodes_with_copy_source_count: u32,

    /// See on_disk::Header

    pub(super) ignore_patterns_hash: on_disk::IgnorePatternsHash,

    /// How many bytes of `on_disk` are not used anymore

    pub(super) unreachable_bytes: u32,

    /// Size of the data used to first load this `DirstateMap`. Used in case

    /// we need to write some new metadata, but no new data on disk.

    pub(super) old_data_size: usize,

    pub(super) dirstate_version: DirstateVersion,

}

/// Using a plain `HgPathBuf` of the full path from the repository root as a

/// map key would also work: all paths in a given map have the same parent

/// path, so comparing full paths gives the same result as comparing base

/// names. However `HashMap` would waste time always re-hashing the same

/// string prefix.

pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>;

/// Similar to `&'tree Cow<'on_disk, HgPath>`, but can also be returned

/// for on-disk nodes that don’t actually have a `Cow` to borrow.

#[derive(Debug)]

pub(super) enum BorrowedPath<'tree, 'on_disk> {

    InMemory(&'tree HgPathBuf),

    OnDisk(&'on_disk HgPath),

}

#[derive(Debug)]

pub(super) enum ChildNodes<'on_disk> {

    InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),

    OnDisk(&'on_disk [on_disk::Node]),

}

#[derive(Debug)]

pub(super) enum ChildNodesRef<'tree, 'on_disk> {

    InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),

    OnDisk(&'on_disk [on_disk::Node]),

}

#[derive(Debug)]

pub(super) enum NodeRef<'tree, 'on_disk> {

    InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>),

    OnDisk(&'on_disk on_disk::Node),

}

impl<'tree, 'on_disk> BorrowedPath<'tree, 'on_disk> {

    pub fn detach_from_tree(&self) -> Cow<'on_disk, HgPath> {

        match *self {

            BorrowedPath::InMemory(in_memory) => Cow::Owned(in_memory.clone()),

            BorrowedPath::OnDisk(on_disk) => Cow::Borrowed(on_disk),

        }

    }

}

impl<'tree, 'on_disk> std::ops::Deref for BorrowedPath<'tree, 'on_disk> {

    type Target = HgPath;

    fn deref(&self) -> &HgPath {

        match *self {

            BorrowedPath::InMemory(in_memory) => in_memory,

            BorrowedPath::OnDisk(on_disk) => on_disk,

        }

    }

}

impl Default for ChildNodes<'_> {

    fn default() -> Self {

        ChildNodes::InMemory(Default::default())

    }

}

impl<'on_disk> ChildNodes<'on_disk> {

    pub(super) fn as_ref<'tree>(

        &'tree self,

    ) -> ChildNodesRef<'tree, 'on_disk> {

        match self {

            ChildNodes::InMemory(nodes) => ChildNodesRef::InMemory(nodes),

            ChildNodes::OnDisk(nodes) => ChildNodesRef::OnDisk(nodes),

        }

    }

    pub(super) fn is_empty(&self) -> bool {

        match self {

            ChildNodes::InMemory(nodes) => nodes.is_empty(),

            ChildNodes::OnDisk(nodes) => nodes.is_empty(),

        }

    }

    fn make_mut(

        &mut self,

        on_disk: &'on_disk [u8],

        unreachable_bytes: &mut u32,

    ) -> Result<

        &mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>,

        DirstateV2ParseError,

    > {

        match self {

            ChildNodes::InMemory(nodes) => Ok(nodes),

            ChildNodes::OnDisk(nodes) => {

                *unreachable_bytes +=

                    std::mem::size_of_val::<[on_disk::Node]>(nodes) as u32;

                let nodes = nodes

                    .iter()

                    .map(|node| {

                        Ok((

                            node.path(on_disk)?,

                            node.to_in_memory_node(on_disk)?,

                        ))

                    })

                    .collect::<Result<_, _>>()?;

                *self = ChildNodes::InMemory(nodes);

                match self {

                    ChildNodes::InMemory(nodes) => Ok(nodes),

                    ChildNodes::OnDisk(_) => unreachable!(),

                }

            }

        }

    }

}

impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> {

    pub(super) fn get(

        &self,

        base_name: &HgPath,

        on_disk: &'on_disk [u8],

    ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {

        match self {

            ChildNodesRef::InMemory(nodes) => Ok(nodes

                .get_key_value(base_name)

                .map(|(k, v)| NodeRef::InMemory(k, v))),

            ChildNodesRef::OnDisk(nodes) => {

                let mut parse_result = Ok(());

                let search_result = nodes.binary_search_by(|node| {

                    match node.base_name(on_disk) {

                        Ok(node_base_name) => node_base_name.cmp(base_name),

                        Err(e) => {

                            parse_result = Err(e);

                            // Dummy comparison result, `search_result` won’t

                            // be used since `parse_result` is an error

                            std::cmp::Ordering::Equal

                        }

                    }

                });

                parse_result.map(|()| {

                    search_result.ok().map(|i| NodeRef::OnDisk(&nodes[i]))

                })

            }

        }

    }

    /// Iterate in undefined order

    pub(super) fn iter(

        &self,

    ) -> impl Iterator<Item = NodeRef<'tree, 'on_disk>> {

        match self {

            ChildNodesRef::InMemory(nodes) => itertools::Either::Left(

                nodes.iter().map(|(k, v)| NodeRef::InMemory(k, v)),

            ),

            ChildNodesRef::OnDisk(nodes) => {

                itertools::Either::Right(nodes.iter().map(NodeRef::OnDisk))

            }

        }

    }

    /// Iterate in parallel in undefined order

    pub(super) fn par_iter(

        &self,

    ) -> impl rayon::iter::ParallelIterator<Item = NodeRef<'tree, 'on_disk>>

    {

        use rayon::prelude::*;

        match self {

            ChildNodesRef::InMemory(nodes) => rayon::iter::Either::Left(

                nodes.par_iter().map(|(k, v)| NodeRef::InMemory(k, v)),

            ),

            ChildNodesRef::OnDisk(nodes) => rayon::iter::Either::Right(

                nodes.par_iter().map(NodeRef::OnDisk),

            ),

        }

    }

    pub(super) fn sorted(&self) -> Vec<NodeRef<'tree, 'on_disk>> {

        match self {

            ChildNodesRef::InMemory(nodes) => {

                let mut vec: Vec<_> = nodes

                    .iter()

                    .map(|(k, v)| NodeRef::InMemory(k, v))

                    .collect();

                fn sort_key<'a>(node: &'a NodeRef) -> &'a HgPath {

                    match node {

                        NodeRef::InMemory(path, _node) => path.base_name(),

                        NodeRef::OnDisk(_) => unreachable!(),

                    }

                }

                // `sort_unstable_by_key` doesn’t allow keys borrowing from the

                // value: https://github.com/rust-lang/rust/issues/34162

                vec.sort_unstable_by(|a, b| sort_key(a).cmp(sort_key(b)));

                vec

            }

            ChildNodesRef::OnDisk(nodes) => {

                // Nodes on disk are already sorted

                nodes.iter().map(NodeRef::OnDisk).collect()

            }

        }

    }

}

impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> {

    pub(super) fn full_path(

        &self,

        on_disk: &'on_disk [u8],

    ) -> Result<&'tree HgPath, DirstateV2ParseError> {

        match self {

            NodeRef::InMemory(path, _node) => Ok(path.full_path()),

            NodeRef::OnDisk(node) => node.full_path(on_disk),

        }

    }

    /// Returns a `BorrowedPath`, which can be turned into a `Cow<'on_disk,

    /// HgPath>` detached from `'tree`

    pub(super) fn full_path_borrowed(

        &self,

        on_disk: &'on_disk [u8],

    ) -> Result<BorrowedPath<'tree, 'on_disk>, DirstateV2ParseError> {

        match self {

            NodeRef::InMemory(path, _node) => match path.full_path() {

                Cow::Borrowed(on_disk) => Ok(BorrowedPath::OnDisk(on_disk)),

                Cow::Owned(in_memory) => Ok(BorrowedPath::InMemory(in_memory)),

            },

            NodeRef::OnDisk(node) => {

                Ok(BorrowedPath::OnDisk(node.full_path(on_disk)?))

            }

        }

    }

    pub(super) fn base_name(

        &self,

        on_disk: &'on_disk [u8],

    ) -> Result<&'tree HgPath, DirstateV2ParseError> {

        match self {

            NodeRef::InMemory(path, _node) => Ok(path.base_name()),

            NodeRef::OnDisk(node) => node.base_name(on_disk),

        }

    }

    pub(super) fn children(

        &self,

        on_disk: &'on_disk [u8],

    ) -> Result<ChildNodesRef<'tree, 'on_disk>, DirstateV2ParseError> {

        match self {

            NodeRef::InMemory(_path, node) => Ok(node.children.as_ref()),

            NodeRef::OnDisk(node) => {

                Ok(ChildNodesRef::OnDisk(node.children(on_disk)?))

            }

        }

    }

    pub(super) fn has_copy_source(&self) -> bool {

        match self {

            NodeRef::InMemory(_path, node) => node.copy_source.is_some(),

            NodeRef::OnDisk(node) => node.has_copy_source(),

        }

    }

    pub(super) fn copy_source(

        &self,

        on_disk: &'on_disk [u8],

    ) -> Result<Option<&'tree HgPath>, DirstateV2ParseError> {

        match self {

            NodeRef::OnDisk(node) => node.copy_source(on_disk),

        }

    }

    /// Returns a `BorrowedPath`, which can be turned into a `Cow<'on_disk,

    /// HgPath>` detached from `'tree`

    pub(super) fn copy_source_borrowed(

        &self,