gemlab 2.0.0

use super::{Cell, Mesh, Point, PointId};
use crate::shapes::GeoKind;
use crate::StrError;
use std::ffi::OsStr;
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::path::Path;

struct DataForReadTextMesh {
    ndim: usize,
    npoint: usize,
    ncell: usize,
    nmarked_edge: usize,
    nmarked_face: usize,
    current_npoint: usize,
    current_ncell: usize,
    current_marked_edge: usize,
    current_marked_face: usize,
}

impl DataForReadTextMesh {
    fn new() -> Self {
        DataForReadTextMesh {
            ndim: 0,
            npoint: 0,
            ncell: 0,
            nmarked_edge: 0,
            nmarked_face: 0,
            current_npoint: 0,
            current_ncell: 0,
            current_marked_edge: 0,
            current_marked_face: 0,
        }
    }

    fn parse_sizes(&mut self, line: &str) -> Result<bool, StrError> {
        let maybe_data = line.trim_start().trim_end_matches("\n");
        if maybe_data.starts_with("#") || maybe_data == "" {
            return Ok(false); // ignore comments or empty lines; returns false == not parsed
        }

        let mut data = maybe_data.split_whitespace();

        self.ndim = data
            .next()
            .unwrap() // must panic because no error expected here
            .parse()
            .map_err(|_| "cannot parse ndim")?;

        self.npoint = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse npoint")?,
            None => return Err("cannot read npoint"),
        };

        self.ncell = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse ncell")?,
            None => return Err("cannot read ncell"),
        };

        self.nmarked_edge = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse nmarked_edge")?,
            None => return Err("cannot read nmarked_edge"),
        };

        self.nmarked_face = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse nmarked_face")?,
            None => return Err("cannot read nmarked_face"),
        };

        Ok(true) // returns true == parsed
    }

    fn parse_point(&mut self, mesh: &mut Mesh, line: &str) -> Result<bool, StrError> {
        let maybe_data = line.trim_start().trim_end_matches("\n");
        if maybe_data.starts_with("#") || maybe_data == "" {
            return Ok(false); // ignore comments or empty lines
        }

        let mut data = maybe_data.split_whitespace();

        let id: usize = data
            .next()
            .unwrap() // must panic because no error expected here
            .parse()
            .map_err(|_| "cannot parse point id")?;

        if id != self.current_npoint {
            return Err("the id and index of points must equal each other");
        }

        let marker = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse point marker")?,
            None => return Err("cannot read point marker"),
        };

        let mut coords = vec![0.0; self.ndim];

        coords[0] = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse point x coordinate")?,
            None => return Err("cannot read point x coordinate"),
        };

        coords[1] = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse point y coordinate")?,
            None => return Err("cannot read point y coordinate"),
        };

        if self.ndim == 3 {
            coords[2] = match data.next() {
                Some(v) => v.parse().map_err(|_| "cannot parse point z coordinate")?,
                None => return Err("cannot read point z coordinate"),
            };
        }

        if data.next() != None {
            return Err("point data contains extra values");
        }

        mesh.points.push(Point { id, marker, coords });

        self.current_npoint += 1; // next point

        Ok(true) // returns true == parsed
    }

    fn parse_cell(&mut self, mesh: &mut Mesh, line: &str) -> Result<bool, StrError> {
        let maybe_data = line.trim_start().trim_end_matches("\n");
        if maybe_data.starts_with("#") || maybe_data == "" {
            return Ok(false); // ignore comments or empty lines
        }

        let mut data = maybe_data.split_whitespace();

        let id: usize = data
            .next()
            .unwrap() // must panic because no error expected here
            .parse()
            .map_err(|_| "cannot parse cell id")?;

        if id != self.current_ncell {
            return Err("the id and index of cells must equal each other");
        }

        let marker: i32 = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse cell marker")?,
            None => return Err("cannot read cell marker"),
        };

        let str_kind = match data.next() {
            Some(v) => v,
            None => return Err("cannot read cell kind"),
        };

        let kind = GeoKind::from(&str_kind)?;
        let mut points: Vec<PointId> = vec![0; kind.nnode()];

        for m in 0..kind.nnode() {
            match data.next() {
                Some(v) => {
                    let point_id: usize = v.parse().map_err(|_| "cannot parse cell point id")?;
                    points[m] = point_id;
                }
                None => return Err("cannot read cell point id"),
            }
        }

        if data.next() != None {
            return Err("cell data contains extra values");
        }

        mesh.cells.push(Cell {
            id,
            marker,
            kind,
            points,
        });

        self.current_ncell += 1; // next cell

        Ok(true) // returns true == parsed
    }

    fn parse_marked_edge(&mut self, mesh: &mut Mesh, line: &str) -> Result<bool, StrError> {
        let maybe_data = line.trim_start().trim_end_matches("\n");
        if maybe_data.starts_with("#") || maybe_data == "" {
            return Ok(false); // ignore comments or empty lines
        }

        let mut data = maybe_data.split_whitespace();

        let marker: i32 = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse marked edge")?,
            None => unreachable!("at least one value expected at this point"),
        };

        let p1: usize = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse p1 of marked edge")?,
            None => return Err("cannot read p1 of marked edge"),
        };

        let p2: usize = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse p2 of marked edge")?,
            None => return Err("cannot read p2 of marked edge"),
        };

        if data.next() != None {
            return Err("marked edge data contains extra values");
        }

        mesh.marked_edges.push((marker, p1, p2));

        self.current_marked_edge += 1; // next marked edge

        Ok(true) // returns true == parsed
    }

    fn parse_marked_face(&mut self, mesh: &mut Mesh, line: &str) -> Result<bool, StrError> {
        let maybe_data = line.trim_start().trim_end_matches("\n");
        if maybe_data.starts_with("#") || maybe_data == "" {
            return Ok(false); // ignore comments or empty lines
        }

        let mut data = maybe_data.split_whitespace();

        let marker: i32 = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse marked face")?,
            None => unreachable!("at least one value expected at this point"),
        };

        let p1: usize = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse p1 of marked face")?,
            None => return Err("cannot read p1 of marked face"),
        };

        let p2: usize = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse p2 of marked face")?,
            None => return Err("cannot read p2 of marked face"),
        };

        let p3: usize = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse p3 of marked face")?,
            None => return Err("cannot read p3 of marked face"),
        };

        let p4: usize = match data.next() {
            Some(v) => v.parse().map_err(|_| "cannot parse p4 of marked face")?,
            None => usize::MAX,
        };

        mesh.marked_faces.push((marker, p1, p2, p3, p4));

        self.current_marked_face += 1; // next marked face

        Ok(true) // returns true == parsed
    }
}

impl Mesh {
    /// Allocates a new Mesh by reading raw mesh data from a text file
    ///
    /// # File format
    ///
    /// The text file format includes three sections:
    ///
    /// 1. The header with the space dimension (`ndim`), number of points (`npoint`), and number of cells (`ncell`);
    /// 2. The points list where each line contains the `id` of the point, which must be **equal to the position** in the list,
    ///    followed by the `x` and `y` (and `z`) coordinates;
    /// 3. The cells list where each line contains the `id` of the cell, which must be **equal to the position** in the list,
    ///    the `marker` of the cell, the `kind` of the cell, followed by the IDs of the points that define the cell (connectivity).
    ///
    /// The text file looks like this (the `#` character indicates a comment):
    ///
    /// ```text
    /// # header
    /// # ndim npoint ncell nmarked_edge nmarked_face
    ///      3      8     5            3            2
    ///
    /// # points
    /// # id marker x y {z}
    ///    0 0 0.0 0.0 0.0
    ///    1 0 0.5 0.0 0.0
    ///    2 0 1.0 0.0 0.0
    /// # ... more points should follow
    ///
    /// # cells
    /// # id marker kind points
    ///    0 1 tri3 0 1 3
    ///    1 1 qua4 1 4 6 3
    ///    2 2 tet4 0 3 7 2
    /// # ... more cells should follow
    ///
    /// # marked edges
    /// # marker p1 p2
    /// -100 0 1
    /// -100 9 8
    /// -200 8 3
    ///
    /// # marked faces
    /// # marker p1 p2 p3 {p4}
    /// -10 4 7 4
    /// -10 1 2 3
    /// ```
    ///
    /// where we can see that different cell (shape) kinds can be present in the same mesh.
    /// However, this function does not check for element compatibility as required by finite element analyses.
    ///
    /// See [GeoKind::from] for the keys used to identify the cell kind (the keys are **lowercase**).
    ///
    /// # Input
    ///
    /// * `full_path` -- may be a String, &str, or Path
    pub fn read<P>(full_path: &P) -> Result<Self, StrError>
    where
        P: AsRef<OsStr> + ?Sized,
    {
        let path = Path::new(full_path).to_path_buf();
        let input = File::open(path).map_err(|_| "cannot open file")?;
        let buffered = BufReader::new(input);
        let mut lines_iter = buffered.lines();

        // auxiliary data structure
        let mut data = DataForReadTextMesh::new();

        // read and parse sizes
        loop {
            match lines_iter.next() {
                Some(v) => {
                    let line = v.unwrap(); // must panic because no error expected here
                    if data.parse_sizes(&line)? {
                        break;
                    }
                }
                None => return Err("file is empty or header is missing"),
            }
        }

        // allocate mesh
        let mut mesh = Mesh {
            ndim: data.ndim,
            points: Vec::new(),
            cells: Vec::new(),
            marked_edges: Vec::new(),
            marked_faces: Vec::new(),
        };

        // read and parse points
        loop {
            match lines_iter.next() {
                Some(v) => {
                    let line = v.unwrap(); // must panic because no error expected here
                    if data.parse_point(&mut mesh, &line)? {
                        if data.current_npoint == data.npoint {
                            break;
                        }
                    }
                }
                None => break,
            }
        }

        // check data
        if data.current_npoint != data.npoint {
            return Err("not all points have been found");
        }

        // read and parse cells
        loop {
            match lines_iter.next() {
                Some(v) => {
                    let line = v.unwrap(); // must panic because no error expected here
                    if data.parse_cell(&mut mesh, &line)? {
                        if data.current_ncell == data.ncell {
                            break;
                        }
                    }
                }
                None => break,
            }
        }

        // check data
        if data.current_ncell != data.ncell {
            return Err("not all cells have been found");
        }

        // read and parse marked edges
        if data.nmarked_edge > 0 {
            loop {
                match lines_iter.next() {
                    Some(v) => {
                        let line = v.unwrap(); // must panic because no error expected here
                        if data.parse_marked_edge(&mut mesh, &line)? {
                            if data.current_marked_edge == data.nmarked_edge {
                                break;
                            }
                        }
                    }
                    None => break,
                }
            }
            if data.current_marked_edge != data.nmarked_edge {
                return Err("not all marked edges have been found");
            }
        }

        // read and parse marked faces
        if data.nmarked_face > 0 {
            loop {
                match lines_iter.next() {
                    Some(v) => {
                        let line = v.unwrap(); // must panic because no error expected here
                        if data.parse_marked_face(&mut mesh, &line)? {
                            if data.current_marked_face == data.nmarked_face {
                                break;
                            }
                        }
                    }
                    None => break,
                }
            }
            if data.current_marked_face != data.nmarked_face {
                return Err("not all marked faces have been found");
            }
        }

        // done
        Ok(mesh)
    }

    /// Allocates a new Mesh by parsing raw mesh data from a text string
    ///
    /// # Text format
    ///
    /// The text includes three sections:
    ///
    /// 1. The header with the space dimension (`ndim`), number of points (`npoint`), and number of cells (`ncell`);
    /// 2. The points list where each line contains the `id` of the point, which must be **equal to the position** in the list,
    ///    followed by the `x` and `y` (and `z`) coordinates;
    /// 3. The cells list where each line contains the `id` of the cell, which must be **equal to the position** in the list,
    ///    the `marker` of the cell, the `kind` of the cell, followed by the IDs of the points that define the cell (connectivity).
    ///
    /// The text looks like this (the `#` character indicates a comment):
    ///
    /// ```text
    /// # header
    /// # ndim npoint ncell nmarked_edge nmarked_face
    ///      3      8     5            3            2
    ///
    /// # points
    /// # id marker x y {z}
    ///    0 0 0.0 0.0 0.0
    ///    1 0 0.5 0.0 0.0
    ///    2 0 1.0 0.0 0.0
    /// # ... more points should follow
    ///
    /// # cells
    /// # id marker kind points
    ///    0 1 tri3 0 1 3
    ///    1 1 qua4 1 4 6 3
    ///    2 2 tet4 0 3 7 2
    /// # ... more cells should follow
    ///
    /// # marked edges
    /// # marker p1 p2
    /// -100 0 1
    /// -100 9 8
    /// -200 8 3
    ///
    /// # marked faces
    /// # marker p1 p2 p3 {p4}
    /// -10 4 7 4
    /// -10 1 2 3
    /// ```
    ///
    /// where we can see that different cell (shape) kinds can be present in the same mesh.
    /// However, this function does not check for element compatibility as required by finite element analyses.
    ///
    /// See [GeoKind::from] for the keys used to identify the cell kind (the keys are **lowercase**).
    ///
    /// # Examples
    ///
    /// See `examples` and `data/meshes` directories for more examples
    /// (with pretty formatted strings).
    ///
    /// ```
    /// use gemlab::mesh::Mesh;
    /// use gemlab::StrError;
    ///
    /// fn main() -> Result<(), StrError> {
    ///     // 1.0  3-------2
    ///     //      |`. [1] |
    ///     //      |  `.   |
    ///     //      | [0]`. |
    ///     // 0.0  0------`1
    ///     //     0.0     1.0
    ///     let mesh = Mesh::from_text(
    ///         "2 4 2 0 0\n# points\n0 0 0.0 0.0\n1 0 1.0 0.0\n2 0 1.0 1.0\n3 0 0.0 1.0\n# cells\n0 1 tri3  0 1 3\n1 1 tri3  2 3 1\n",
    ///     )?;
    ///     assert_eq!(mesh.points.len(), 4);
    ///     assert_eq!(mesh.cells.len(), 2);
    ///     assert_eq!(mesh.cells[0].points, &[0, 1, 3]);
    ///     assert_eq!(mesh.cells[1].points, &[2, 3, 1]);
    ///     Ok(())
    /// }
    /// ```
    pub fn from_text(text: &str) -> Result<Self, StrError> {
        // auxiliary data structure
        let mut data = DataForReadTextMesh::new();

        // read and parse sizes
        let mut lines_iter = text.lines();
        loop {
            match lines_iter.next() {
                Some(line) => {
                    if data.parse_sizes(line)? {
                        break;
                    }
                }
                None => return Err("text string is empty or header is missing"),
            }
        }

        // allocate mesh
        let mut mesh = Mesh {
            ndim: data.ndim,
            points: Vec::new(),
            cells: Vec::new(),
            marked_edges: Vec::new(),
            marked_faces: Vec::new(),
        };

        // read and parse points
        loop {
            match lines_iter.next() {
                Some(line) => {
                    if data.parse_point(&mut mesh, line)? {
                        if data.current_npoint == data.npoint {
                            break;
                        }
                    }
                }
                None => break,
            }
        }

        // check data
        if data.current_npoint != data.npoint {
            return Err("not all points have been found");
        }

        // read and parse cells
        loop {
            match lines_iter.next() {
                Some(line) => {
                    if data.parse_cell(&mut mesh, line)? {
                        if data.current_ncell == data.ncell {
                            break;
                        }
                    }
                }
                None => break,
            }
        }

        // check data
        if data.current_ncell != data.ncell {
            return Err("not all cells have been found");
        }

        // read and parse marked edges
        if data.nmarked_edge > 0 {
            loop {
                match lines_iter.next() {
                    Some(line) => {
                        if data.parse_marked_edge(&mut mesh, &line)? {
                            if data.current_marked_edge == data.nmarked_edge {
                                break;
                            }
                        }
                    }
                    None => break,
                }
            }
            if data.current_marked_edge != data.nmarked_edge {
                return Err("not all marked edges have been found");
            }
        }

        // read and parse marked faces
        if data.nmarked_face > 0 {
            loop {
                match lines_iter.next() {
                    Some(line) => {
                        if data.parse_marked_face(&mut mesh, &line)? {
                            if data.current_marked_face == data.nmarked_face {
                                break;
                            }
                        }
                    }
                    None => break,
                }
            }
            if data.current_marked_face != data.nmarked_face {
                return Err("not all marked faces have been found");
            }
        }

        // done
        Ok(mesh)
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#[cfg(test)]
mod tests {
    use super::DataForReadTextMesh;
    use crate::mesh::{Mesh, Samples};

    #[test]
    fn parse_sizes_captures_errors() {
        let mut data = DataForReadTextMesh::new();

        assert_eq!(
            data.parse_sizes(&String::from(" wrong \n")).err(),
            Some("cannot parse ndim")
        );

        assert_eq!(
            data.parse_sizes(&String::from(" 2 \n")).err(),
            Some("cannot read npoint")
        );
        assert_eq!(
            data.parse_sizes(&String::from(" 1 wrong")).err(),
            Some("cannot parse npoint")
        );

        assert_eq!(
            data.parse_sizes(&String::from(" 2 4   \n")).err(),
            Some("cannot read ncell")
        );
        assert_eq!(
            data.parse_sizes(&String::from(" 2 4  wrong")).err(),
            Some("cannot parse ncell")
        );
        assert_eq!(
            data.parse_sizes(&String::from(" 2 4 3 wrong")).err(),
            Some("cannot parse nmarked_edge")
        );
        assert_eq!(
            data.parse_sizes(&String::from(" 2 4 3 5 wrong")).err(),
            Some("cannot parse nmarked_face")
        );
    }

    #[test]
    fn parse_point_captures_errors() {
        let mut data = DataForReadTextMesh::new();
        data.ndim = 3;
        data.npoint = 2;
        data.ncell = 1;

        let mut mesh = Mesh {
            ndim: data.ndim,
            points: Vec::new(),
            cells: Vec::new(),
            marked_edges: Vec::new(),
            marked_faces: Vec::new(),
        };

        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" wrong \n")).err(),
            Some("cannot parse point id")
        );

        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" 2 0.0 0.0 0.0 \n")).err(),
            Some("the id and index of points must equal each other")
        );

        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" 0    \n")).err(),
            Some("cannot read point marker")
        );
        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" 0 wrong   \n")).err(),
            Some("cannot parse point marker")
        );

        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" 0 0    \n")).err(),
            Some("cannot read point x coordinate")
        );
        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" 0 0   wrong")).err(),
            Some("cannot parse point x coordinate")
        );

        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" 0 0  0.0  \n")).err(),
            Some("cannot read point y coordinate")
        );
        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" 0 0  0.0 wrong")).err(),
            Some("cannot parse point y coordinate")
        );

        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" 0 0  0.0 0.0 \n")).err(),
            Some("cannot read point z coordinate")
        );
        assert_eq!(
            data.parse_point(&mut mesh, &String::from(" 0 0  0.0 0.0 wrong")).err(),
            Some("cannot parse point z coordinate")
        );
    }

    #[test]
    fn parse_cell_captures_errors() {
        let mut data = DataForReadTextMesh::new();
        data.ndim = 3;
        data.npoint = 2;
        data.ncell = 1;

        let mut mesh = Mesh {
            ndim: data.ndim,
            points: Vec::new(),
            cells: Vec::new(),
            marked_edges: Vec::new(),
            marked_faces: Vec::new(),
        };

        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" wrong \n")).err(),
            Some("cannot parse cell id")
        );

        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" 2 1 0.0 0.0 0.0 \n")).err(),
            Some("the id and index of cells must equal each other")
        );

        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" 0 \n")).err(),
            Some("cannot read cell marker")
        );
        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" 0 wrong")).err(),
            Some("cannot parse cell marker")
        );

        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" 0 1 ")).err(),
            Some("cannot read cell kind")
        );
        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" 0 1  wrong")).err(),
            Some("string representation of GeoKind is incorrect")
        );
        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" 0 1 Lin2")).err(), // must be lowercase
            Some("string representation of GeoKind is incorrect")
        );

        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" 0 1  tri3  ")).err(),
            Some("cannot read cell point id")
        );
        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" 0 1  tri3  0 1 wrong")).err(),
            Some("cannot parse cell point id")
        );

        assert_eq!(
            data.parse_cell(&mut mesh, &String::from(" 0 1  tri3  0 1 2  extra"))
                .err(),
            Some("cell data contains extra values")
        );
    }

    #[test]
    fn parse_edge_marker_captures_errors() {
        let mut data = DataForReadTextMesh::new();
        data.ndim = 2;
        data.npoint = 2;
        data.ncell = 1;

        let mut mesh = Mesh {
            ndim: data.ndim,
            points: Vec::new(),
            cells: Vec::new(),
            marked_edges: Vec::new(),
            marked_faces: Vec::new(),
        };

        assert_eq!(
            data.parse_marked_edge(&mut mesh, &String::from(" wrong \n")).err(),
            Some("cannot parse marked edge")
        );

        assert_eq!(
            data.parse_marked_edge(&mut mesh, &String::from(" -10 wrong \n")).err(),
            Some("cannot parse p1 of marked edge")
        );

        assert_eq!(
            data.parse_marked_edge(&mut mesh, &String::from(" -10 \n")).err(),
            Some("cannot read p1 of marked edge")
        );

        assert_eq!(
            data.parse_marked_edge(&mut mesh, &String::from(" -10 1 wrong \n"))
                .err(),
            Some("cannot parse p2 of marked edge")
        );

        assert_eq!(
            data.parse_marked_edge(&mut mesh, &String::from(" -10 1 \n")).err(),
            Some("cannot read p2 of marked edge")
        );

        assert_eq!(
            data.parse_marked_edge(&mut mesh, &String::from(" -10 1 2 extra \n"))
                .err(),
            Some("marked edge data contains extra values")
        );
    }

    #[test]
    fn parse_face_marker_captures_errors() {
        let mut data = DataForReadTextMesh::new();
        data.ndim = 3;
        data.npoint = 2;
        data.ncell = 1;

        let mut mesh = Mesh {
            ndim: data.ndim,
            points: Vec::new(),
            cells: Vec::new(),
            marked_edges: Vec::new(),
            marked_faces: Vec::new(),
        };

        assert_eq!(
            data.parse_marked_face(&mut mesh, &String::from(" wrong \n")).err(),
            Some("cannot parse marked face")
        );

        assert_eq!(
            data.parse_marked_face(&mut mesh, &String::from(" -10 wrong \n")).err(),
            Some("cannot parse p1 of marked face")
        );

        assert_eq!(
            data.parse_marked_face(&mut mesh, &String::from(" -10 \n")).err(),
            Some("cannot read p1 of marked face")
        );

        assert_eq!(
            data.parse_marked_face(&mut mesh, &String::from(" -10 1 wrong \n"))
                .err(),
            Some("cannot parse p2 of marked face")
        );

        assert_eq!(
            data.parse_marked_face(&mut mesh, &String::from(" -10 1 \n")).err(),
            Some("cannot read p2 of marked face")
        );

        assert_eq!(
            data.parse_marked_face(&mut mesh, &String::from(" -10 1 2 wrong \n"))
                .err(),
            Some("cannot parse p3 of marked face")
        );

        assert_eq!(
            data.parse_marked_face(&mut mesh, &String::from(" -10 1 3 \n")).err(),
            Some("cannot read p3 of marked face")
        );

        assert_eq!(
            data.parse_marked_face(&mut mesh, &String::from(" -10 1 2 3 wrong \n"))
                .err(),
            Some("cannot parse p4 of marked face")
        );
    }

    #[test]
    fn read_captures_errors() {
        assert_eq!(Mesh::read(&String::from("__wrong__")).err(), Some("cannot open file"));
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_empty.msh")).err(),
            Some("file is empty or header is missing")
        );
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_extra_cell_data.msh")).err(),
            Some("cell data contains extra values")
        );
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_extra_point_data.msh")).err(),
            Some("point data contains extra values")
        );
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_missing_header.msh")).err(),
            Some("file is empty or header is missing")
        );
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_missing_points.msh")).err(),
            Some("not all points have been found")
        );
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_missing_cells.msh")).err(),
            Some("not all cells have been found")
        );
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_missing_marked_edges.msh")).err(),
            Some("not all marked edges have been found")
        );
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_missing_marked_faces.msh")).err(),
            Some("not all marked faces have been found")
        );
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_missing_marked_faces2.msh")).err(),
            Some("not all marked faces have been found")
        );
        assert_eq!(
            Mesh::read(&String::from("./data/meshes/bad_wrong_cell_kind.msh")).err(),
            Some("string representation of GeoKind is incorrect")
        );
    }

    #[test]
    fn read_works() {
        let mesh = Mesh::read("./data/meshes/two_quads_horizontal.msh").unwrap();
        let sample = Samples::two_qua4();
        assert_eq!(format!("{:?}", mesh), format!("{:?}", sample));

        let mesh = Mesh::read("./data/meshes/two_cubes_vertical.msh").unwrap();
        let sample = Samples::two_hex8();
        assert_eq!(format!("{:?}", mesh), format!("{:?}", sample));

        let mesh = Mesh::read("./data/meshes/four_hex8.msh").unwrap();
        let sample = Samples::four_hex8();
        assert_eq!(format!("{:?}", mesh), format!("{:?}", sample));

        let mesh = Mesh::read("./data/meshes/mixed_shapes_2d.msh").unwrap();
        let sample = Samples::mixed_shapes_2d();
        assert_eq!(format!("{:?}", mesh), format!("{:?}", sample));

        let mesh = Mesh::read("./data/meshes/mixed_shapes_3d.msh").unwrap();
        let sample = Samples::mixed_shapes_3d();
        assert_eq!(format!("{:?}", mesh), format!("{:?}", sample));
    }

    #[test]
    fn from_text_captures_errors() {
        assert_eq!(
            Mesh::from_text(
                "# header\n\
                 # ndim npoint ncell nmarked_edge nmarked_face\n"
            )
            .err(),
            Some("text string is empty or header is missing")
        );

        assert_eq!(
            Mesh::from_text(
                "# header\n\
                 # ndim npoint ncell nmarked_edge nmarked_face\n\
                      2      4     1            0            0\n\
                 \n\
                 # points\n\
                 # id marker x y\n\
                    0 0 0.0 0.0\n"
            )
            .err(),
            Some("not all points have been found")
        );

        assert_eq!(
            Mesh::from_text(
                "# header\n\
                 # ndim npoint ncell nmarked_edge nmarked_face\n\
                      2      6     2            0            0\n\
                 \n\
                 # points\n\
                 # id marker x y\n\
                    0 0 0.0 0.0\n\
                    1 0 1.0 0.0\n\
                    2 0 1.0 1.0\n\
                    3 0 0.0 1.0\n\
                    4 0 2.0 0.0\n\
                    5 0 2.0 1.0\n\
                 \n\
                 # cells\n\
                 # id marker kind points\n\
                    0   1 qua4  0 1 2 3\n"
            )
            .err(),
            Some("not all cells have been found")
        );

        assert_eq!(
            Mesh::from_text(
                "# header\n\
                 # ndim npoint ncell nmarked_edge nmarked_face\n\
                      2      4     1            0            0\n\
                 # points\n\
                 # id marker x y wrong\n\
                    0 0 0.0 0.0  1\n\
                    1 0 1.0 0.0  1\n\
                    2 0 1.0 1.0  1\n\
                    3 0 0.0 1.0  1\n\
                 # cells\n\
                 # id marker kind points\n\
                    0   1 qua4  0 1 2 3\n"
            )
            .err(),
            Some("point data contains extra values")
        );

        assert_eq!(
            Mesh::from_text(
                "# header\n\
                 # ndim npoint ncell nmarked_edge nmarked_face\n\
                      2      4     1            0            0\n\
                 # points\n\
                 # id marker x y\n\
                    0 0 0.0 0.0\n\
                    1 0 1.0 0.0\n\
                    2 0 1.0 1.0\n\
                    3 0 0.0 1.0\n\
                 # cells\n\
                 # id marker kind  point_ids + wrong...\n\
                    0   1 qua4  0 1 2 3       4\n"
            )
            .err(),
            Some("cell data contains extra values")
        );

        assert_eq!(
            Mesh::from_text(
                "# header\n\
                 # ndim npoint ncell nmarked_edge nmarked_face\n\
                      2      4     1            0            0\n\
                 # points\n\
                 # id marker x y\n\
                    0 0 0.0 0.0\n\
                    1 0 1.0 0.0\n\
                    2 0 1.0 1.0\n\
                    3 0 0.0 1.0\n\
                 # cells\n\
                 # id marker kind points\n\
                    0   1 Qua4  0 1 2 3     \n"
            )
            .err(),
            Some("string representation of GeoKind is incorrect")
        );
    }

    #[test]
    fn from_text_works() {
        let mesh = Mesh::from_text(
            r"# header
              # ndim npoint ncell nmarked_edge nmarked_face
                  2      6     3            0            0

              # points
              # id marker x y
              0 0 0.0 0.0
              1 0 1.0 0.0
              2 0 2.0 0.0
              3 0 2.0 1.0
              4 0 1.0 1.0
              5 0 3.0 0.0

              # cells
              # id marker kind points
              0 1 lin2 0 1
              1 2 qua4 1 2 3 4
              2 1 lin2 2 5",
        )
        .unwrap();
        let sample = Samples::mixed_shapes_2d();
        assert_eq!(format!("{:?}", mesh), format!("{:?}", sample));

        let mesh = Mesh::from_text(
            r"# header
            # ndim npoint ncell nmarked_edge nmarked_face
                 2      6     2            6            0
            
            # points
            # id marker x y
               0 -1 0.0 0.0
               1 -2 1.0 0.0
               2 -3 1.0 1.0
               3 -4 0.0 1.0
               4 -5 2.0 0.0
               5 -6 2.0 1.0
            
            # cells
            # id marker kind points
               0   1 qua4  0 1 2 3
               1   2 qua4  1 4 5 2
               
            # marked edges
            # marker p1 p2
            -100 3 2
            -200 2 5
            -300 5 4
            -300 3 0
            -400 0 1
            -400 1 4",
        )
        .unwrap();
        let sample = Samples::two_qua4();
        assert_eq!(format!("{:?}", mesh), format!("{:?}", sample));

        let mesh = Mesh::from_text(
            r"# header
            # ndim npoint ncell nmarked_edge nmarked_face
                 3     12     2            4            4
            
            # points
            # id marker x y z
               0  0 0.0 0.0 0.0
               1 -1 1.0 0.0 0.0
               2 -1 1.0 1.0 0.0
               3  0 0.0 1.0 0.0
               4  0 0.0 0.0 1.0
               5  0 1.0 0.0 1.0
               6  0 1.0 1.0 1.0
               7 -1 0.0 1.0 1.0
               8  0 0.0 0.0 2.0
               9  0 1.0 0.0 2.0
              10  0 1.0 1.0 2.0
              11  0 0.0 1.0 2.0
            
            # cells
            # id marker kind points
               0   1 hex8  0 1 2 3 4 5  6  7
               1   2 hex8  4 5 6 7 8 9 10 11
               
            # marked edges
            # marker p1 p2
            123 7 11
            -5 11 10
            -4 7 3
            -5 8 9

            # marked faces
            # marker p1 p2 p3 {p4}
            -8 3 2 7 6
            -9 8 10 9 11
            -10 1 2 5 6
            -11 0 1 4 5",
        )
        .unwrap();
        let sample = Samples::two_hex8();
        assert_eq!(format!("{:?}", mesh), format!("{:?}", sample));
    }

    #[test]
    fn read_works_with_data_from_tritet_tri() {
        let mesh = Mesh::read("data/meshes/test_tri_write_msh_file_works.msh").unwrap();
        let correct = "# header\n\
                       # ndim npoint ncell nmarked_edge nmarked_face\n\
                       2 5 4 4 0\n\
                       \n\
                       # points\n\
                       # id marker x y {z}\n\
                       0 -1 0.0 0.0\n\
                       1 -2 1.0 0.0\n\
                       2 -3 1.0 1.0\n\
                       3 -4 0.0 1.0\n\
                       4 0 0.5 0.5\n\
                       \n\
                       # cells\n\
                       # id marker kind points\n\
                       0 1 tri3 1 2 4\n\
                       1 1 tri3 3 0 4\n\
                       2 1 tri3 4 2 3\n\
                       3 1 tri3 0 1 4\n\
                       \n\
                       # marked edges\n\
                       # marker p1 p2\n\
                       -10 1 0\n\
                       -20 2 1\n\
                       -30 3 2\n\
                       -40 0 3\n\
                       ";
        assert_eq!(format!("{}", mesh), correct);
    }

    #[test]
    fn read_works_with_data_from_tritet_tet() {
        let mesh = Mesh::read("data/meshes/test_tet_write_msh_file_works.msh").unwrap();
        let correct = "# header\n\
                       # ndim npoint ncell nmarked_edge nmarked_face\n\
                       3 8 6 0 12\n\
                       \n\
                       # points\n\
                       # id marker x y {z}\n\
                       0 -1 0.0 0.0 0.0\n\
                       1 -2 1.0 0.0 0.0\n\
                       2 -3 1.0 1.0 0.0\n\
                       3 -4 0.0 1.0 0.0\n\
                       4 -5 0.0 0.0 1.0\n\
                       5 -6 1.0 0.0 1.0\n\
                       6 -7 1.0 1.0 1.0\n\
                       7 -8 0.0 1.0 1.0\n\
                       \n\
                       # cells\n\
                       # id marker kind points\n\
                       0 1 tet4 0 3 7 2\n\
                       1 1 tet4 0 7 4 6\n\
                       2 1 tet4 5 0 4 6\n\
                       3 1 tet4 0 7 6 2\n\
                       4 1 tet4 5 0 6 1\n\
                       5 1 tet4 6 0 2 1\n\
                       \n\
                       # marked faces\n\
                       # marker p1 p2 p3 {p4}\n\
                       20 2 7 3\n\
                       -30 3 0 2\n\
                       -10 3 7 0\n\
                       30 6 4 7\n\
                       -10 7 4 0\n\
                       30 6 5 4\n\
                       -20 0 4 5\n\
                       20 2 6 7\n\
                       10 1 5 6\n\
                       -20 0 5 1\n\
                       -30 1 2 0\n\
                       10 1 6 2\n\
                       ";
        assert_eq!(format!("{}", mesh), correct);
    }
}