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