use femm_doc_heat::FemmDoc;

const FIXTURE: &str = r#"[Format]      =  1
[Precision]   =  1e-08
[MinAngle]    =  30
[DoSmartMesh] =  1
[Depth]       =  1
[LengthUnits] =  millimeters
[ProblemType] =  planar
[Coordinates] =  cartesian
[PrevSoln] = ""
[dT] = 0.01
[Comment]     =  "heat-flow planar slab"
[PointProps]   = 1
  <BeginPoint>
    <PointName> = "Tfix"
    <Tp> = 300
    <qp> = 0
  <EndPoint>
[BdryProps]   = 1
  <BeginBdry>
    <BdryName> = "ambient"
    <BdryType> = 2
    <Tset> = 0
    <qs>   = 0
    <beta> = 0
    <h>    = 10
    <Tinf> = 293
  <EndBdry>
[BlockProps]  = 2
  <BeginBlock>
    <BlockName> = "Air"
    <Kx> = 0.026
    <Ky> = 0.026
    <Kt> = 1006
    <qv> = 0
  <EndBlock>
  <BeginBlock>
    <BlockName> = "Copper"
    <Kx> = 401
    <Ky> = 401
    <Kt> = 385
    <qv> = 0
    <TKPoints> = 3
      250	410
      300	401
      400	390
  <EndBlock>
[ConductorProps]  = 1
  <BeginConductor>
    <ConductorName> = "Heater"
    <Tc> = 0
    <qc> = 50
    <ConductorType> = 0
  <EndConductor>
[NumPoints] = 4
0	0	1	0	1
10	0	0	0	0
10	10	0	0	0
0	10	0	0	0
[NumSegments] = 4
0	1	-1	1	0	0	0
1	2	-1	1	0	0	0
2	3	-1	1	0	0	0
3	0	-1	1	0	0	0
[NumArcSegments] = 0
[NumHoles] = 0
[NumBlockLabels] = 1
5	5	2	0.1	0	0
"#;

#[test]
fn parses_fixture_geometry() {
    let doc = FemmDoc::parse(FIXTURE).expect("parse");
    assert_eq!(doc.dt, 0.01);
    assert_eq!(doc.nodes.len(), 4);
    assert_eq!(doc.segments.len(), 4);
    assert_eq!(doc.arcs.len(), 0);
    assert_eq!(doc.block_labels.len(), 1);
    assert_eq!(doc.materials.len(), 2);
    assert_eq!(doc.boundaries.len(), 1);
    assert_eq!(doc.points.len(), 1);
    assert_eq!(doc.conductors.len(), 1);
    assert_eq!(doc.nodes[0].boundary_marker, "Tfix");
    assert_eq!(doc.nodes[0].in_conductor, "Heater");
    assert_eq!(doc.nodes[1].in_conductor, "<None>");
    assert_eq!(doc.segments[0].boundary_marker, "ambient");
    assert_eq!(doc.block_labels[0].block_type, "Copper");
    assert_eq!(doc.materials[1].name, "Copper");
    assert_eq!(doc.materials[1].tk_curve.len(), 3);
    assert_eq!(doc.materials[1].tk_curve[1], (300.0, 401.0));
    assert_eq!(doc.boundaries[0].h, 10.0);
    assert_eq!(doc.boundaries[0].tinf, 293.0);
    assert_eq!(doc.points[0].tp, 300.0);
    assert_eq!(doc.conductors[0].qc, 50.0);
}

#[test]
fn round_trips_parse_write_parse() {
    let a = FemmDoc::parse(FIXTURE).expect("parse a");
    let text = a.write();
    let b = FemmDoc::parse(&text).expect("parse b");

    assert_eq!(a.dt, b.dt);
    assert_eq!(a.precision, b.precision);
    assert_eq!(a.depth, b.depth);
    assert_eq!(a.nodes.len(), b.nodes.len());
    assert_eq!(a.segments.len(), b.segments.len());
    assert_eq!(a.materials.len(), b.materials.len());
    assert_eq!(a.conductors.len(), b.conductors.len());

    for (x, y) in a.nodes.iter().zip(b.nodes.iter()) {
        assert!((x.x - y.x).abs() < 1e-12);
        assert!((x.y - y.y).abs() < 1e-12);
        assert_eq!(x.boundary_marker, y.boundary_marker);
        assert_eq!(x.in_conductor, y.in_conductor);
    }
    for (x, y) in a.segments.iter().zip(b.segments.iter()) {
        assert_eq!(x.n0, y.n0);
        assert_eq!(x.n1, y.n1);
        assert_eq!(x.boundary_marker, y.boundary_marker);
    }
    for (x, y) in a.materials.iter().zip(b.materials.iter()) {
        assert_eq!(x.name, y.name);
        assert!((x.kx - y.kx).abs() < 1e-12);
        assert!((x.kt - y.kt).abs() < 1e-12);
        assert_eq!(x.tk_curve.len(), y.tk_curve.len());
        for ((t0, k0), (t1, k1)) in x.tk_curve.iter().zip(y.tk_curve.iter()) {
            assert!((t0 - t1).abs() < 1e-12);
            assert!((k0 - k1).abs() < 1e-12);
        }
    }
    for (x, y) in a.boundaries.iter().zip(b.boundaries.iter()) {
        assert_eq!(x.name, y.name);
        assert!((x.h - y.h).abs() < 1e-12);
        assert!((x.tinf - y.tinf).abs() < 1e-12);
    }
    for (x, y) in a.conductors.iter().zip(b.conductors.iter()) {
        assert_eq!(x.name, y.name);
        assert!((x.qc - y.qc).abs() < 1e-12);
        assert_eq!(x.conductor_type, y.conductor_type);
    }
    assert_eq!(a.block_labels.len(), b.block_labels.len());
    let la = &a.block_labels[0];
    let lb = &b.block_labels[0];
    assert!((la.x - lb.x).abs() < 1e-12);
    assert_eq!(la.block_type, lb.block_type);
    assert!((la.max_area - lb.max_area).abs() < 1e-10);
}