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::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::DirstateMapError;

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) type ChildNodes<'on_disk> =

    FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>;

/// 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> Node<'on_disk> {

    pub(super) fn state(&self) -> Option<EntryState> {

        self.entry.as_ref().map(|entry| entry.state)

    }

    pub(super) fn sorted<'tree>(

        nodes: &'tree ChildNodes<'on_disk>,

    ) -> Vec<(&'tree NodeKey<'on_disk>, &'tree Self)> {

        let mut vec: Vec<_> = nodes.iter().collect();

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

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

        vec.sort_unstable_by(|(path1, _), (path2, _)| path1.cmp(path2));

        vec

    }

}

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(

        on_disk: &'on_disk [u8],

    ) -> Result<(Self, Option<DirstateParents>), DirstateError> {

        on_disk::read(on_disk)

    }

    #[timed]

    pub fn new_v1(

        on_disk: &'on_disk [u8],

    ) -> Result<(Self, Option<DirstateParents>), DirstateError> {

        let mut map = Self::empty(on_disk);

        if map.on_disk.is_empty() {

            return Ok((map, None));

        }

        let parents = parse_dirstate_entries(

            map.on_disk,

            |path, entry, copy_source| {

                let tracked = entry.state.is_tracked();

                let node = Self::get_or_insert_node(

                    &mut map.root,

                    path,

                    WithBasename::to_cow_borrowed,

                    |ancestor| {

                        if tracked {

                            ancestor.tracked_descendants_count += 1

                        }

                    },

                );

                assert!(

                    node.entry.is_none(),

                    "duplicate dirstate entry in read"

                );

                assert!(

                    node.copy_source.is_none(),

                    "duplicate dirstate entry in read"

                );

                node.entry = Some(*entry);

                node.copy_source = copy_source.map(Cow::Borrowed);

                map.nodes_with_entry_count += 1;

                if copy_source.is_some() {

                    map.nodes_with_copy_source_count += 1

                }

            },

        )?;

        let parents = Some(parents.clone());

        Ok((map, parents))

    }

    fn get_node(&self, path: &HgPath) -> Option<&Node> {

        let mut children = &self.root;

        let mut components = path.components();

        let mut component =

            components.next().expect("expected at least one components");

        loop {

            let child = children.get(component)?;

            if let Some(next_component) = components.next() {

                component = next_component;

                children = &child.children;

            } else {

                return Some(child);

            }

        }

    }

    /// Returns a mutable reference to the node at `path` if it exists

    ///

    /// This takes `root` instead of `&mut self` so that callers can mutate

    /// other fields while the returned borrow is still valid

    fn get_node_mut<'tree>(

        root: &'tree mut ChildNodes<'on_disk>,

        path: &HgPath,

    ) -> Option<&'tree mut Node<'on_disk>> {

        let mut children = root;

        let mut components = path.components();

        let mut component =

            components.next().expect("expected at least one components");

        loop {

            let child = children.get_mut(component)?;

            if let Some(next_component) = components.next() {

                component = next_component;

                children = &mut child.children;

            } else {

                return Some(child);

            }

        }

    }

    fn get_or_insert_node<'tree, 'path>(

        root: &'tree mut ChildNodes<'on_disk>,

        path: &'path HgPath,

        to_cow: impl Fn(

            WithBasename<&'path HgPath>,

        ) -> WithBasename<Cow<'on_disk, HgPath>>,

        mut each_ancestor: impl FnMut(&mut Node),

    ) -> &'tree mut Node<'on_disk> {

        let mut child_nodes = root;

        let mut inclusive_ancestor_paths =

            WithBasename::inclusive_ancestors_of(path);

        let mut ancestor_path = inclusive_ancestor_paths

            .next()

            .expect("expected at least one inclusive ancestor");

        loop {

            // TODO: can we avoid allocating an owned key in cases where the

            // map already contains that key, without introducing double

            // lookup?

            let child_node =

                child_nodes.entry(to_cow(ancestor_path)).or_default();

            if let Some(next) = inclusive_ancestor_paths.next() {

                each_ancestor(child_node);

                ancestor_path = next;

                child_nodes = &mut child_node.children;

            } else {

                return child_node;

            }

        }

    }

    fn add_or_remove_file(

        &mut self,

        path: &HgPath,

        old_state: EntryState,

        new_entry: DirstateEntry,

    ) {

        let tracked_count_increment =

            match (old_state.is_tracked(), new_entry.state.is_tracked()) {

                (false, true) => 1,

                (true, false) => -1,

                _ => 0,

            };

        let node = Self::get_or_insert_node(

            &mut self.root,

            path,

            WithBasename::to_cow_owned,

            |ancestor| {

                // We can’t use `+= increment` because the counter is unsigned,

                // and we want debug builds to detect accidental underflow

                // through zero

                match tracked_count_increment {

                    1 => ancestor.tracked_descendants_count += 1,

                    -1 => ancestor.tracked_descendants_count -= 1,

                    _ => {}

                }

            },

        );

        if node.entry.is_none() {

            self.nodes_with_entry_count += 1

        }

        node.entry = Some(new_entry)

    }

    fn iter_nodes<'a>(

        &'a self,

    ) -> impl Iterator<Item = (&'a Cow<'on_disk, HgPath>, &'a Node)> + 'a {

        // Depth first tree traversal.

        //

        // If we could afford internal iteration and recursion,

        // this would look like:

        //

        // ```

        // fn traverse_children(

        //     children: &ChildNodes,

        //     each: &mut impl FnMut(&Node),

        // ) {

        //     for child in children.values() {

        //         traverse_children(&child.children, each);

        //         each(child);

        //     }

        // }

        // ```

        //

        // However we want an external iterator and therefore can’t use the

        // call stack. Use an explicit stack instead:

        let mut stack = Vec::new();

        let mut iter = self.root.iter();

        std::iter::from_fn(move || {

            while let Some((key, child_node)) = iter.next() {

                // Pseudo-recursion

                let new_iter = child_node.children.iter();

                let old_iter = std::mem::replace(&mut iter, new_iter);

                let key = key.full_path();

                stack.push((key, child_node, old_iter));

            }

            // Found the end of a `children.iter()` iterator.

            if let Some((key, child_node, next_iter)) = stack.pop() {

                // "Return" from pseudo-recursion by restoring state from the

                // explicit stack

                iter = next_iter;

                Some((key, child_node))

            } else {

                // Reached the bottom of the stack, we’re done

                None

            }

        })

    }

    fn clear_known_ambiguous_mtimes(&mut self, paths: &[impl AsRef<HgPath>]) {

        for path in paths {

            if let Some(node) =

                Self::get_node_mut(&mut self.root, path.as_ref())

            {

                if let Some(entry) = node.entry.as_mut() {

                    entry.clear_mtime();

                }

            }

        }

    }

}

impl<'on_disk> super::dispatch::DirstateMapMethods for DirstateMap<'on_disk> {

    fn clear(&mut self) {

        self.root.clear();

        self.nodes_with_entry_count = 0;

        self.nodes_with_copy_source_count = 0;

    }

    fn add_file(

        &mut self,

        filename: &HgPath,

        old_state: EntryState,

        entry: DirstateEntry,

    ) -> Result<(), DirstateMapError> {

        self.add_or_remove_file(filename, old_state, entry);

        Ok(())

    }

    fn remove_file(

        &mut self,

        filename: &HgPath,

        old_state: EntryState,

        size: i32,

    ) -> Result<(), DirstateMapError> {

        let entry = DirstateEntry {

            state: EntryState::Removed,

            mode: 0,

            size,

            mtime: 0,

        };

        self.add_or_remove_file(filename, old_state, entry);

        Ok(())

    }

    fn drop_file(

        &mut self,

        filename: &HgPath,

        old_state: EntryState,