// status.rs

//

// Copyright 2020, Georges Racinet <georges.racinets@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.

use crate::error::CommandError;

use crate::ui::{

    format_pattern_file_warning, print_narrow_sparse_warnings, relative_paths,

    RelativePaths, Ui,

};

use crate::utils::path_utils::RelativizePaths;

use clap::Arg;

use format_bytes::format_bytes;

use hg::config::Config;

use hg::dirstate::entry::{has_exec_bit, TruncatedTimestamp};

use hg::dirstate::status::{

    BadMatch, DirstateStatus, StatusError, StatusOptions, StatusPath,

};

use hg::errors::{HgError, IoResultExt};

use hg::lock::LockError;

use hg::matchers::{AlwaysMatcher, IntersectionMatcher};

use hg::repo::Repo;

use hg::revlog::manifest::Manifest;

use hg::revlog::options::{default_revlog_options, RevlogOpenOptions};

use hg::revlog::RevlogType;

use hg::utils::debug::debug_wait_for_file;

use hg::utils::files::{

    get_bytes_from_os_str, get_bytes_from_os_string, get_path_from_bytes,

};

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

use hg::Revision;

use hg::{self, narrow, sparse};

use log::info;

use rayon::prelude::*;

use std::borrow::Cow;

use std::io;

use std::mem::take;

use std::path::PathBuf;

pub const HELP_TEXT: &str = "

Show changed files in the working directory

This is a pure Rust version of `hg status`.

Some options might be missing, check the list below.

";

pub fn args() -> clap::Command {

    clap::command!("status")

        .alias("st")

        .about(HELP_TEXT)

        .arg(

            Arg::new("file")

                .value_parser(clap::value_parser!(std::ffi::OsString))

                .help("show only these files")

                .action(clap::ArgAction::Append),

        )

        .arg(

            Arg::new("all")

                .help("show status of all files")

                .short('A')

                .action(clap::ArgAction::SetTrue)

                .long("all"),

        )

        .arg(

            Arg::new("modified")

                .help("show only modified files")

                .short('m')

                .action(clap::ArgAction::SetTrue)

                .long("modified"),

        )

        .arg(

            Arg::new("added")

                .help("show only added files")

                .short('a')

                .action(clap::ArgAction::SetTrue)

                .long("added"),

        )

        .arg(

            Arg::new("removed")

                .help("show only removed files")

                .short('r')

                .action(clap::ArgAction::SetTrue)

                .long("removed"),

        )

        .arg(

            Arg::new("clean")

                .help("show only clean files")

                .short('c')

                .action(clap::ArgAction::SetTrue)

                .long("clean"),

        )

        .arg(

            Arg::new("deleted")

                .help("show only deleted files")

                .short('d')

                .action(clap::ArgAction::SetTrue)

                .long("deleted"),

        )

        .arg(

            Arg::new("unknown")

                .help("show only unknown (not tracked) files")

                .short('u')

                .action(clap::ArgAction::SetTrue)

                .long("unknown"),

        )

        .arg(

            Arg::new("ignored")

                .help("show only ignored files")

                .short('i')

                .action(clap::ArgAction::SetTrue)

                .long("ignored"),

        )

        .arg(

            Arg::new("copies")

                .help("show source of copied files (DEFAULT: ui.statuscopies)")

                .short('C')

                .action(clap::ArgAction::SetTrue)

                .long("copies"),

        )

        .arg(

            Arg::new("print0")

                .help("end filenames with NUL, for use with xargs")

                .short('0')

                .action(clap::ArgAction::SetTrue)

                .long("print0"),

        )

        .arg(

            Arg::new("no-status")

                .help("hide status prefix")

                .short('n')

                .action(clap::ArgAction::SetTrue)

                .long("no-status"),

        )

        .arg(

            Arg::new("verbose")

                .help("enable additional output")

                .short('v')

                .action(clap::ArgAction::SetTrue)

                .long("verbose"),

        )

        .arg(

            Arg::new("rev")

                .help("show difference from/to revision")

                .long("rev")

                .num_args(1)

                .action(clap::ArgAction::Append)

                .value_name("REV"),

        )

}

fn parse_revpair(

    repo: &Repo,

    revs: Option<Vec<String>>,

) -> Result<Option<(Revision, Revision)>, CommandError> {

    let revs = match revs {

        None => return Ok(None),

        Some(revs) => revs,

    };

    if revs.is_empty() {

        return Ok(None);

    }

    if revs.len() != 2 {

        return Err(CommandError::unsupported("expected 0 or 2 --rev flags"));

    }

    let rev1 = &revs[0];

    let rev2 = &revs[1];

    let rev1 = hg::revset::resolve_single(rev1, repo)

        .map_err(|e| (e, rev1.as_str()))?;

    let rev2 = hg::revset::resolve_single(rev2, repo)

        .map_err(|e| (e, rev2.as_str()))?;

    Ok(Some((rev1, rev2)))

}

/// Pure data type allowing the caller to specify file states to display

#[derive(Copy, Clone, Debug)]

pub struct DisplayStates {

    pub modified: bool,

    pub added: bool,

    pub removed: bool,

    pub clean: bool,

    pub deleted: bool,

    pub unknown: bool,

    pub ignored: bool,

}

pub const DEFAULT_DISPLAY_STATES: DisplayStates = DisplayStates {

    modified: true,

    added: true,

    removed: true,

    clean: false,

    deleted: true,

    unknown: true,

    ignored: false,

};

pub const ALL_DISPLAY_STATES: DisplayStates = DisplayStates {

    modified: true,

    added: true,

    removed: true,

    clean: true,

    deleted: true,

    unknown: true,

    ignored: true,

};

impl DisplayStates {

    pub fn is_empty(&self) -> bool {

        !(self.modified

            || self.added

            || self.removed

            || self.clean

            || self.deleted

            || self.unknown

            || self.ignored)

    }

}

fn has_unfinished_merge(repo: &Repo) -> Result<bool, CommandError> {

    Ok(repo.dirstate_parents()?.is_merge())

}

fn has_unfinished_state(repo: &Repo) -> Result<bool, CommandError> {

    // These are all the known values for the [fname] argument of

    // [addunfinished] function in [state.py]

    let known_state_files: &[&str] = &[

        "bisect.state",

        "graftstate",

        "histedit-state",

        "rebasestate",

        "shelvedstate",

        "transplant/journal",

        "updatestate",

    ];

    if has_unfinished_merge(repo)? {

        return Ok(true);

    };

    for f in known_state_files {

        if repo.hg_vfs().join(f).exists() {

            return Ok(true);

        }

    }

    Ok(false)

}

pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {

    // TODO: lift these limitations

    if invocation

        .config

        .get(b"commands", b"status.terse")

        .is_some()

    {

        return Err(CommandError::unsupported(

            "status.terse is not yet supported with rhg status",

        ));

    }

    let ui = invocation.ui;

    let config = invocation.config;

    let args = invocation.subcommand_args;

    let revs = args.get_many::<String>("rev");

    let print0 = args.get_flag("print0");

    let verbose = args.get_flag("verbose")

        || config.get_bool(b"ui", b"verbose")?

        || config.get_bool(b"commands", b"status.verbose")?;

    let verbose = verbose && !print0;

    let all = args.get_flag("all");

    let display_states = if all {

        // TODO when implementing `--quiet`: it excludes clean files

        // from `--all`

        ALL_DISPLAY_STATES

    } else {

        let requested = DisplayStates {

            modified: args.get_flag("modified"),

            added: args.get_flag("added"),

            removed: args.get_flag("removed"),

            clean: args.get_flag("clean"),

            deleted: args.get_flag("deleted"),

            unknown: args.get_flag("unknown"),

            ignored: args.get_flag("ignored"),

        };

        if requested.is_empty() {

            DEFAULT_DISPLAY_STATES

        } else {

            requested

        }

    };

    let no_status = args.get_flag("no-status");

    let list_copies = all

        || args.get_flag("copies")

        || config.get_bool(b"ui", b"statuscopies")?;

    let repo = invocation.repo?;

    let revpair = parse_revpair(repo, revs.map(|i| i.cloned().collect()))?;

    if verbose && has_unfinished_state(repo)? {

        return Err(CommandError::unsupported(

            "verbose status output is not supported by rhg (and is needed because we're in an unfinished operation)",

        ));

    }

    let mut dmap = repo.dirstate_map_mut()?;

    let check_exec = hg::checkexec::check_exec(repo.working_directory_path());

    let options = StatusOptions {

        check_exec,

        list_clean: display_states.clean,

        list_unknown: display_states.unknown,

        list_ignored: display_states.ignored,

        list_copies,

        collect_traversed_dirs: false,

    };

    type StatusResult<'a> =

        Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>;

    let relative_status = config

        .get_option(b"commands", b"status.relative")?

        .expect("commands.status.relative should have a default value");

    let relativize_paths = relative_status || {

        // See in Python code with `getuipathfn` usage in `commands.py`.

        let legacy_relative_behavior = args.contains_id("file");

        match relative_paths(invocation.config)? {

            RelativePaths::Legacy => legacy_relative_behavior,

            RelativePaths::Bool(v) => v,

        }

    };

    let mut output = DisplayStatusPaths {

        ui,

        no_status,

        relativize: if relativize_paths {

            Some(RelativizePaths::new(repo)?)

        } else {

            None

        },

        print0,

    };

    let after_status = |res: StatusResult| -> Result<_, CommandError> {

        let (mut ds_status, pattern_warnings) = res?;

        for warning in pattern_warnings {

            ui.write_stderr(&format_pattern_file_warning(&warning, repo))?;

        }

        for (path, error) in take(&mut ds_status.bad) {

            let error = match error {

                BadMatch::OsError(code) => {

                    std::io::Error::from_raw_os_error(code).to_string()

                }

                BadMatch::BadType(ty) => {

                    format!("unsupported file type (type is {})", ty)

                }

            };

            ui.write_stderr(&format_bytes!(

                b"{}: {}\n",

                path.as_bytes(),

                error.as_bytes()

            ))?

        }

        if !ds_status.unsure.is_empty() {

            info!(

                "Files to be rechecked by retrieval from filelog: {:?}",

                ds_status.unsure.iter().map(|s| &s.path).collect::<Vec<_>>()

            );

        }

        let mut fixup = Vec::new();

        if !ds_status.unsure.is_empty()

            && (display_states.modified || display_states.clean)

        {

            let p1 = repo.dirstate_parents()?.p1;

            let manifest = repo.manifest_for_node(p1).map_err(|e| {

                CommandError::from((e, &*format!("{:x}", p1.short())))

            })?;

            let working_directory_vfs = repo.working_directory_vfs();

            let store_vfs = repo.store_vfs();

            let filelog_open_options = default_revlog_options(

                repo.config(),

                repo.requirements(),

                RevlogType::Filelog,

            )?;

            let res: Vec<_> = take(&mut ds_status.unsure)

                .into_par_iter()

                .map(|to_check| {

                    // The compiler seems to get a bit confused with complex

                    // inference when using a parallel iterator + map

                    // + map_err + collect, so let's just inline some of the

                    // logic.

                    match unsure_is_modified(

                        &working_directory_vfs,

                        &store_vfs,

                        check_exec,

                        &manifest,

                        &to_check.path,

                        filelog_open_options,

                    ) {

                        Err(HgError::IoError { .. }) => {

                            // IO errors most likely stem from the file being

                            // deleted even though we know it's in the

                            // dirstate.

                            Ok((to_check, UnsureOutcome::Deleted))

                        }

                        Ok(outcome) => Ok((to_check, outcome)),

                        Err(e) => Err(e),

                    }

                })

                .collect::<Result<_, _>>()?;

            for (status_path, outcome) in res.into_iter() {

                match outcome {

                    UnsureOutcome::Clean => {

                        if display_states.clean {

                            ds_status.clean.push(status_path.clone());

                        }

                        fixup.push(status_path.path.into_owned())

                    }

                    UnsureOutcome::Modified => {

                        if display_states.modified {

                            ds_status.modified.push(status_path);

                        }

                    }

                    UnsureOutcome::Deleted => {

                        if display_states.deleted {

                            ds_status.deleted.push(status_path);

                        }

                    }

                }

            }

        }

        let dirstate_write_needed = ds_status.dirty;

        let filesystem_time_at_status_start =

            ds_status.filesystem_time_at_status_start;

        output.output(display_states, ds_status)?;

        Ok((

            fixup,

            dirstate_write_needed,

            filesystem_time_at_status_start,

        ))

    };

    let (narrow_matcher, narrow_warnings) = narrow::matcher(repo)?;

    if let Some((rev1, rev2)) = revpair {

        let mut ds_status = DirstateStatus::default();

        if list_copies {

            return Err(CommandError::unsupported(

                "status --rev --rev with copy information is not implemented yet",

            ));

        }

        let stat = hg::operations::status_rev_rev_no_copies(

            repo,

            rev1,

            rev2,

            narrow_matcher,

        )?;

        for entry in stat.iter() {

            let (path, status) = entry?;

            let path = StatusPath {

                path: Cow::Borrowed(path),

                copy_source: None,

            };

            match status {

                hg::operations::DiffStatus::Removed => {

                    if display_states.removed {

                        ds_status.removed.push(path)

                    }

                }

                hg::operations::DiffStatus::Added => {

                    if display_states.added {

                        ds_status.added.push(path)

                    }

                }

                hg::operations::DiffStatus::Modified => {

                    if display_states.modified {

                        ds_status.modified.push(path)

                    }

                }

                hg::operations::DiffStatus::Matching => {

                    if display_states.clean {

                        ds_status.clean.push(path)

                    }