// Copyright (C) 2015  Daniel Trebbien
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library.  If not, see <http://www.gnu.org/licenses/>.

use std::fmt::{Display, Error, Formatter};
use std::io::{BufRead};
use std::iter::{IntoIterator};
use std::option::{Option};
use std::result::{Result};
use std::slice::{Iter, IterMut};
use std::str::{FromStr};
use std::string::{String};
use std::vec::{Vec};

/// Holds information about a parse error generated while parsing a suppressions file.
pub struct ParseError {
    /// Line number where the parse error occurred.
    pub lineno: usize,

    /// Description of the parse error.
    pub message: String,
}

impl Display for ParseError {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
        write!(fmt, "line {}: {}", self.lineno, self.message)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub enum Frame {
    /// A frame-level wildcard, represented by `'...'`.
    FrameWildcard,

    /// An object frame.
    ObjFrame {
        /// A file glob for the path to the object file. This may contain wildcard characters
        /// `*` and `?`.
        glob: String,
    },

    /// A function frame.
    FunFrame {
        /// Glob for the name of the function. This may contain wildcard characters `*` and `?`.
        glob: String,
    },
}

impl Display for Frame {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
        use Frame::*;
        match *self {
            FrameWildcard => write!(fmt, "..."),
            ObjFrame { ref glob } => {
                write!(fmt, "obj:{}", glob)
            },
            FunFrame { ref glob } => {
                write!(fmt, "fun:{}", glob)
            },
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub enum SuppressionType {
    MemcheckAddr(usize),
    MemcheckCond,
    MemcheckFree,
    MemcheckLeak,
    MemcheckOverlap,
    MemcheckParam,
    MemcheckValue(usize),
    OtherType {
        tool_name: String,
        suppression_type: String,
    },
}

impl Display for SuppressionType {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
        use SuppressionType::*;
        match *self {
            MemcheckAddr(n) => write!(fmt, "Memcheck:Addr{}", n),
            MemcheckCond => write!(fmt, "Memcheck:Cond"),
            MemcheckFree => write!(fmt, "Memcheck:Free"),
            MemcheckLeak => write!(fmt, "Memcheck:Leak"),
            MemcheckOverlap => write!(fmt, "Memcheck:Overlap"),
            MemcheckParam => write!(fmt, "Memcheck:Param"),
            MemcheckValue(n) => write!(fmt, "Memcheck:Value{}", n),
            OtherType { ref tool_name, ref suppression_type } => {
                write!(fmt, "{}:{}", tool_name, suppression_type)
            },
        }
    }
}

/// Holds information about a single Valgrind suppression.
#[derive(Clone, Debug, PartialEq)]
pub struct Suppression {
    /// The name of the suppression.
    pub name: String,
    /// The type of suppression.
    pub type_: SuppressionType,
    /// Any extra information, where used by the suppression type (e.g. a Memcheck `Param` suppression).
    pub opt_extra_info: Option<Vec<String>>,
    /// The calling context of the suppression.
    pub frames: Vec<Frame>,
}

impl Display for Suppression {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
        try!(writeln!(fmt, "{{"));
        try!(writeln!(fmt, "   {}", self.name));
        try!(writeln!(fmt, "   {}", self.type_));
        if let Some(ref extra_info) = self.opt_extra_info {
            for line in extra_info {
                try!(writeln!(fmt, "   {}", line));
            }
        }
        for frame in &self.frames {
            try!(writeln!(fmt, "   {}", frame));
        }
        write!(fmt, "}}")
    }
}

/// A set of Valgrind suppressions.
#[derive(Clone)]
pub struct Suppressions {
    suppressions: Vec<Suppression>
}

enum ParseState {
    BeforeOpeningBrace,
    AfterOpeningBrace {
        opening_brace_lineno: usize,
    },
    HaveName {
        opening_brace_lineno: usize,
        name: String,
    },
    HaveSuppressionType {
        opening_brace_lineno: usize,
        name: String,
        tool_names: Vec<String>,
        suppression_type: String,
        /// Lines of extra information, used by some suppression types (e.g. a Memcheck `Param` suppression).
        opt_extra_info: Option<Vec<String>>,
    },
    HaveOptExtraInfo {
        opening_brace_lineno: usize,
        name: String,
        tool_names: Vec<String>,
        suppression_type: String,
        opt_extra_info: Option<Vec<String>>,
        frames: Vec<Frame>,
    },
}

impl Suppressions {

    /// Parses the suppressions from `buf` in Valgrind suppression syntax.
    ///
    /// # See also
    /// * [Suppressing errors](http://valgrind.org/docs/manual/manual-core.html#manual-core.suppress). Valgrind User Manual.
    pub fn parse<B: BufRead>(buf: &mut B) -> Result<Suppressions, ParseError> {
        use ParseState::*;

        let mut suppressions: Vec<Suppression> = Vec::new();
        let mut lineno = 0;
        let mut state = BeforeOpeningBrace;
        for line_res in buf.lines() {
            match line_res {
                Err(e) => {
                    return Err(ParseError {
                        lineno: lineno,
                        message: format!("IoError returned: {}", e),
                    });
                },
                Ok(line) => {
                    lineno = lineno + 1;

                    let trimmed_line = line.trim();
                    if !trimmed_line.is_empty() && !trimmed_line.starts_with("#") {
                        state = match state {
                                BeforeOpeningBrace => {
                                    if trimmed_line == "{" {
                                        AfterOpeningBrace {
                                            opening_brace_lineno: lineno
                                        }
                                    } else if trimmed_line.starts_with('{') {
                                        return Err(ParseError {
                                            lineno: lineno,
                                            message: "expecting an opening brace on its own line".to_string(),
                                        });
                                    } else {
                                        return Err(ParseError {
                                            lineno: lineno,
                                            message: "expecting an opening brace".to_string(),
                                        });
                                    }
                                },
                                AfterOpeningBrace { opening_brace_lineno } => {
                                    // If there is a closing brace immediately after the opening brace,
                                    // then skip this "empty" suppression (go back to the BeforeOpeningBrace
                                    // state).
                                    if trimmed_line == "}" {
                                        BeforeOpeningBrace
                                    } else if trimmed_line.contains('}') {
                                        return Err(ParseError {
                                            lineno: lineno,
                                            message: "the suppression name cannot contain a closing brace '}'".to_string(),
                                        });
                                    } else {
                                        HaveName {
                                            opening_brace_lineno: opening_brace_lineno,
                                            name: trimmed_line.to_string(),
                                        }
                                    }
                                },
                                HaveName { opening_brace_lineno, name } => {
                                    let colon_pos = match trimmed_line.find(':') {
                                            None => {
                                                return Err(ParseError {
                                                    lineno: lineno,
                                                    message: "no suppression type was found".to_string(),
                                                });
                                            }
                                            Some(colon_pos) => colon_pos,
                                        };
                                    let splits = trimmed_line[..colon_pos].split(',');
                                    let tool_names: Vec<String> = splits.map(|part| part.to_string()).collect();
                                    HaveSuppressionType {
                                        opening_brace_lineno: opening_brace_lineno,
                                        name: name,
                                        tool_names: tool_names,
                                        suppression_type: trimmed_line[colon_pos + 1..].to_string(),
                                        opt_extra_info: None,
                                    }
                                },
                                HaveSuppressionType {
                                    opening_brace_lineno,
                                    name,
                                    tool_names,
                                    suppression_type,
                                    mut opt_extra_info,
                                } => {
                                    if trimmed_line == "..." {
                                        HaveOptExtraInfo {
                                            opening_brace_lineno: opening_brace_lineno,
                                            name: name,
                                            tool_names: tool_names,
                                            suppression_type: suppression_type,
                                            opt_extra_info: opt_extra_info,
                                            frames: vec![Frame::FrameWildcard],
                                        }
                                    } else if trimmed_line.starts_with("obj:") {
                                        let glob = trimmed_line[4..].trim_left().to_string();
                                        HaveOptExtraInfo {
                                            opening_brace_lineno: opening_brace_lineno,
                                            name: name,
                                            tool_names: tool_names,
                                            suppression_type: suppression_type,
                                            opt_extra_info: opt_extra_info,
                                            frames: vec![Frame::ObjFrame { glob: glob }],
                                        }
                                    } else if trimmed_line.starts_with("fun:") {
                                        let glob = trimmed_line[4..].trim_left().to_string();
                                        HaveOptExtraInfo {
                                            opening_brace_lineno: opening_brace_lineno,
                                            name: name,
                                            tool_names: tool_names,
                                            suppression_type: suppression_type,
                                            opt_extra_info: opt_extra_info,
                                            frames: vec![Frame::FunFrame { glob: glob }],
                                        }
                                    // If there is no calling context for this suppression, then skip it.
                                    // TODO This might not be 100% correct. Perhaps some suppressions only use extra info?
                                    } else if trimmed_line == "}" {
                                        BeforeOpeningBrace
                                    } else {
                                        if let Some(ref mut extra_info) = opt_extra_info {
                                            extra_info.push(trimmed_line.to_string());
                                        } else {
                                            opt_extra_info = Some(vec![trimmed_line.to_string()]);
                                        }
                                        HaveSuppressionType {
                                            opening_brace_lineno: opening_brace_lineno,
                                            name: name,
                                            tool_names: tool_names,
                                            suppression_type: suppression_type,
                                            opt_extra_info: opt_extra_info,
                                        }
                                    }
                                },
                                HaveOptExtraInfo {
                                    opening_brace_lineno,
                                    name,
                                    tool_names,
                                    suppression_type,
                                    opt_extra_info,
                                    mut frames,
                                } => {
                                    if trimmed_line == "..." {
                                        frames.push(Frame::FrameWildcard);
                                        HaveOptExtraInfo {
                                            opening_brace_lineno: opening_brace_lineno,
                                            name: name,
                                            tool_names: tool_names,
                                            suppression_type: suppression_type,
                                            opt_extra_info: opt_extra_info,
                                            frames: frames,
                                        }
                                    } else if trimmed_line.starts_with("obj:") {
                                        frames.push(Frame::ObjFrame {
                                            glob: trimmed_line[4..].trim_left().to_string(),
                                        });
                                        HaveOptExtraInfo {
                                            opening_brace_lineno: opening_brace_lineno,
                                            name: name,
                                            tool_names: tool_names,
                                            suppression_type: suppression_type,
                                            opt_extra_info: opt_extra_info,
                                            frames: frames,
                                        }
                                    } else if trimmed_line.starts_with("fun:") {
                                        frames.push(Frame::FunFrame {
                                            glob: trimmed_line[4..].trim_left().to_string(),
                                        });
                                        HaveOptExtraInfo {
                                            opening_brace_lineno: opening_brace_lineno,
                                            name: name,
                                            tool_names: tool_names,
                                            suppression_type: suppression_type,
                                            opt_extra_info: opt_extra_info,
                                            frames: frames,
                                        }
                                    } else if trimmed_line == "}" {
                                        suppressions.extend(tool_names.iter().map(|tool_name| -> Suppression {
                                            let type_ = if tool_name == "Memcheck" {
                                                    if suppression_type.starts_with("Addr") {
                                                        match usize::from_str(&suppression_type[4..]) {
                                                            Err(_) => SuppressionType::OtherType {
                                                                tool_name: tool_name.to_string(),
                                                                suppression_type: suppression_type.clone(),
                                                            },
                                                            Ok(n) => SuppressionType::MemcheckAddr(n),
                                                        }
                                                    } else if suppression_type == "Cond" {
                                                        SuppressionType::MemcheckCond
                                                    } else if suppression_type == "Free" {
                                                        SuppressionType::MemcheckFree
                                                    } else if suppression_type == "Leak" {
                                                        SuppressionType::MemcheckLeak
                                                    } else if suppression_type == "Overlap" {
                                                        SuppressionType::MemcheckOverlap
                                                    } else if suppression_type == "Param" {
                                                        SuppressionType::MemcheckParam
                                                    } else if suppression_type.starts_with("Value") {
                                                        match usize::from_str(&suppression_type[5..]) {
                                                            Err(_) => SuppressionType::OtherType {
                                                                tool_name: tool_name.to_string(),
                                                                suppression_type: suppression_type.clone(),
                                                            },
                                                            Ok(n) => SuppressionType::MemcheckValue(n),
                                                        }
                                                    } else {
                                                        SuppressionType::OtherType {
                                                            tool_name: tool_name.to_string(),
                                                            suppression_type: suppression_type.clone(),
                                                        }
                                                    }
                                                } else {
                                                    SuppressionType::OtherType {
                                                        tool_name: tool_name.to_string(),
                                                        suppression_type: suppression_type.clone(),
                                                    }
                                                };
                                            Suppression {
                                                name: name.clone(),
                                                type_: type_,
                                                opt_extra_info: opt_extra_info.clone(),
                                                frames: frames.clone(),
                                            }
                                        }));

                                        BeforeOpeningBrace
                                    } else {
                                        return Err(ParseError {
                                            lineno: lineno,
                                            message: "invalid calling context line".to_string(),
                                        });
                                    }
                                },
                            }; // end match state
                    }
                }, // end Ok(line)
            }
        }
        match state {
            AfterOpeningBrace {
                opening_brace_lineno,
                ..
            } => {
                return Err(ParseError {
                    lineno: opening_brace_lineno,
                    message: "unexpectedly encountered EOF while parsing a suppression".to_string(),
                });
            },
            HaveName {
                opening_brace_lineno,
                name,
            } => {
                return Err(ParseError {
                    lineno: opening_brace_lineno,
                    message: format!("unexpectedly encountered EOF while parsing the suppression named '{}'", name),
                });
            },
            HaveSuppressionType {
                opening_brace_lineno,
                name,
                ..
            } => {
                return Err(ParseError {
                    lineno: opening_brace_lineno,
                    message: format!("unexpectedly encountered EOF while parsing the suppression named '{}'", name),
                });
            },
            HaveOptExtraInfo {
                opening_brace_lineno,
                name,
                ..
            } => {
                return Err(ParseError {
                    lineno: opening_brace_lineno,
                    message: format!("unexpectedly encountered EOF while parsing the suppression named '{}'", name),
                });
            },
            _ => (),
        }

        Ok(Suppressions {
            suppressions: suppressions,
        })
    }

    /// Clones all of the suppressions in `other` and adds them to these suppressions.
    pub fn add_all(&mut self, other: &Suppressions) {
        self.suppressions.extend(other.suppressions.iter().cloned());
    }

    pub fn count(&self) -> usize {
        self.suppressions.len()
    }

    pub fn iter(&self) -> Iter<Suppression> {
        self.suppressions.iter()
    }

    pub fn iter_mut(&mut self) -> IterMut<Suppression> {
        self.suppressions.iter_mut()
    }
}

impl Display for Suppressions {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
        for suppression in &self.suppressions {
            try!(writeln!(fmt, "{}", suppression));
        }
        Ok(())
    }
}

impl<'a> IntoIterator for &'a Suppressions {
    type Item = &'a Suppression;
    type IntoIter = Iter<'a, Suppression>;

    fn into_iter(self) -> Iter<'a, Suppression> {
        self.iter()
    }
}