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

use crate::{CopyMap, DirstateEntry, DirstateMap, EntryState};

/// Marker enum used to dispatch new status entries into the right collections.

/// Is similar to `crate::EntryState`, but represents the transient state of

/// entries during the lifetime of a command.

enum Dispatch {

    Unsure,

    Modified,

    Added,

    Removed,

    Deleted,

    Clean,

    Unknown,

}

/// The file corresponding to the dirstate entry was found on the filesystem.

fn dispatch_found(

    filename: impl AsRef<HgPath>,

    entry: DirstateEntry,

    metadata: HgMetadata,

    copy_map: &CopyMap,

    check_exec: bool,

    list_clean: bool,

    last_normal_time: i64,

) -> Dispatch {

    let DirstateEntry {

        state,

        mode,

        mtime,

        size,

    } = entry;

    let HgMetadata {

        st_mode,

        st_size,

        st_mtime,

        ..

    } = metadata;

    match state {

        EntryState::Normal => {

            // Dates and times that are outside the 31-bit signed

            // range are compared modulo 2^31. This should prevent

            // it from behaving badly with very large files or

            // corrupt dates while still having a high probability

            // of detecting changes. (issue2608)

            let range_mask = 0x7fffffff;

            let size_changed = (size != st_size as i32)

                && size != (st_size as i32 & range_mask);

            let mode_changed =

                (mode ^ st_mode as i32) & 0o100 != 0o000 && check_exec;

            if size >= 0

                            && (size_changed || mode_changed)

                            || size == -2  // other parent

                            || copy_map.contains_key(filename.as_ref())

            {

                Dispatch::Modified

            } else if mtime != st_mtime as i32

                && mtime != (st_mtime as i32 & range_mask)

            {

                Dispatch::Unsure

            } else if st_mtime == last_normal_time {

                // the file may have just been marked as normal and

                // it may have changed in the same second without

                // changing its size. This can happen if we quickly

                // do multiple commits. Force lookup, so we don't

                // miss such a racy file change.

                Dispatch::Unsure

            } else if list_clean {

                Dispatch::Clean

            } else {

                Dispatch::Unknown

            }

        }

        EntryState::Merged => Dispatch::Modified,

        EntryState::Added => Dispatch::Added,

        EntryState::Removed => Dispatch::Removed,

        EntryState::Unknown => Dispatch::Unknown,

    }

}

/// The file corresponding to this Dirstate entry is missing.

fn dispatch_missing(state: EntryState) -> Dispatch {

    match state {

        // File was removed from the filesystem during commands

        EntryState::Normal | EntryState::Merged | EntryState::Added => {

            Dispatch::Deleted

        }

        // File was removed, everything is normal

        EntryState::Removed => Dispatch::Removed,

        // File is unknown to Mercurial, everything is normal

        EntryState::Unknown => Dispatch::Unknown,

    }

}

/// Stat all entries in the `DirstateMap` and mark them for dispatch into

/// the relevant collections.

fn stat_dmap_entries(

    check_exec: bool,

    list_clean: bool,

    last_normal_time: i64,

) -> std::io::Result<Vec<(&HgPath, Dispatch)>> {

            |(filename, entry)| -> Option<

                std::io::Result<(&HgPath, Dispatch)>

                        Ok((filename, dispatch_missing(entry.state)))

                    Ok(m) => Ok((filename, dispatch_found(

                            filename,

                            *entry,

                            HgMetadata::from_metadata(m),

                            &dmap.copy_map,

                            check_exec,

                            list_clean,

                            last_normal_time))),

                        Ok((filename, dispatch_missing(entry.state)))

pub struct StatusResult<'a> {

    pub modified: Vec<&'a HgPath>,

    pub added: Vec<&'a HgPath>,

    pub removed: Vec<&'a HgPath>,

    pub deleted: Vec<&'a HgPath>,

    pub clean: Vec<&'a HgPath>,

    results: Vec<(&HgPath, Dispatch)>,

) -> (Vec<&HgPath>, StatusResult) {

    for (filename, dispatch) in results.into_iter() {

        match dispatch {

            Dispatch::Unknown => {}

            Dispatch::Unsure => lookup.push(filename),

            Dispatch::Modified => modified.push(filename),

            Dispatch::Added => added.push(filename),

            Dispatch::Removed => removed.push(filename),

            Dispatch::Deleted => deleted.push(filename),

            Dispatch::Clean => clean.push(filename),

) -> std::io::Result<(Vec<&HgPath>, StatusResult)> {

    let results = stat_dmap_entries(

        root_dir,

        check_exec,

    )?;

    Ok(build_response(results))