// status.rs

//

// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>

//

// This software may be used and distributed according to the terms of the

// GNU General Public License version 2 or any later version.

//! Rust implementation of dirstate.status (dirstate.py).

//! It is currently missing a lot of functionality compared to the Python one

//! and will only be triggered in narrow cases.

use crate::utils::files::HgMetadata;

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

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

use rayon::prelude::*;

use std::collections::HashMap;

use std::fs::Metadata;

use std::path::Path;

/// Get stat data about the files explicitly specified by match.

/// TODO subrepos

fn walk_explicit(

    files: &[impl AsRef<HgPath> + Sync],

    dmap: &DirstateMap,

    root_dir: impl AsRef<Path> + Sync,

) -> std::io::Result<HashMap<HgPathBuf, Option<HgMetadata>>> {

    let mut results = HashMap::new();

    // A tuple of the normalized filename and the `Result` of the call to

    // `symlink_metadata` for separate handling.

    type WalkTuple<'a> = (&'a HgPath, std::io::Result<Metadata>);

    let stats_res: std::io::Result<Vec<WalkTuple>> = files

        .par_iter()

        .map(|filename| {

            // TODO normalization

            let normalized = filename.as_ref();

            let target_filename =

                root_dir.as_ref().join(hg_path_to_path_buf(normalized)?);

            Ok((normalized, target_filename.symlink_metadata()))

        })

        .collect();

    for res in stats_res? {

        match res {

            (normalized, Ok(stat)) => {

                if stat.is_file() {

                    results.insert(

                        normalized.to_owned(),

                        Some(HgMetadata::from_metadata(stat)),

                    );

                } else {

                    if dmap.contains_key(normalized) {

                        results.insert(normalized.to_owned(), None);

                    }

                }

            }

            (normalized, Err(_)) => {

                if dmap.contains_key(normalized) {

                    results.insert(normalized.to_owned(), None);

                }

            }

        };

    }

    Ok(results)

}

// Stat all entries in the `DirstateMap` and return their new metadata.

pub fn stat_dmap_entries(

    dmap: &DirstateMap,

    results: &HashMap<HgPathBuf, Option<HgMetadata>>,

    root_dir: impl AsRef<Path> + Sync,

) -> std::io::Result<Vec<(HgPathBuf, Option<HgMetadata>)>> {

    dmap.par_iter()

        .filter_map(

            // Getting file metadata is costly, so we don't do it if the

            // file is already present in the results, hence `filter_map`

            |(filename, _)| -> Option<

                std::io::Result<(HgPathBuf, Option<HgMetadata>)>

            > {

                if results.contains_key(filename) {

                    return None;

                }

                let meta = match hg_path_to_path_buf(filename) {

                    Ok(p) => root_dir.as_ref().join(p).symlink_metadata(),

                    Err(e) => return Some(Err(e.into())),

                };

                Some(match meta {

                    Ok(ref m)

                        if !(m.file_type().is_file()

                            || m.file_type().is_symlink()) =>

                    {

                        Ok((filename.to_owned(), None))

                    }

                    Ok(m) => Ok((

                        filename.to_owned(),

                        Some(HgMetadata::from_metadata(m)),

                    )),

                    Err(ref e)

                        if e.kind() == std::io::ErrorKind::NotFound

                            || e.raw_os_error() == Some(20) =>

                    {

                        // Rust does not yet have an `ErrorKind` for

                        // `NotADirectory` (errno 20)

                        // It happens if the dirstate contains `foo/bar` and

                        // foo is not a directory

                        Ok((filename.to_owned(), None))

                    }

                    Err(e) => Err(e),

                })

            },

        )

        .collect()

}

pub struct StatusResult {

    pub modified: Vec<HgPathBuf>,

    pub added: Vec<HgPathBuf>,

    pub removed: Vec<HgPathBuf>,

    pub deleted: Vec<HgPathBuf>,

    pub clean: Vec<HgPathBuf>,

    // TODO ignored

    // TODO unknown

}

fn build_response(

    dmap: &DirstateMap,

    list_clean: bool,

    last_normal_time: i64,

    check_exec: bool,

    results: HashMap<HgPathBuf, Option<HgMetadata>>,

) -> (Vec<HgPathBuf>, StatusResult) {

    let mut lookup = vec![];

    let mut modified = vec![];

    let mut added = vec![];

    let mut removed = vec![];

    let mut deleted = vec![];

    let mut clean = vec![];

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

        let DirstateEntry {

            state,

            mode,

            mtime,

            size,

        } = match dmap.get(&filename) {

            None => {

                continue;

            }

            Some(e) => *e,

        };

        match metadata_option {

            None => {

                match state {

                    EntryState::Normal

                    | EntryState::Merged

                    | EntryState::Added => deleted.push(filename),

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

                    _ => {}

                };

            }

            Some(HgMetadata {

                st_mode,

                st_size,

                st_mtime,

                ..

            }) => {

                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

                            || dmap.copy_map.contains_key(&filename)

                        {

                            modified.push(filename);

                        } else if mtime != st_mtime as i32

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

                        {

                            lookup.push(filename);

                        } 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.

                            lookup.push(filename);

                        } else if list_clean {

                            clean.push(filename);

                        }

                    }

                    EntryState::Merged => modified.push(filename),

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

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

                    EntryState::Unknown => {}

                }

            }

        }

    }

    (

        lookup,

        StatusResult {

            modified,

            added,

            removed,

            deleted,

            clean,

        },

    )

}

pub fn status(

    dmap: &DirstateMap,

    root_dir: impl AsRef<Path> + Sync + Copy,

    files: &[impl AsRef<HgPath> + Sync],

    list_clean: bool,

    last_normal_time: i64,

    check_exec: bool,

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

    let mut results = walk_explicit(files, &dmap, root_dir)?;

    results.extend(stat_dmap_entries(&dmap, &results, root_dir)?);

    Ok(build_response(

        &dmap,

        list_clean,

        last_normal_time,

        check_exec,

        results,

    ))

}