use bytes_cast::BytesCast;

use micro_timer::timed;

use std::borrow::Cow;

use std::convert::TryInto;

use std::path::PathBuf;

use super::on_disk;

use super::on_disk::DirstateV2ParseError;

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::parsers::Timestamp;

use crate::matchers::Matcher;

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

use crate::CopyMapIter;

use crate::DirstateEntry;

use crate::DirstateError;

use crate::DirstateParents;

use crate::DirstateStatus;

use crate::EntryState;

use crate::FastHashMap;

use crate::PatternFileWarning;

use crate::StateMapIter;

use crate::StatusError;

use crate::StatusOptions;

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,

}

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

pub(super) enum ChildNodes<'on_disk> {

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

}

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

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

}

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

    InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'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),

        }

    }

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

        match self {

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

        }

    }

    pub(super) fn make_mut(

        &mut self,

    ) -> Result<

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

        DirstateV2ParseError,

    > {

        match self {

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

        }

    }

}

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

    pub(super) fn get(

        &self,

        base_name: &HgPath,

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

        }

    }

    /// Iterate in undefined order

    pub(super) fn iter(

        &self,

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

        match self {

            }

        }

    }

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

        }

    }

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

                    }

                }

                // `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

            }

        }

    }

}

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

    pub(super) fn full_path(

        &self,

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

        match self {

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

        }

    }

    /// Returns a `Cow` that can borrow 'on_disk but is detached from 'tree

    pub(super) fn full_path_cow(

        &self,

    ) -> Result<Cow<'on_disk, HgPath>, DirstateV2ParseError> {

        match self {

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

        }

    }

    pub(super) fn base_name(

        &self,

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

        match self {

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

        }

    }

    pub(super) fn children(

        &self,

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

        match self {

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

        }

    }

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

        match self {

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

        }

    }

    pub(super) fn copy_source(

        &self,

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

        match self {

            NodeRef::InMemory(_path, node) => {

                Ok(node.copy_source.as_ref().map(|s| &**s))

            }

        }

    }

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

        match self {

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

        }

    }

    pub(super) fn entry(

        &self,

    ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {

        match self {

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

        }

    }

    pub(super) fn state(

        &self,

    ) -> Result<Option<EntryState>, DirstateV2ParseError> {

        match self {

            NodeRef::InMemory(_path, node) => {

                Ok(node.entry.as_ref().map(|entry| entry.state))

            }

        }

    }

    pub(super) fn tracked_descendants_count(&self) -> u32 {

        match self {

            NodeRef::InMemory(_path, node) => node.tracked_descendants_count,

        }

    }

}

/// Represents a file or a directory

#[derive(Default)]

pub(super) struct Node<'on_disk> {

    /// `None` for directories

    pub(super) entry: Option<DirstateEntry>,

    pub(super) copy_source: Option<Cow<'on_disk, HgPath>>,

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

    /// How many (non-inclusive) descendants of this node are tracked files

    pub(super) tracked_descendants_count: u32,

}

impl<'on_disk> DirstateMap<'on_disk> {

    pub(super) fn empty(on_disk: &'on_disk [u8]) -> Self {

        Self {

            on_disk,

            root: ChildNodes::default(),

            nodes_with_entry_count: 0,

            nodes_with_copy_source_count: 0,

        }

    }

    #[timed]

    pub fn new_v2(