use maraiah::{durandal::{bin, fixed::*}, marathon::{map, trm}};

include!("data/rand.rs");

#[test]
fn read_term_must_process()
{
   const INPUT: &[u8] = include_bytes!("data/term.in");

   let inp = bin::rd_array(INPUT, trm::read_term).unwrap();
   let out = include!("data/term.out");

   // for better debug output, we iterate over each item
   assert_eq!(inp.len(), out.len());

   for (itrm, otrm) in inp.iter().zip(&out) {
      assert_eq!(itrm.groups.len(), otrm.groups.len());
      for (igrp, ogrp) in itrm.groups.iter().zip(&otrm.groups) {
         assert_eq!(igrp, ogrp);
      }

      assert_eq!(itrm.faces.len(), otrm.faces.len());
      for (ifac, ofac) in itrm.faces.iter().zip(&otrm.faces) {
         assert_eq!(ifac, ofac);
      }
   }
}

#[test]
fn trm_must_not_process()
{
   for inp in &RANDOM {
      assert!(bin::rd_array(inp, trm::read_term).is_err());
   }
}

#[test]
fn read_minf_must_process()
{
   const INPUT: &[u8] = include_bytes!("data/minf.in");

   let out = map::Minf{env_code:    0,
                       physi_id:    1,
                       music_id:    1,
                       missi_flags: map::MsnFlags::Repair,
                       envir_flags: map::EnvFlags::empty(),
                       entry_flags: map::EntFlags::Solo | map::EntFlags::CoOp,
                       level_name:  "Waterloo Waterpark".to_string()};

   assert_eq!(map::read_minf(INPUT).unwrap(), out);
}

#[test]
fn read_epnt_must_process()
{
   const INPUT: &[u8] = include_bytes!("data/epnt.in");
   const OUTPUT: [map::Point; 54] = include!("data/epnt.out");

   assert_eq!(bin::rd_array(INPUT, map::read_epnt).unwrap(), OUTPUT.to_vec());
}

#[test]
fn map_must_not_process()
{
   // these functions must not succeed
   for inp in &RANDOM {
      assert!(map::read_minf(inp).is_err());
      assert!(map::read_old_minf(inp).is_err());
      assert!(bin::rd_array(inp, map::read_lins).is_err());
      assert!(bin::rd_array(inp, map::read_lite).is_err());
      assert!(bin::rd_array(inp, map::read_medi).is_err());
      assert!(bin::rd_array(inp, map::read_note).is_err());
      assert!(bin::rd_array(inp, map::read_objs).is_err());
      assert!(bin::rd_array(inp, map::read_plat).is_err());
      assert!(bin::rd_array(inp, map::read_poly).is_err());
      assert!(bin::rd_array(inp, map::read_sids).is_err());
      assert!(bin::rd_array(inp, map::read_old_lite).is_err());
      assert!(bin::rd_array(inp, map::read_old_poly).is_err());
      assert!(bin::rd_array(inp, map::read_old_sids).is_err());
   }
}

#[test]
#[allow(unused_must_use)]
fn map_wont_panic()
{
   // these functions can succeed but must never panic
   for inp in &RANDOM {
      bin::rd_array(inp, map::read_ambi);
      bin::rd_array(inp, map::read_bonk);
      bin::rd_array(inp, map::read_epnt);
      bin::rd_array(inp, map::read_iidx);
      bin::rd_array(inp, map::read_plac);
   }
}

// EOF