// License: see LICENSE file at root directory of `master` branch

//! # Arguments

use std::{
    collections::HashMap,
    env,
    fs::File,
    io::{self, BufRead, BufReader, Error, ErrorKind, Read},
    path::Path,
    str::FromStr,
};

use crate::{
    MergeOption,
    paths::permissions::{self, Permissions},
};

/// # `true` as string
pub const TRUE_AS_STR: &str = "true";

/// # `false` as string
pub const FALSE_AS_STR: &str = "false";

/// # Arguments
///
/// ## Usage
///
/// - [`cmds()`][Args::cmds()] can contain commands and normal arguments (such as file paths...)
/// - [`sub_args()`][Args::sub_args()] are **not** verified. They are the ones after `--` symbol, which are meant for being passed to sub
///   processes.
///
/// [Args::cmds()]: struct.Args.html#method.cmds
/// [Args::sub_args()]: struct.Args.html#method.sub_args
#[derive(Default, Debug, Clone)]
pub struct Args {

    /// # Commands
    ///
    /// If it's some vector, the vector is _not_ empty.
    cmds: Option<Vec<String>>,

    /// # Raw arguments
    args: HashMap<String, Vec<String>>,

    /// # Sub arguments
    ///
    /// If it's some vector, the vector is _not_ empty.
    sub_args: Option<Vec<String>>,

    /// # Flag for using stdin
    use_stdin: bool,

}

impl AsRef<Args> for Args {

    fn as_ref(&self) -> &Self {
        self
    }

}

impl Args {

    /// # Gets the command
    pub fn cmd(&self) -> Option<&str> {
        match self.cmds {
            Some(ref cmds) => cmds.first().map(|s| s.as_str()),
            None => None,
        }
    }

    /// # Gets the commands
    ///
    /// If it's some vector, the vector is _not_ empty.
    pub fn cmds(&self) -> Option<Vec<&str>> {
        self.cmds.as_ref().map(|v| v.iter().map(|s| s.as_str()).collect())
    }

    /// # Gets raw arguments
    pub fn args(&self) -> &HashMap<String, Vec<String>> {
        &self.args
    }

    /// # Sub arguments
    ///
    /// If it's some vector, the vector is _not_ empty.
    pub fn sub_args(&self) -> Option<Vec<&str>> {
        self.sub_args.as_ref().map(|v| v.iter().map(|s| s.as_str()).collect())
    }

    /// # Checks if there are no commands/arguments/sub arguments
    pub fn is_empty(&self) -> bool {
        self.cmds.is_none() && self.args.is_empty() && self.sub_args.is_none()
    }

    /// # Checks if there are arguments or sub arguments
    pub fn has_args(&self) -> bool {
        self.args.is_empty() == false || self.sub_args.is_some()
    }

    /// # Gets flag for using stdin
    pub fn use_stdin(&self) -> bool {
        self.use_stdin
    }

    /// # Transforms into sub command
    ///
    /// For example:
    ///
    /// - Command line: `program help version 1`
    /// - First parse: `help version 1`
    /// - After calling this function: `version 1`
    ///
    /// ```
    /// use dia_args;
    ///
    /// const CMD_VERSION: &str = "version";
    ///
    /// let (cmd, args) = dia_args::parse()?.sub_cmd();
    /// match cmd.as_ref().map(|s| s.as_str()) {
    ///     Some(CMD_VERSION) => match args.is_empty() {
    ///         true => println!("Version: ..."),
    ///         false => eprintln!("{:?} command doesn't take arguments", CMD_VERSION),
    ///     },
    ///     Some(other) => eprintln!("Command {:?} not supported", other),
    ///     None => eprintln!("Missing command"),
    /// };
    ///
    /// # Ok::<_, std::io::Error>(())
    /// ```
    pub fn sub_cmd(self) -> (Option<String>, Self) {
        let mut cmds = self.cmds;
        (
            match cmds.as_mut() {
                Some(cmds) => match cmds.is_empty() {
                    true => None,
                    false => Some(cmds.remove(0)),
                },
                None => None,
            },
            Self {
                cmds: match cmds {
                    Some(cmds) => match cmds.is_empty() {
                        true => None,
                        false => Some(cmds),
                    },
                    None => None,
                },
                ..self
            }
        )
    }

    /// # Gets a value
    ///
    /// You can provide multiple keys as you want. But the user can only provide one single key of them. This function can be used for short
    /// version and long version of your keys.
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_args;
    ///
    /// let args = dia_args::parse_strings(["--type", "ogg"].iter())?;
    /// assert_eq!(args.get::<String, _>(&["-t", "--type"])?.unwrap(), "ogg");
    ///
    /// let args = dia_args::parse_strings(["--type", "ogg"].iter())?;
    /// assert!(args.get::<String, _>(&["-t"])?.is_none());
    ///
    /// let args = dia_args::parse_strings(["--type", "ogg", "-t", "some"].iter())?;
    /// args.get::<String, _>(&["-t", "--type"]).unwrap_err();
    ///
    /// # Ok::<_, std::io::Error>(())
    /// ```
    pub fn get<T, S>(&self, keys: &[S]) -> io::Result<Option<T>> where T: FromStr, S: AsRef<str> {
        let mut result = None;

        for key in keys {
            let key = key.as_ref();
            if let Some(values) = self.args.get(key) {
                match result.is_none() {
                    true => match values.len() {
                        0 => return Err(Error::new(ErrorKind::InvalidData, __!("Internal parser error: no values found"))),
                        1 => result = Some(
                            T::from_str(&values[0])
                                .map_err(|_| Error::new(ErrorKind::Other, format!("Failed parsing value {:?} of {:?}", &values[0], &key)))?
                        ),
                        _ => return Err(Error::new(ErrorKind::InvalidData, format!("Expected 1 value, got: {:?}", &values))),
                    },
                    false => return Err(Error::new(ErrorKind::InvalidData, format!("Duplicate value for {:?}", key))),
                };
            }
        }

        Ok(result)
    }

    /// # Calls [`get()`][self::get()] and removes the keys if the result is `Ok(Some)`
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_args;
    ///
    /// let mut args = dia_args::parse_strings(["--type", "rs"].iter())?;
    /// assert_eq!(args.take::<String, _>(&["--type"])?.unwrap(), "rs");
    /// assert!(args.get::<String, _>(&["--type"])?.is_none());
    ///
    /// # Ok::<_, std::io::Error>(())
    /// ```
    ///
    /// [self::get()]: struct.Args.html#method.get
    pub fn take<T, S>(&mut self, keys: &[S]) -> io::Result<Option<T>> where T: FromStr, S: AsRef<str> {
        let result = self.get(keys);
        if result.as_ref().map(|r| r.is_some()).unwrap_or(false) {
            for key in keys {
                self.args.remove(key.as_ref());
            }
        }

        result
    }

    /// # Gets a vector of values
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_args;
    ///
    /// let args = dia_args::parse_strings(
    ///     ["--type", "ogg", "-t", "m4v", "--type", "md", "-t", "rs"].iter()
    /// )?;
    /// let mut types = args.get_vec::<String, _>(&["-t", "--type"])?.unwrap();
    /// types.sort();
    /// assert_eq!(types, &["m4v", "md", "ogg", "rs"]);
    ///
    /// # Ok::<_, std::io::Error>(())
    /// ```
    pub fn get_vec<T, S>(&self, keys: &[S]) -> io::Result<Option<Vec<T>>> where T: FromStr, S: AsRef<str> {
        let mut result: Option<Vec<_>> = None;

        for key in keys {
            let key = key.as_ref();
            if let Some(values) = self.args.get(key) {
                for v in values.iter() {
                    let v = T::from_str(v).map_err(|_| Error::new(ErrorKind::Other, format!("Failed parsing value {:?} of {:?}", v, key)))?;
                    match result {
                        Some(ref mut result) => result.push(v),
                        None => result = Some(vec![v]),
                    };
                }
            }
        }

        Ok(result)
    }

    /// # Calls [`get_vec()`][self::get_vec()] and removes the keys if the result is `Ok(Some)`
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_args;
    ///
    /// let mut args = dia_args::parse_strings(["-l", "c", "-l", "c++"].iter())?;
    /// let mut languages = args.take_vec::<String, _>(&["-l"])?.unwrap();
    /// languages.sort();
    /// assert_eq!(languages, &["c", "c++"]);
    /// assert!(args.is_empty());
    ///
    /// # Ok::<_, std::io::Error>(())
    /// ```
    ///
    /// [self::get_vec()]: struct.Args.html#method.get_vec
    pub fn take_vec<T, S>(&mut self, keys: &[S]) -> io::Result<Option<Vec<T>>> where T: FromStr, S: AsRef<str> {
        let result = self.get_vec(keys);
        if result.as_ref().map(|r| r.is_some()).unwrap_or(false) {
            for key in keys {
                self.args.remove(key.as_ref());
            }
        }

        result
    }

    /// # Takes commands out
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_args;
    ///
    /// let mut args = dia_args::parse_strings(["do", "this", "--faster=true"].iter())?;
    /// assert_eq!(args.take_cmds().unwrap(), &["do", "this"]);
    ///
    /// # Ok::<_, std::io::Error>(())
    /// ```
    pub fn take_cmds(&mut self) -> Option<Vec<String>> {
        self.cmds.take()
    }

    /// # Takes sub arguments out
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_args;
    ///
    /// let mut args = dia_args::parse_strings(
    ///     ["eat", "chicken", "--", "with", "ronnie-coleman"].iter()
    /// )?;
    /// assert_eq!(args.take_sub_args().unwrap(), &["with", "ronnie-coleman"]);
    ///
    /// # Ok::<_, std::io::Error>(())
    /// ```
    pub fn take_sub_args(&mut self) -> Option<Vec<String>> {
        self.sub_args.take()
    }

    /// # Merges _arguments_ from other
    ///
    /// - This function works on _arguments_, not commands/stdin flag/sub arguments...
    /// - Other's arguments will be taken out, if conditions are met.
    /// - Result is number of items merged.
    ///
    /// ## Examples
    ///
    /// Your program allows the user to set arguments from file. Later you want to give the user new option to set arguments via command line,
    /// overwriting the ones from file. This function can help.
    ///
    /// ```
    /// use dia_args::MergeOption;
    ///
    /// // Here in test, we're parsing from strings.
    /// // In real code, you might want to use dia_args::parse_file()
    /// let mut args_from_file = dia_args::parse_strings(
    ///     ["--debug=false", "--port=6789"].iter()
    /// )?;
    ///
    /// // Command line arguments
    /// let mut cmd_line_args = dia_args::parse_strings(
    ///     ["--debug=true", "--address", "localhost"].iter()
    /// )?;
    ///
    /// // Merge
    /// assert_eq!(args_from_file.merge_args(&mut cmd_line_args, MergeOption::TakeAll), 2);
    ///
    /// assert_eq!(args_from_file.get(&["--debug"])?, Some(true));
    /// assert_eq!(args_from_file.get::<String, _>(&["--address"])?.unwrap(), "localhost");
    /// assert_eq!(args_from_file.get::<u16, _>(&["--port"])?, Some(6789));
    ///
    /// # Ok::<_, std::io::Error>(())
    /// ```
    pub fn merge_args(&mut self, other: &mut Self, merge_option: MergeOption) -> usize {
        let mut count = 0;
        let mut not_merged: Option<HashMap<_, _>> = None;

        for (key, other_value) in other.args.drain() {
            match self.args.get_mut(&key) {
                Some(value) => match merge_option {
                    MergeOption::TakeAll => {
                        *value = other_value;
                        count += 1;
                    },
                    MergeOption::IgnoreExisting => match not_merged.as_mut() {
                        Some(not_merged) => drop(not_merged.insert(key, other_value)),
                        None => not_merged = Some(vec![(key, other_value)].into_iter().collect()),
                    },
                },
                None => {
                    self.args.insert(key, other_value);
                    count += 1;
                },
            };
        }

        if let Some(not_merged) = not_merged {
            other.args = not_merged;
        }

        count
    }

}

///  # Kinds of a single argument
#[derive(Debug, Eq, PartialEq)]
enum ArgKind {

    /// # A command
    Command,

    /// # A short option
    ShortOption,

    /// # A short option with value
    ShortOptionWithValue,

    /// # Multiple boolean short options
    SomeBoolShortOptions,

    /// # A long option
    LongOption,

    /// # A long option with value
    LongOptionWithValue,

    /// # Sub arguments separator
    SubArgsSeparator,

    /// # Stdin indicator
    StdinIndicator,

}

/// # Parses from an iterator of strings
pub fn parse_strings<S, I>(args: I) -> io::Result<Args> where S: AsRef<str>, I: Iterator<Item=S> {
    let mut result = Args {
        cmds: None,
        args: HashMap::new(),
        sub_args: None,
        use_stdin: false,
    };

    /// # Adds option
    fn add_option(arg: &str, value: String, mut options: Option<&mut Vec<String>>, allow_duplicates: bool) -> io::Result<Option<Vec<String>>> {
        if let Some(options) = options.as_mut() {
            if allow_duplicates || options.contains(&value) == false {
                options.push(value);
                return Ok(None);
            } else {
                return Err(Error::new(ErrorKind::InvalidData, format!("Duplicate value for {:?}", &arg)));
            }
        }
        Ok(Some(vec![value]))
    }

    let mut args = args.peekable();

    while let Some(arg) = args.next() {
        let arg = arg.as_ref();
        match ArgKind::parse(arg)? {
            ArgKind::Command => if let Some(cmds) = add_option(arg, arg.to_string(), result.cmds.as_mut(), true)? {
                result.cmds = Some(cmds);
            },
            ArgKind::SomeBoolShortOptions => {
                let parts = arg.splitn(2, '=').collect::<Vec<&str>>();
                let value = match parts.len() {
                    1 => TRUE_AS_STR.to_string(),
                    _ => match parts[1].trim().to_lowercase().as_str() {
                        self::TRUE_AS_STR => self::TRUE_AS_STR.to_string(),
                        self::FALSE_AS_STR => self::FALSE_AS_STR.to_string(),
                        _ => return Err(Error::new(ErrorKind::InvalidData, format!("Invalid some boolean short options: {:?}", &arg))),
                    },
                };
                for chr in parts[0].chars() {
                    let arg = format!("-{}", &chr);
                    if let Some(options) = add_option(&arg, value.clone(), result.args.get_mut(&arg), false)? {
                        result.args.insert(arg, options);
                    }
                }
            },
            ArgKind::ShortOption | ArgKind::LongOption => {
                let value = match args.peek().map(|s| s.as_ref().starts_with('-')) {
                    Some(true) | None => TRUE_AS_STR.to_string(),
                    Some(false) => args.next().map(|s| s.as_ref().to_string()).ok_or_else(||
                        // This shouldn't happen, but it's better than ::unwrap()
                        Error::new(ErrorKind::InvalidData, format!("Missing value for {:?}", &arg))
                    )?,
                };
                if let Some(options) = add_option(arg, value, result.args.get_mut(arg), false)? {
                    result.args.insert(arg.to_string(), options);
                }
            },
            ArgKind::ShortOptionWithValue | ArgKind::LongOptionWithValue => {
                let parts = arg.splitn(2, '=').collect::<Vec<&str>>();
                match parts.len() {
                    2 => {
                        let (arg, value) = (parts[0].to_string(), parts[1].to_string());
                        if let Some(options) = add_option(&arg, value, result.args.get_mut(&arg), false)? {
                            result.args.insert(arg, options);
                        }
                    },
                    _ => return Err(Error::new(ErrorKind::InvalidData, format!("Invalid option: {:?}", &arg))),
                };
            },
            ArgKind::SubArgsSeparator => {
                let sub_args = args.map(|some| some.as_ref().to_string()).collect::<Vec<String>>();
                if sub_args.is_empty() == false {
                    result.sub_args = Some(sub_args);
                }
                break;
            },
            ArgKind::StdinIndicator => {
                match result.use_stdin {
                    true => return Err(Error::new(ErrorKind::InvalidData, format!("Duplicate {:?}", &arg))),
                    false => result.use_stdin = true,
                };
            },
        };
    }

    Ok(result)
}

/// # Parses from process' arguments
pub fn parse() -> io::Result<Args> {
    parse_strings(env::args().skip(1))
}

/// # Parses from file
///
/// ## Rules
///
/// ### Default file
///
/// - Default file is a file named [`DIA_ARGS_FILE_NAME`][crate::DIA_ARGS_FILE_NAME] within directory of the program. On Unix, if the program
///   is a symlink, its parent directory is used. The parent directory of the original file is ***not*** used.<sup><a id='::&1' href='#::1'>
///   `[1]`</a></sup>
/// - If `None` is given, default file will be used.
/// - If input file is resolved as default file, _and_ it does not exist, an empty [`Args`][crate::Args] will be returned.
///
/// ### Limits and syntax
///
/// - An error will be returned if the file's size is larger than [`MAX_DIA_ARGS_FILE_SIZE`][crate::MAX_DIA_ARGS_FILE_SIZE].
///
/// - On Unix:
///
///     + If you don't provide permissions, the file's permissions must be _equal to or more restrictive_ than the program's owners'. Or an
///       error will be returned.
///
///     + If you provide permissions, the file's permissions must _match_ them exactly, or an error will be returned.
///
/// - Empty lines or lines starting with `#` will be ignored.
///
/// - Each command, argument, or option must be placed on a separate line.
///
/// - Normally, a shell will remove leading/trailing marks such as `"..."` or `'...'`. ***However*** those are _not_ required in this file. So
///   you can separate options like these:
///
///     ```shell
///     --passphrase=secret passphrase with white-spaces in it
///     --passphrase        =       secret passphrase with white-spaces in it
///     --passphrase        secret passphrase with white-spaces in it
///     ```
///
///   They're all the same. Also, note that values will be trimmed.
///
/// ---
///
/// 1. <a id='::1' href='#::&1'>`^^`</a> In theory, that is the goal. However [`env::current_exe()`][r::env::current_exe()] function might
///    return the original file (not the symlink). In that case, the parent directory of the original file will be used.
///
/// [crate::Args]: struct.Args.html
/// [crate::DIA_ARGS_FILE_NAME]: constant.DIA_ARGS_FILE_NAME.html
/// [crate::MAX_DIA_ARGS_FILE_SIZE]: constant.MAX_DIA_ARGS_FILE_SIZE.html
/// [r::env::current_exe()]: https://doc.rust-lang.org/std/env/fn.current_exe.html
pub fn parse_file<P>(file: Option<P>, permissions: Option<Permissions>) -> io::Result<Args> where P: AsRef<Path> {
    let current_exe = env::current_exe()?;
    let default_file = match current_exe.parent() {
        Some(dir) => {
            let default_file = dir.join(crate::DIA_ARGS_FILE_NAME);
            match default_file.exists() {
                true => default_file.canonicalize()?,
                false => default_file,
            }
        },
        None => return Err(Error::new(ErrorKind::NotFound, "Could not find parent directory of the program")),
    };
    let file = match file.map(|f| f.as_ref().to_path_buf()) {
        Some(file) => match file.canonicalize() {
            Ok(file) => file,
            Err(err) => return Err(Error::new(err.kind(), format!("Failed accessing {:?}: {:?}", file, err))),
        },
        None => default_file.clone(),
    };
    if file == default_file && default_file.exists() == false {
        return Ok(Args::default());
    }
    if file.exists() == false {
        return Err(Error::new(ErrorKind::NotFound, format!("File not found: {:?}", file)));
    }
    if file.is_file() == false {
        return Err(Error::new(ErrorKind::InvalidInput, format!("Not a file: {:?}", file)));
    }
    if file.metadata()?.len() > crate::MAX_DIA_ARGS_FILE_SIZE {
        return Err(Error::new(ErrorKind::InvalidInput, format!("File too large: {:?} (max allowed: {})", file, crate::MAX_DIA_ARGS_FILE_SIZE)));
    }

    // Verify file permissions
    match permissions {
        Some(permissions) => permissions::matches(&file, permissions)?,
        None => permissions::ensure_second_is_safe(&current_exe, &file)?,
    };

    let mut args: Vec<String> = vec![];
    for line in read_file_to_string(file, Some(crate::MAX_DIA_ARGS_FILE_SIZE))?.lines() {
        let line = line.trim();
        if line.is_empty() || line.starts_with('#') {
            continue;
        }
        if line.starts_with('-') == false || false == ['=', ' ', '\t'].iter().any(|separator| match line.find(*separator) {
            Some(idx) => {
                args.push(format!("{}={}", line[..idx].trim(), line[idx + 1..].trim()));
                true
            },
            None => false,
        }) {
            args.push(line.to_owned());
        }
    }

    parse_strings(args.into_iter())
}

/// # Reads file to string with optional limit
fn read_file_to_string<P>(file: P, limit: Option<u64>) -> io::Result<String> where P: AsRef<Path> {
    const BUF_SIZE: usize = 8 * 1024;

    let file = file.as_ref();
    let limit = file.metadata()?.len().min(limit.unwrap_or(u64::max_value()));
    let mut reader = BufReader::new(File::open(file)?).take(limit);

    let mut buf = [0; BUF_SIZE];
    let mut data = Vec::with_capacity(limit as usize);
    loop {
        match reader.read(&mut buf)? {
            0 => return String::from_utf8(data).map_err(|e| Error::new(ErrorKind::InvalidData, e)),
            read => data.extend(&buf[..read]),
        };
    }
}

impl ArgKind {

    /// # Parses long options
    ///
    /// 2 leading characters are expected to be `--`. They won't be verified but will be ignored.
    fn parse_long_options<S>(s: S) -> io::Result<ArgKind> where S: AsRef<str> {
        let s = s.as_ref();

        for (index, chr) in s.chars().skip(2).enumerate() {
            match chr {
                '=' => match index {
                    0 => return Err(Error::new(ErrorKind::InvalidData, format!("Invalid long option: {:?}", &s))),
                    _ => return Ok(ArgKind::LongOptionWithValue),
                },
                'a'...'z' | 'A'...'Z' | '0'...'9' | '-' => continue,
                _ => return Err(Error::new(ErrorKind::InvalidData, format!("Invalid long option: {:?}", &s))),
            };
        }

        Ok(ArgKind::LongOption)
    }

    /// # Parses short options
    ///
    /// The first leading character is expected to be `-`. It won't be verified but will be ignored.
    fn parse_short_options<S>(s: S) -> io::Result<ArgKind> where S: AsRef<str> {
        let s = s.as_ref();

        let mut must_be_some_bool_options = false;
        let mut chars = s.char_indices().skip(1);
        while let Some((index, chr)) = chars.next() {
            match chr {
                '=' => match index {
                    // This shouldn't be true, we skipped 1 above
                    0 => return Err(Error::new(ErrorKind::Other, __!("Invalid index: {} -> {}", &index, &chr))),
                    1 => return Err(Error::new(ErrorKind::InvalidData, format!("Invalid short option: {:?}", &s))),
                    2 => return Ok(ArgKind::ShortOptionWithValue),
                    _ => match chars.map(|(_, chr)| chr).collect::<String>().trim().to_lowercase().as_str() {
                        self::TRUE_AS_STR | self::FALSE_AS_STR => return Ok(ArgKind::SomeBoolShortOptions),
                        _ => return Err(Error::new(ErrorKind::InvalidData, format!("Invalid some boolean short options: {:?}", &s))),
                    },
                },
                'a'...'z' | 'A'...'Z' | '0'...'9' => if index > 1 {
                    must_be_some_bool_options = true;
                },
                _ => return Err(Error::new(ErrorKind::InvalidData, format!("Invalid short option: {:?}", &s))),
            };
        }
        match must_be_some_bool_options {
            true => Ok(ArgKind::SomeBoolShortOptions),
            false => Ok(ArgKind::ShortOption),
        }
    }

    /// # Parses argument kind
    fn parse<S>(s: S) -> io::Result<ArgKind> where S: AsRef<str> {
        let s = s.as_ref();

        if s.starts_with("--") {
            return match s.len() {
                2 => Ok(ArgKind::SubArgsSeparator),
                _ => Self::parse_long_options(s),
            };
        }
        if s.starts_with('-') {
            return match s.len() {
                1 => Ok(ArgKind::StdinIndicator),
                _ => Self::parse_short_options(s),
            };
        }

        Ok(ArgKind::Command)
    }

}

/// # Reads a line from stdin, trims and converts it to `T`
pub fn read_line<T>() -> io::Result<T> where T: FromStr {
    let stdin = io::stdin();
    let mut stdin = stdin.lock();

    let mut buf = String::with_capacity(64);
    stdin.read_line(&mut buf)?;

    let buf = buf.trim();
    T::from_str(&buf).map_err(|_| Error::new(ErrorKind::InvalidData, format!("Invalid {:?}", buf)))
}