//! Unified diff parsing/metadata extraction library for Rust
//!
//! # Examples
//!
//! ```
//! extern crate unidiff;
//!
//! use unidiff::PatchSet;
//!
//! fn main() {
//!     let diff_str = "diff --git a/added_file b/added_file
//! new file mode 100644
//! index 0000000..9b710f3
//! --- /dev/null
//! +++ b/added_file
//! @@ -0,0 +1,4 @@
//! +This was missing!
//! +Adding it now.
//! +
//! +Only for testing purposes.";
//!     let mut patch = PatchSet::new();
//!     patch.parse(diff_str).ok().expect("Error parsing diff");
//! }
//! ```
extern crate regex;
#[macro_use]
extern crate lazy_static;
extern crate encoding;

use std::fmt;
use std::error;
use std::ops::{Index, IndexMut};

use regex::Regex;


lazy_static! {
    static ref RE_SOURCE_FILENAME: Regex = Regex::new(r"^--- (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?").unwrap();
    static ref RE_TARGET_FILENAME: Regex = Regex::new(r"^\+\+\+ (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?").unwrap();
    static ref RE_HUNK_HEADER: Regex = Regex::new(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@[ ]?(.*)").unwrap();
    static ref RE_HUNK_BODY_LINE: Regex = Regex::new(r"^(?P<line_type>[- \n\+\\]?)(?P<value>.*)").unwrap();
}

/// Diff line is added
pub const LINE_TYPE_ADDED: &'static str = "+";
/// Diff line is removed
pub const LINE_TYPE_REMOVED: &'static str = "-";
/// Diff line is context
pub const LINE_TYPE_CONTEXT: &'static str = " ";
/// Diff line is empty
pub const LINE_TYPE_EMPTY: &'static str = "\n";

/// Error type
#[derive(Debug, Clone)]
pub enum Error {
    /// Target without source
    TargetWithoutSource(String),
    /// Unexpected hunk found
    UnexpectedHunk(String),
    /// Hunk line expected
    ExpectLine(String),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Error::TargetWithoutSource(ref l) => write!(f, "Target without source: {}", l),
            Error::UnexpectedHunk(ref l) => write!(f, "Unexpected hunk found: {}", l),
            Error::ExpectLine(ref l) => write!(f, "Hunk line expected: {}", l),
        }
    }
}

impl error::Error for Error {
    fn description(&self) -> &str {
        match *self {
            Error::TargetWithoutSource(..) => "Target without source",
            Error::UnexpectedHunk(..) => "Unexpected hunk found",
            Error::ExpectLine(..) => "Hunk line expected",
        }
    }
}

/// `unidiff::parse` result type
pub type Result<T> = ::std::result::Result<T, Error>;


/// A diff line
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Line {
    /// Source file line number
    pub source_line_no: Option<usize>,
    /// Target file line number
    pub target_line_no: Option<usize>,
    /// Diff file line number
    pub diff_line_no: usize,
    /// Diff line type
    pub line_type: String,
    /// Diff line content value
    pub value: String,
}

impl Line {
    pub fn new<T: Into<String>>(value: T, line_type: T) -> Line {
        Line {
            source_line_no: Some(0usize),
            target_line_no: Some(0usize),
            diff_line_no: 0usize,
            line_type: line_type.into(),
            value: value.into(),
        }
    }

    /// Diff line type is added
    pub fn is_added(&self) -> bool {
        LINE_TYPE_ADDED == &self.line_type
    }

    /// Diff line type is removed
    pub fn is_removed(&self) -> bool {
        LINE_TYPE_REMOVED == &self.line_type
    }

    /// Diff line type is context
    pub fn is_context(&self) -> bool {
        LINE_TYPE_CONTEXT == &self.line_type
    }
}

impl fmt::Display for Line {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}{}", self.line_type, self.value)
    }
}

/// Each of the modified blocks of a file
///
/// You can iterate over it to get ``Line``s.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Hunk {
    /// Count of lines added
    added: usize,
    /// Count of lines removed
    removed: usize,
    /// Source file starting line number
    pub source_start: usize,
    /// Source file changes length
    pub source_length: usize,
    /// Target file starting line number
    pub target_start: usize,
    /// Target file changes length
    pub target_length: usize,
    /// Section header
    pub section_header: String,
    lines: Vec<Line>,
    source: Vec<String>,
    target: Vec<String>,
}

impl Hunk {
    pub fn new<T: Into<String>>(source_start: usize,
                                source_length: usize,
                                target_start: usize,
                                target_length: usize,
                                section_header: T)
                                -> Hunk {
        Hunk {
            added: 0usize,
            removed: 0usize,
            source_start: source_start,
            source_length: source_length,
            target_start: target_start,
            target_length: target_length,
            section_header: section_header.into(),
            lines: vec![],
            source: vec![],
            target: vec![],
        }
    }

    /// Count of lines added
    pub fn added(&self) -> usize {
        self.added
    }

    /// Count of lines removed
    pub fn removed(&self) -> usize {
        self.removed
    }

    /// Is this hunk valid
    pub fn is_valid(&self) -> bool {
        self.source.len() == self.source_length && self.target.len() == self.target_length
    }

    /// Lines from source file
    pub fn source_lines(&self) -> Vec<Line> {
        self.lines.iter().cloned().filter(|l| l.is_context() || l.is_removed()).collect()
    }

    /// Lines from target file
    pub fn target_lines(&self) -> Vec<Line> {
        self.lines.iter().cloned().filter(|l| l.is_context() || l.is_added()).collect()
    }

    /// Append new line into hunk
    pub fn append(&mut self, line: Line) {
        if line.is_added() {
            self.added = self.added + 1;
            self.target.push(format!("{}{}", line.line_type, line.value));
        } else if line.is_removed() {
            self.removed = self.removed + 1;
            self.source.push(format!("{}{}", line.line_type, line.value));
        } else if line.is_context() {
            self.source.push(format!("{}{}", line.line_type, line.value));
            self.target.push(format!("{}{}", line.line_type, line.value));
        }
        self.lines.push(line);
    }

    /// Count of lines in this hunk
    pub fn len(&self) -> usize {
        self.lines.len()
    }

    /// Is this hunk empty
    pub fn is_empty(&self) -> bool {
        self.lines.is_empty()
    }
}

impl fmt::Display for Hunk {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let header = format!("@@ -{},{} +{},{} @@ {}\n",
                             self.source_start,
                             self.source_length,
                             self.target_start,
                             self.target_length,
                             self.section_header);
        let content = self.lines.iter().map(|l| l.to_string()).collect::<Vec<String>>().join("\n");
        write!(f, "{}{}", header, content)
    }
}

impl IntoIterator for Hunk {
    type Item = Line;
    type IntoIter = ::std::vec::IntoIter<Line>;

    fn into_iter(self) -> Self::IntoIter {
        self.lines.into_iter()
    }
}

impl Index<usize> for Hunk {
    type Output = Line;

    fn index(&self, idx: usize) -> &Line {
        &self.lines[idx]
    }
}

impl IndexMut<usize> for Hunk {
    fn index_mut(&mut self, index: usize) -> &mut Line {
        &mut self.lines[index]
    }
}

/// Patch updated file, contains a list of Hunks
///
/// You can iterate over it to get ``Hunk``s.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PatchedFile {
    /// Source file name
    pub source_file: String,
    /// Source file timestamp
    pub source_timestamp: Option<String>,
    /// Target file name
    pub target_file: String,
    /// Target file timestamp
    pub target_timestamp: Option<String>,
    hunks: Vec<Hunk>,
}

impl PatchedFile {
    /// Initialize a new PatchedFile instance
    pub fn new<T: Into<String>>(source_file: T, target_file: T) -> PatchedFile {
        PatchedFile {
            source_file: source_file.into(),
            target_file: target_file.into(),
            source_timestamp: None,
            target_timestamp: None,
            hunks: vec![],
        }
    }

    /// Initialize a new PatchedFile instance with hunks
    pub fn with_hunks<T: Into<String>>(source_file: T, target_file: T, hunks: Vec<Hunk>) -> PatchedFile {
        PatchedFile {
            source_file: source_file.into(),
            target_file: target_file.into(),
            source_timestamp: None,
            target_timestamp: None,
            hunks: hunks,
        }
    }

    /// Patched file relative path
    pub fn path(&self) -> String {
        if self.source_file.starts_with("a/") && self.target_file.starts_with("b/") {
            return self.source_file[2..].to_owned();
        }
        if self.source_file.starts_with("a/") && "/dev/null" == &self.target_file {
            return self.source_file[2..].to_owned();
        }
        if self.target_file.starts_with("b/") && "/dev/null" == &self.source_file {
            return self.target_file[2..].to_owned();
        }
        self.source_file.clone()
    }

    /// Count of lines added
    pub fn added(&self) -> usize {
        self.hunks.iter().map(|h| h.added).fold(0, |acc, x| acc + x)
    }

    /// Count of lines removed
    pub fn removed(&self) -> usize {
        self.hunks.iter().map(|h| h.removed).fold(0, |acc, x| acc + x)
    }

    /// Is this file newly added
    pub fn is_added_file(&self) -> bool {
        self.hunks.len() == 1 && self.hunks[0].source_start == 0 && self.hunks[0].source_length == 0
    }

    /// Is this file removed
    pub fn is_removed_file(&self) -> bool {
        self.hunks.len() == 1 && self.hunks[0].target_start == 0 && self.hunks[0].target_length == 0
    }

    /// Is this file modified
    pub fn is_modified_file(&self) -> bool {
        !self.is_added_file() && !self.is_removed_file()
    }

    fn parse_hunk(&mut self, header: &str, diff: &[(usize, &str)]) -> Result<()> {
        let header_info = RE_HUNK_HEADER.captures(header).unwrap();
        let source_start = header_info.get(1).unwrap().as_str().parse::<usize>().unwrap();
        let source_length = header_info.get(2).unwrap().as_str().parse::<usize>().unwrap();
        let target_start = header_info.get(3).unwrap().as_str().parse::<usize>().unwrap();
        let target_length = header_info.get(4).unwrap().as_str().parse::<usize>().unwrap();
        let section_header = header_info.get(5).unwrap().as_str();
        let mut hunk = Hunk {
            added: 0usize,
            removed: 0usize,
            source: vec![],
            target: vec![],
            lines: vec![],
            source_start: source_start,
            source_length: source_length,
            target_start: target_start,
            target_length: target_length,
            section_header: section_header.to_owned(),
        };
        let mut source_line_no = source_start;
        let mut target_line_no = target_start;
        let expected_source_end = source_start + source_length;
        let expected_target_end = target_start + target_length;
        for &(diff_line_no, line) in diff {
            if let Some(valid_line) = RE_HUNK_BODY_LINE.captures(line) {
                let mut line_type = valid_line.name("line_type").unwrap().as_str();
                if line_type == LINE_TYPE_EMPTY || line_type == "" {
                    line_type = LINE_TYPE_CONTEXT;
                }
                let value = valid_line.name("value").unwrap().as_str();
                let mut original_line = Line {
                    source_line_no: None,
                    target_line_no: None,
                    diff_line_no: diff_line_no + 1,
                    line_type: line_type.to_owned(),
                    value: value.to_owned(),
                };
                match line_type {
                    LINE_TYPE_ADDED => {
                        original_line.target_line_no = Some(target_line_no);
                        target_line_no = target_line_no + 1;
                    }
                    LINE_TYPE_REMOVED => {
                        original_line.source_line_no = Some(source_line_no);
                        source_line_no = source_line_no + 1;
                    }
                    LINE_TYPE_CONTEXT => {
                        original_line.target_line_no = Some(target_line_no);
                        target_line_no = target_line_no + 1;
                        original_line.source_line_no = Some(source_line_no);
                        source_line_no = source_line_no + 1;
                    }
                    _ => {}
                }
                hunk.append(original_line);
                if source_line_no == expected_source_end && target_line_no == expected_target_end {
                    break;
                }
            } else {
                return Err(Error::ExpectLine(line.to_owned()));
            }
        }
        self.hunks.push(hunk);
        Ok(())
    }

    /// Count of hunks
    pub fn len(&self) -> usize {
        self.hunks.len()
    }

    pub fn is_empty(&self) -> bool {
        self.hunks.is_empty()
    }
}

impl fmt::Display for PatchedFile {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let source = format!("--- {}\n", self.source_file);
        let target = format!("+++ {}\n", self.target_file);
        let hunks = self.hunks.iter().map(|h| h.to_string()).collect::<Vec<String>>().join("\n");
        write!(f, "{}{}{}", source, target, hunks)
    }
}

impl IntoIterator for PatchedFile {
    type Item = Hunk;
    type IntoIter = ::std::vec::IntoIter<Hunk>;

    fn into_iter(self) -> Self::IntoIter {
        self.hunks.into_iter()
    }
}

impl Index<usize> for PatchedFile {
    type Output = Hunk;

    fn index(&self, idx: usize) -> &Hunk {
        &self.hunks[idx]
    }
}

impl IndexMut<usize> for PatchedFile {
    fn index_mut(&mut self, index: usize) -> &mut Hunk {
        &mut self.hunks[index]
    }
}

/// Unfied patchset
///
/// You can iterate over it to get ``PatchedFile``s.
///
/// ```ignore
/// let mut patch = PatchSet::new();
/// patch.parse("some diff");
/// for patched_file in patch {
///   // do something with patched_file
///   for hunk in patched_file {
///       // do something with hunk
///       for line in hunk {
///           // do something with line
///       }
///   }
/// }
/// ```
#[derive(Clone, Default)]
pub struct PatchSet {
    files: Vec<PatchedFile>,
    encoding: Option<encoding::EncodingRef>,
}

impl fmt::Debug for PatchSet {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PatchSet")
           .field("files", &self.files)
           .finish()
    }
}

impl PatchSet {
    /// Added files vector
    pub fn added_files(&self) -> Vec<PatchedFile> {
        self.files.iter().cloned().filter(|f| f.is_added_file()).collect()
    }

    /// Removed files vector
    pub fn removed_files(&self) -> Vec<PatchedFile> {
        self.files.iter().cloned().filter(|f| f.is_removed_file()).collect()
    }

    /// Modified files vector
    pub fn modified_files(&self) -> Vec<PatchedFile> {
        self.files.iter().cloned().filter(|f| f.is_modified_file()).collect()
    }

    /// Initialize a new PatchSet instance
    pub fn new() -> PatchSet {
        PatchSet {
            files: vec![],
            encoding: None,
        }
    }

    /// Initialize a new PatchedSet instance with encoding
    pub fn with_encoding(coding: encoding::EncodingRef) -> PatchSet {
        PatchSet {
            files: vec![],
            encoding: Some(coding),
        }
    }

    /// Initialize a new PatchedSet instance with encoding(string form)
    pub fn from_encoding<T: AsRef<str>>(coding: T) -> PatchSet {
        let codec = encoding::label::encoding_from_whatwg_label(coding.as_ref());
        PatchSet {
            files: vec![],
            encoding: codec,
        }
    }

    /// Parse diff from bytes
    pub fn parse_bytes(&mut self, input: &[u8]) -> Result<()> {
        let input = if let Some(codec) = self.encoding {
            codec.decode(input, encoding::DecoderTrap::Ignore).unwrap()
        } else {
            encoding::decode(input, encoding::DecoderTrap::Strict, encoding::all::UTF_8)
                .0
                .unwrap_or(String::from_utf8(input.to_vec()).unwrap())
        };
        self.parse(input)
    }

    /// Parse diff from string
    pub fn parse<T: AsRef<str>>(&mut self, input: T) -> Result<()> {
        let input = input.as_ref();
        let mut current_file: Option<PatchedFile> = None;
        let diff: Vec<(usize, &str)> = input.split('\n').enumerate().collect();
        let mut source_file: Option<String> = None;
        let mut source_timestamp: Option<String> = None;

        for &(line_no, line) in &diff {
            // check for source file header
            if let Some(captures) = RE_SOURCE_FILENAME.captures(line) {
                source_file = match captures.name("filename") {
                    Some(ref filename) => Some(filename.as_str().to_owned()),
                    None => Some("".to_owned())
                };
                source_timestamp = match captures.name("timestamp") {
                    Some(ref timestamp) => Some(timestamp.as_str().to_owned()),
                    None => Some("".to_owned())
                };
                if let Some(patched_file) = current_file {
                    self.files.push(patched_file.clone());
                }
                current_file = None;
                continue;
            }
            // check for target file header
            if let Some(captures) = RE_TARGET_FILENAME.captures(line) {
                if current_file.is_some() {
                    return Err(Error::TargetWithoutSource(line.to_owned()));
                }
                let target_file = match captures.name("filename") {
                    Some(ref filename) => Some(filename.as_str().to_owned()),
                    None => Some("".to_owned())
                };
                let target_timestamp = match captures.name("timestamp") {
                    Some(ref timestamp) => Some(timestamp.as_str().to_owned()),
                    None => Some("".to_owned())
                };

                // add current file to PatchSet
                current_file = Some(PatchedFile {
                    source_file: source_file.clone().unwrap(),
                    target_file: target_file.clone().unwrap(),
                    source_timestamp: source_timestamp.clone(),
                    target_timestamp: target_timestamp.clone(),
                    hunks: vec![],
                });
                continue;
            }
            // check for hunk header
            if RE_HUNK_HEADER.is_match(line) {
                if let Some(ref mut patched_file) = current_file {
                    try!(patched_file.parse_hunk(line, &diff[line_no + 1..]));
                } else {
                    return Err(Error::UnexpectedHunk(line.to_owned()));
                }
            }
        }
        if let Some(patched_file) = current_file {
            self.files.push(patched_file.clone());
        }
        Ok(())
    }

    /// Count of patched files
    pub fn len(&self) -> usize {
        self.files.len()
    }

    pub fn is_empty(&self) -> bool {
        self.files.is_empty()
    }
}

impl fmt::Display for PatchSet {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let diff = self.files.iter().map(|f| f.to_string()).collect::<Vec<String>>().join("\n");
        write!(f, "{}", diff)
    }
}

impl IntoIterator for PatchSet {
    type Item = PatchedFile;
    type IntoIter = ::std::vec::IntoIter<PatchedFile>;

    fn into_iter(self) -> Self::IntoIter {
        self.files.into_iter()
    }
}

impl Index<usize> for PatchSet {
    type Output = PatchedFile;

    fn index(&self, idx: usize) -> &PatchedFile {
        &self.files[idx]
    }
}

impl IndexMut<usize> for PatchSet {
    fn index_mut(&mut self, index: usize) -> &mut PatchedFile {
        &mut self.files[index]
    }
}