// std
#[allow(deprecated, unused_imports)]
use std::ascii::AsciiExt;
use std::fmt::Display;

// Internal
use app::parser::{ParseResult, Parser};
use app::settings::AppSettings as AS;
use app::usage;
use args::settings::ArgSettings;
use args::{AnyArg, ArgMatcher, MatchedArg};
use errors::Result as ClapResult;
use errors::{Error, ErrorKind};
use fmt::{Colorizer, ColorizerOption};
use INTERNAL_ERROR_MSG;
use INVALID_UTF8;

pub struct Validator<'a, 'b, 'z>(&'z mut Parser<'a, 'b>)
where
    'a: 'b,
    'b: 'z;

impl<'a, 'b, 'z> Validator<'a, 'b, 'z> {
    pub fn new(p: &'z mut Parser<'a, 'b>) -> Self {
        Validator(p)
    }

    pub fn validate(
        &mut self,
        needs_val_of: ParseResult<'a>,
        subcmd_name: Option<String>,
        matcher: &mut ArgMatcher<'a>,
    ) -> ClapResult<()> {
        debugln!("Validator::validate;");
        let mut reqs_validated = false;
        self.0.add_env(matcher)?;
        self.0.add_defaults(matcher)?;
        if let ParseResult::Opt(a) = needs_val_of {
            debugln!("Validator::validate: needs_val_of={:?}", a);
            let o = {
                self.0
                    .opts
                    .iter()
                    .find(|o| o.b.name == a)
                    .expect(INTERNAL_ERROR_MSG)
                    .clone()
            };
            self.validate_required(matcher)?;
            reqs_validated = true;
            let should_err = if let Some(v) = matcher.0.args.get(&*o.b.name) {
                v.vals.is_empty() && !(o.v.min_vals.is_some() && o.v.min_vals.unwrap() == 0)
            } else {
                true
            };
            if should_err {
                return Err(Error::empty_value(
                    &o,
                    &*usage::create_error_usage(self.0, matcher, None),
                    self.0.color(),
                ));
            }
        }

        if matcher.is_empty()
            && matcher.subcommand_name().is_none()
            && self.0.is_set(AS::ArgRequiredElseHelp)
        {
            let mut out = vec![];
            self.0.write_help_err(&mut out)?;
            return Err(Error {
                message: String::from_utf8_lossy(&*out).into_owned(),
                kind: ErrorKind::MissingArgumentOrSubcommand,
                info: None,
            });
        }
        self.validate_blacklist(matcher)?;
        if !(self.0.is_set(AS::SubcommandsNegateReqs) && subcmd_name.is_some()) && !reqs_validated {
            self.validate_required(matcher)?;
        }
        self.validate_matched_args(matcher)?;
        matcher.usage(usage::create_usage_with_title(self.0, &[]));

        Ok(())
    }

    fn validate_arg_values<A>(
        &self,
        arg: &A,
        ma: &MatchedArg,
        matcher: &ArgMatcher<'a>,
    ) -> ClapResult<()>
    where
        A: AnyArg<'a, 'b> + Display,
    {
        debugln!("Validator::validate_arg_values: arg={:?}", arg.name());
        for val in &ma.vals {
            if self.0.is_set(AS::StrictUtf8) && val.to_str().is_none() {
                debugln!(
                    "Validator::validate_arg_values: invalid UTF-8 found in val {:?}",
                    val
                );
                return Err(Error::invalid_utf8(
                    &*usage::create_error_usage(self.0, matcher, None),
                    self.0.color(),
                ));
            }
            if let Some(p_vals) = arg.possible_vals() {
                debugln!("Validator::validate_arg_values: possible_vals={:?}", p_vals);
                let val_str = val.to_string_lossy();
                let ok = if arg.is_set(ArgSettings::CaseInsensitive) {
                    p_vals.iter().any(|pv| pv.eq_ignore_ascii_case(&*val_str))
                } else {
                    p_vals.contains(&&*val_str)
                };
                if !ok {
                    return Err(Error::invalid_value(
                        val_str,
                        p_vals,
                        arg,
                        &*usage::create_error_usage(self.0, matcher, None),
                        self.0.color(),
                    ));
                }
            }
            if !arg.is_set(ArgSettings::EmptyValues)
                && val.is_empty()
                && matcher.contains(&*arg.name())
            {
                debugln!("Validator::validate_arg_values: illegal empty val found");
                return Err(Error::empty_value(
                    arg,
                    &*usage::create_error_usage(self.0, matcher, None),
                    self.0.color(),
                ));
            }
            if let Some(vtor) = arg.validator() {
                debug!("Validator::validate_arg_values: checking validator...");
                if let Err(e) = vtor(val.to_string_lossy().into_owned()) {
                    sdebugln!("error");
                    return Err(Error::value_validation(Some(arg), e, self.0.color()));
                } else {
                    sdebugln!("good");
                }
            }
            if let Some(vtor) = arg.validator_os() {
                debug!("Validator::validate_arg_values: checking validator_os...");
                if let Err(e) = vtor(val) {
                    sdebugln!("error");
                    return Err(Error::value_validation(
                        Some(arg),
                        (*e).to_string_lossy().to_string(),
                        self.0.color(),
                    ));
                } else {
                    sdebugln!("good");
                }
            }
        }
        Ok(())
    }

    fn build_err(&self, name: &str, matcher: &ArgMatcher) -> ClapResult<()> {
        debugln!("build_err!: name={}", name);
        let mut c_with = find_from!(self.0, &name, blacklist, matcher);
        c_with = c_with.or(self
            .0
            .find_any_arg(name)
            .map_or(None, |aa| aa.blacklist())
            .map_or(None, |bl| bl.iter().find(|arg| matcher.contains(arg)))
            .map_or(None, |an| self.0.find_any_arg(an))
            .map_or(None, |aa| Some(format!("{}", aa))));
        debugln!("build_err!: '{:?}' conflicts with '{}'", c_with, &name);
        //        matcher.remove(&name);
        let usg = usage::create_error_usage(self.0, matcher, None);
        if let Some(f) = find_by_name!(self.0, name, flags, iter) {
            debugln!("build_err!: It was a flag...");
            Err(Error::argument_conflict(f, c_with, &*usg, self.0.color()))
        } else if let Some(o) = find_by_name!(self.0, name, opts, iter) {
            debugln!("build_err!: It was an option...");
            Err(Error::argument_conflict(o, c_with, &*usg, self.0.color()))
        } else {
            match find_by_name!(self.0, name, positionals, values) {
                Some(p) => {
                    debugln!("build_err!: It was a positional...");
                    Err(Error::argument_conflict(p, c_with, &*usg, self.0.color()))
                }
                None => panic!(INTERNAL_ERROR_MSG),
            }
        }
    }

    fn validate_blacklist(&self, matcher: &mut ArgMatcher) -> ClapResult<()> {
        debugln!("Validator::validate_blacklist;");
        let mut conflicts: Vec<&str> = vec![];
        for (&name, _) in matcher.iter() {
            debugln!("Validator::validate_blacklist:iter:{};", name);
            if let Some(grps) = self.0.groups_for_arg(name) {
                for grp in &grps {
                    if let Some(g) = self.0.groups.iter().find(|g| &g.name == grp) {
                        if !g.multiple {
                            for arg in &g.args {
                                if arg == &name {
                                    continue;
                                }
                                conflicts.push(arg);
                            }
                        }
                        if let Some(ref gc) = g.conflicts {
                            conflicts.extend(&*gc);
                        }
                    }
                }
            }
            if let Some(arg) = find_any_by_name!(self.0, name) {
                if let Some(bl) = arg.blacklist() {
                    for conf in bl {
                        if matcher.get(conf).is_some() {
                            conflicts.push(conf);
                        }
                    }
                }
            } else {
                debugln!("Validator::validate_blacklist:iter:{}:group;", name);
                let args = self.0.arg_names_in_group(name);
                for arg in &args {
                    debugln!(
                        "Validator::validate_blacklist:iter:{}:group:iter:{};",
                        name,
                        arg
                    );
                    if let Some(bl) = find_any_by_name!(self.0, *arg).unwrap().blacklist() {
                        for conf in bl {
                            if matcher.get(conf).is_some() {
                                conflicts.push(conf);
                            }
                        }
                    }
                }
            }
        }

        for name in &conflicts {
            debugln!(
                "Validator::validate_blacklist:iter:{}: Checking blacklisted arg",
                name
            );
            let mut should_err = false;
            if self.0.groups.iter().any(|g| &g.name == name) {
                debugln!(
                    "Validator::validate_blacklist:iter:{}: groups contains it...",
                    name
                );
                for n in self.0.arg_names_in_group(name) {
                    debugln!(
                        "Validator::validate_blacklist:iter:{}:iter:{}: looking in group...",
                        name,
                        n
                    );
                    if matcher.contains(n) {
                        debugln!(
                            "Validator::validate_blacklist:iter:{}:iter:{}: matcher contains it...",
                            name,
                            n
                        );
                        return self.build_err(n, matcher);
                    }
                }
            } else if let Some(ma) = matcher.get(name) {
                debugln!(
                    "Validator::validate_blacklist:iter:{}: matcher contains it...",
                    name
                );
                should_err = ma.occurs > 0;
            }
            if should_err {
                return self.build_err(*name, matcher);
            }
        }
        Ok(())
    }

    fn validate_matched_args(&self, matcher: &mut ArgMatcher<'a>) -> ClapResult<()> {
        debugln!("Validator::validate_matched_args;");
        for (name, ma) in matcher.iter() {
            debugln!(
                "Validator::validate_matched_args:iter:{}: vals={:#?}",
                name,
                ma.vals
            );
            if let Some(opt) = find_by_name!(self.0, *name, opts, iter) {
                self.validate_arg_num_vals(opt, ma, matcher)?;
                self.validate_arg_values(opt, ma, matcher)?;
                self.validate_arg_requires(opt, ma, matcher)?;
                self.validate_arg_num_occurs(opt, ma, matcher)?;
            } else if let Some(flag) = find_by_name!(self.0, *name, flags, iter) {
                self.validate_arg_requires(flag, ma, matcher)?;
                self.validate_arg_num_occurs(flag, ma, matcher)?;
            } else if let Some(pos) = find_by_name!(self.0, *name, positionals, values) {
                self.validate_arg_num_vals(pos, ma, matcher)?;
                self.validate_arg_num_occurs(pos, ma, matcher)?;
                self.validate_arg_values(pos, ma, matcher)?;
                self.validate_arg_requires(pos, ma, matcher)?;
            } else {
                let grp = self
                    .0
                    .groups
                    .iter()
                    .find(|g| &g.name == name)
                    .expect(INTERNAL_ERROR_MSG);
                if let Some(ref g_reqs) = grp.requires {
                    if g_reqs.iter().any(|&n| !matcher.contains(n)) {
                        return self.missing_required_error(matcher, None);
                    }
                }
            }
        }
        Ok(())
    }

    fn validate_arg_num_occurs<A>(
        &self,
        a: &A,
        ma: &MatchedArg,
        matcher: &ArgMatcher,
    ) -> ClapResult<()>
    where
        A: AnyArg<'a, 'b> + Display,
    {
        debugln!("Validator::validate_arg_num_occurs: a={};", a.name());
        if ma.occurs > 1 && !a.is_set(ArgSettings::Multiple) {
            // Not the first time, and we don't allow multiples
            return Err(Error::unexpected_multiple_usage(
                a,
                &*usage::create_error_usage(self.0, matcher, None),
                self.0.color(),
            ));
        }
        Ok(())
    }

    fn validate_arg_num_vals<A>(
        &self,
        a: &A,
        ma: &MatchedArg,
        matcher: &ArgMatcher,
    ) -> ClapResult<()>
    where
        A: AnyArg<'a, 'b> + Display,
    {
        debugln!("Validator::validate_arg_num_vals:{}", a.name());
        if let Some(num) = a.num_vals() {
            debugln!("Validator::validate_arg_num_vals: num_vals set...{}", num);
            let should_err = if a.is_set(ArgSettings::Multiple) {
                ((ma.vals.len() as u64) % num) != 0
            } else {
                num != (ma.vals.len() as u64)
            };
            if should_err {
                debugln!("Validator::validate_arg_num_vals: Sending error WrongNumberOfValues");
                return Err(Error::wrong_number_of_values(
                    a,
                    num,
                    if a.is_set(ArgSettings::Multiple) {
                        (ma.vals.len() % num as usize)
                    } else {
                        ma.vals.len()
                    },
                    if ma.vals.len() == 1
                        || (a.is_set(ArgSettings::Multiple) && (ma.vals.len() % num as usize) == 1)
                    {
                        "as"
                    } else {
                        "ere"
                    },
                    &*usage::create_error_usage(self.0, matcher, None),
                    self.0.color(),
                ));
            }
        }
        if let Some(num) = a.max_vals() {
            debugln!("Validator::validate_arg_num_vals: max_vals set...{}", num);
            if (ma.vals.len() as u64) > num {
                debugln!("Validator::validate_arg_num_vals: Sending error TooManyValues");
                return Err(Error::too_many_values(
                    ma.vals
                        .iter()
                        .last()
                        .expect(INTERNAL_ERROR_MSG)
                        .to_str()
                        .expect(INVALID_UTF8),
                    a,
                    &*usage::create_error_usage(self.0, matcher, None),
                    self.0.color(),
                ));
            }
        }
        let min_vals_zero = if let Some(num) = a.min_vals() {
            debugln!("Validator::validate_arg_num_vals: min_vals set: {}", num);
            if (ma.vals.len() as u64) < num && num != 0 {
                debugln!("Validator::validate_arg_num_vals: Sending error TooFewValues");
                return Err(Error::too_few_values(
                    a,
                    num,
                    ma.vals.len(),
                    &*usage::create_error_usage(self.0, matcher, None),
                    self.0.color(),
                ));
            }
            num == 0
        } else {
            false
        };
        // Issue 665 (https://github.com/clap-rs/clap/issues/665)
        // Issue 1105 (https://github.com/clap-rs/clap/issues/1105)
        if a.takes_value() && !min_vals_zero && ma.vals.is_empty() {
            return Err(Error::empty_value(
                a,
                &*usage::create_error_usage(self.0, matcher, None),
                self.0.color(),
            ));
        }
        Ok(())
    }

    fn validate_arg_requires<A>(
        &self,
        a: &A,
        ma: &MatchedArg,
        matcher: &ArgMatcher,
    ) -> ClapResult<()>
    where
        A: AnyArg<'a, 'b> + Display,
    {
        debugln!("Validator::validate_arg_requires:{};", a.name());
        if let Some(a_reqs) = a.requires() {
            for &(val, name) in a_reqs.iter().filter(|&&(val, _)| val.is_some()) {
                let missing_req =
                    |v| v == val.expect(INTERNAL_ERROR_MSG) && !matcher.contains(name);
                if ma.vals.iter().any(missing_req) {
                    return self.missing_required_error(matcher, None);
                }
            }
            for &(_, name) in a_reqs.iter().filter(|&&(val, _)| val.is_none()) {
                if !matcher.contains(name) {
                    return self.missing_required_error(matcher, Some(name));
                }
            }
        }
        Ok(())
    }

    fn validate_required(&mut self, matcher: &ArgMatcher) -> ClapResult<()> {
        debugln!(
            "Validator::validate_required: required={:?};",
            self.0.required
        );

        let mut should_err = false;
        let mut to_rem = Vec::new();
        for name in &self.0.required {
            debugln!("Validator::validate_required:iter:{}:", name);
            if matcher.contains(name) {
                continue;
            }
            if to_rem.contains(name) {
                continue;
            } else if let Some(a) = find_any_by_name!(self.0, *name) {
                if self.is_missing_required_ok(a, matcher) {
                    to_rem.push(a.name());
                    if let Some(reqs) = a.requires() {
                        for r in reqs
                            .iter()
                            .filter(|&&(val, _)| val.is_none())
                            .map(|&(_, name)| name)
                        {
                            to_rem.push(r);
                        }
                    }
                    continue;
                }
            }
            should_err = true;
            break;
        }
        if should_err {
            for r in &to_rem {
                'inner: for i in (0..self.0.required.len()).rev() {
                    if &self.0.required[i] == r {
                        self.0.required.swap_remove(i);
                        break 'inner;
                    }
                }
            }
            return self.missing_required_error(matcher, None);
        }

        // Validate the conditionally required args
        for &(a, v, r) in &self.0.r_ifs {
            if let Some(ma) = matcher.get(a) {
                if matcher.get(r).is_none() && ma.vals.iter().any(|val| val == v) {
                    return self.missing_required_error(matcher, Some(r));
                }
            }
        }
        Ok(())
    }

    fn validate_arg_conflicts(&self, a: &AnyArg, matcher: &ArgMatcher) -> Option<bool> {
        debugln!("Validator::validate_arg_conflicts: a={:?};", a.name());
        a.blacklist().map(|bl| {
            bl.iter().any(|conf| {
                matcher.contains(conf)
                    || self
                        .0
                        .groups
                        .iter()
                        .find(|g| &g.name == conf)
                        .map_or(false, |g| g.args.iter().any(|arg| matcher.contains(arg)))
            })
        })
    }

    fn validate_required_unless(&self, a: &AnyArg, matcher: &ArgMatcher) -> Option<bool> {
        debugln!("Validator::validate_required_unless: a={:?};", a.name());
        macro_rules! check {
            ($how:ident, $_self:expr, $a:ident, $m:ident) => {{
                $a.required_unless().map(|ru| {
                    ru.iter().$how(|n| {
                        $m.contains(n) || {
                            if let Some(grp) = $_self.groups.iter().find(|g| &g.name == n) {
                                grp.args.iter().any(|arg| $m.contains(arg))
                            } else {
                                false
                            }
                        }
                    })
                })
            }};
        }
        if a.is_set(ArgSettings::RequiredUnlessAll) {
            check!(all, self.0, a, matcher)
        } else {
            check!(any, self.0, a, matcher)
        }
    }

    fn missing_required_error(&self, matcher: &ArgMatcher, extra: Option<&str>) -> ClapResult<()> {
        debugln!("Validator::missing_required_error: extra={:?}", extra);
        let c = Colorizer::new(ColorizerOption {
            use_stderr: true,
            when: self.0.color(),
        });
        let mut reqs = self.0.required.iter().map(|&r| &*r).collect::<Vec<_>>();
        if let Some(r) = extra {
            reqs.push(r);
        }
        reqs.retain(|n| !matcher.contains(n));
        reqs.dedup();
        debugln!("Validator::missing_required_error: reqs={:#?}", reqs);
        let req_args =
            usage::get_required_usage_from(self.0, &reqs[..], Some(matcher), extra, true)
                .iter()
                .fold(String::new(), |acc, s| {
                    acc + &format!("\n    {}", c.error(s))[..]
                });
        debugln!(
            "Validator::missing_required_error: req_args={:#?}",
            req_args
        );
        Err(Error::missing_required_argument(
            &*req_args,
            &*usage::create_error_usage(self.0, matcher, extra),
            self.0.color(),
        ))
    }

    #[inline]
    fn is_missing_required_ok(&self, a: &AnyArg, matcher: &ArgMatcher) -> bool {
        debugln!("Validator::is_missing_required_ok: a={}", a.name());
        self.validate_arg_conflicts(a, matcher).unwrap_or(false)
            || self.validate_required_unless(a, matcher).unwrap_or(false)
    }
}
