mod token;

pub use token::{EndLine, PlantUmlLine, PlantUmlLineKind, StartLine};

use crate::Error;
use nom::IResult;
use nom::{
    error::{Error as NomError, ErrorKind as NomErrorKind},
    Err as NomErr,
};
use std::fs::read_to_string;
use std::path::PathBuf;

pub struct PlantUmlFile<'a> {
    path: PathBuf,
    raw: String,
    data: Option<PlantUmlFileData<'a>>,
}

#[derive(Clone, Debug)]
pub struct PlantUmlFileData<'a> {
    contents: Vec<PlantUmlContent<'a>>,
}

/// `@start[a-z]*` - `@end[a-z]*`
#[derive(Clone, Debug)]
pub struct PlantUmlContent<'a> {
    lines: Vec<PlantUmlLine<'a>>,
}

impl<'a> PlantUmlFile<'a> {
    pub fn read(path: PathBuf) -> Result<Self, Error> {
        let raw = read_to_string(&path)?;

        Ok(Self {
            path,
            raw,
            data: None,
        })
    }

    pub fn path(&self) -> &PathBuf {
        &self.path
    }

    pub fn parse(&'a mut self) -> Result<&'a PlantUmlFileData<'a>, Error> {
        let data = PlantUmlFileData::parse(self.raw.as_str())?;
        self.data = Some(data);
        Ok(self.data.as_ref().unwrap())
    }
}

impl<'a> PlantUmlFileData<'a> {
    pub fn parse(input: &'a str) -> Result<Self, Error> {
        let mut contents = vec![];
        let mut input = input;
        let (mut rest, mut line) = PlantUmlLine::parse(input).map_err(|e| e.to_owned())?;

        'outer: while !rest.is_empty() {
            while line.empty().is_some() {
                (rest, line) = PlantUmlLine::parse(input).map_err(|e| e.to_owned())?;
                if line.empty().is_none() {
                    break;
                }
                if rest.is_empty() {
                    break 'outer;
                }
                input = rest;
            }

            let (tmp_rest, content) = PlantUmlContent::parse(input).map_err(|e| e.to_owned())?;
            input = tmp_rest;
            contents.push(content);
            if input.is_empty() {
                break;
            }
            (rest, line) = PlantUmlLine::parse(input).map_err(|e| e.to_owned())?;
        }

        Ok(Self { contents })
    }

    pub fn get(&'a self, index: usize) -> Option<&'a PlantUmlContent<'a>> {
        self.contents.get(index)
    }

    pub fn get_by_id(&'a self, id: &str) -> Option<&'a PlantUmlContent<'a>> {
        self.contents.iter().find(|x| x.id() == Some(id))
    }

    pub fn iter(&'a self) -> std::slice::Iter<'_, PlantUmlContent<'a>> {
        self.contents.iter()
    }
}

impl<'a> PlantUmlContent<'a> {
    /// parse a range (`@start[a-z]*` - `@end[a-z]*`)
    fn parse(input: &'a str) -> IResult<&'a str, Self> {
        let mut lines = vec![];
        let (mut rest, mut line) = PlantUmlLine::parse(input)?;
        if line.start().is_none() {
            StartLine::parse(input)?;
            // unreachable
            return Err(NomErr::Failure(NomError::new(input, NomErrorKind::Fail)));
        }
        let line2 = line.clone();
        let diagram_kind = line2.diagram_kind().unwrap();
        lines.push(line.clone());

        while line.end().is_none() {
            let (tmp_rest, tmp_line) = PlantUmlLine::parse(rest)?;
            (rest, line) = (tmp_rest, tmp_line);
            if line.end().map(|x| x.eq_diagram_kind(diagram_kind)) == Some(false) {
                return Err(NomErr::Failure(NomError::new(input, NomErrorKind::Fail)));
            }

            lines.push(line.clone());
        }

        Ok((rest, Self { lines }))
    }

    pub fn id(&'a self) -> Option<&'a str> {
        self.lines[0].start().unwrap().id()
    }

    pub fn construct(&self) -> String {
        self.lines[0..self.lines.len()]
            .iter()
            .map(|x| x.raw())
            .collect::<Vec<_>>()
            .join("")
    }

    pub fn inner(&self) -> String {
        self.lines[1..self.lines.len() - 1]
            .iter()
            .map(|x| x.raw())
            .collect::<Vec<_>>()
            .join("")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_plant_uml_file_data() -> anyhow::Result<()> {
        // OK
        let testdata = r#"@startuml
        @enduml

        @startuml a
            a -> b
        @enduml


        @startuml(id=b)
            b -> a
        @enduml

        "#;
        let parsed = PlantUmlFileData::parse(testdata)?;
        assert_eq!(parsed.contents.len(), 3);

        let content_0 = parsed.get(0).unwrap();
        assert!(content_0.id().is_none());

        let content_1 = parsed.get(1).unwrap();
        assert_eq!(content_1.id(), Some("a"));
        assert_eq!(content_1.inner(), "            a -> b\n");

        let content_a = parsed.get_by_id("a").unwrap();
        assert_eq!(content_a.id(), Some("a"));
        assert_eq!(content_a.inner(), "            a -> b\n");

        let content_2 = parsed.get(2).unwrap();
        assert_eq!(content_2.id(), Some("b"));
        assert_eq!(content_2.inner(), "            b -> a\n");

        let content_b = parsed.get_by_id("b").unwrap();
        assert_eq!(content_b.id(), Some("b"));
        assert_eq!(content_b.inner(), "            b -> a\n");

        assert!(parsed.get(3).is_none());

        Ok(())
    }

    #[test]
    fn test_parse_plant_uml_content() -> anyhow::Result<()> {
        // OK
        let testdata = r#"@startuml
        @enduml"#;
        let (rest, parsed) = PlantUmlContent::parse(testdata)?;
        assert_eq!(rest, "");
        assert_eq!(parsed.lines.len(), 2);
        assert_eq!(parsed.inner(), "");

        // OK
        let testdata = r#"@startuml
            a -> b
        @enduml"#;
        let (rest, parsed) = PlantUmlContent::parse(testdata)?;
        assert_eq!(rest, "");
        assert_eq!(parsed.lines.len(), 3);
        assert_eq!(parsed.inner(), "            a -> b\n");

        // OK (with id)
        let testdata = r#"@startuml aaa
            a -> b
        @enduml"#;
        let (rest, parsed) = PlantUmlContent::parse(testdata)?;
        assert_eq!(rest, "");
        assert_eq!(parsed.lines.len(), 3);
        assert_eq!(parsed.inner(), "            a -> b\n");
        assert_eq!(parsed.id(), Some("aaa"));

        // OK (with id 2)
        let testdata = r#"@startuml(id=bbb)
            a -> b
        @enduml"#;
        let (rest, parsed) = PlantUmlContent::parse(testdata)?;
        assert_eq!(rest, "");
        assert_eq!(parsed.lines.len(), 3);
        assert_eq!(parsed.inner(), "            a -> b\n");
        assert_eq!(parsed.id(), Some("bbb"));

        // NG. diagram_kind not match
        let testdata = r#"@startuml
            a -> b
        @endfoo"#;
        assert!(PlantUmlContent::parse(testdata).is_err());

        Ok(())
    }
}