//! Map file entry data.

use crate::{bin::*, err::*, image::{self, pict}, map};
use super::{entr, head};
use std::collections::BTreeMap;

/// Reads all chunks in an entry.
pub fn read(head: &head::Header, b: &[u8]) -> ResultS<EntryData>
{
   let mut data = EntryData::default();

   let old = head.old_data();

   let rd_cminf = if old {map::minf::read_old} else {map::minf::read};
   let rd_csids = if old {map::sids::read_old} else {map::sids::read};
   let rd_cpoly = if old {map::poly::read_old} else {map::poly::read};
   let rd_clite = if old {map::lite::read_old} else {map::lite::read};

   let mut p = 0;

   while p < b.len() {
      read_data! {
         endian: BIG, buf: b, size: head.size_chunk(), start: p, data {
            let iden = Ident[0];
            let size = u32[8] usize;
         }
      }

      let beg = p + head.size_chunk();
      let end = beg + size;
      let buf = ok!(b.get(beg..end), "not enough data")?;

      match &iden.0 {
         b"EPNT" => data.epnt = Some(rd_array(buf, map::epnt::read)?),
         b"FXpx" => data.fxpx = Some(rd_array(buf, map::fxpx::read)?),
         b"LINS" => data.lins = Some(rd_array(buf, map::lins::read)?),
         b"LITE" => data.lite = Some(rd_array(buf, rd_clite)?),
         b"MNpx" => data.mnpx = Some(rd_array(buf, map::mnpx::read)?),
         b"Minf" => data.minf = Some(rd_cminf(buf)?),
         b"NAME" => data.name = Some(rd_array(buf, map::name::read)?),
         b"NOTE" => data.note = Some(rd_array(buf, map::note::read)?),
         b"OBJS" => data.objs = Some(rd_array(buf, map::objs::read)?),
         b"PICT" => data.pict = Some(pict::read(buf)?),
         b"PNTS" => data.pnts = Some(rd_array(buf, map::pnts::read)?),
         b"POLY" => data.poly = Some(rd_array(buf, rd_cpoly)?),
         b"PRpx" => data.prpx = Some(rd_array(buf, map::prpx::read)?),
         b"PXpx" => data.pxpx = Some(rd_array(buf, map::pxpx::read)?),
         b"SIDS" => data.sids = Some(rd_array(buf, rd_csids)?),
         b"WPpx" => data.wppx = Some(rd_array(buf, map::wppx::read)?),
         b"ambi" => data.ambi = Some(rd_array(buf, map::ambi::read)?),
         b"bonk" => data.bonk = Some(rd_array(buf, map::bonk::read)?),
         b"iidx" => data.iidx = Some(rd_array(buf, map::iidx::read)?),
         b"medi" => data.medi = Some(rd_array(buf, map::medi::read)?),
         b"plac" => data.plac = Some(rd_array(buf, map::plac::read)?),
         b"plat" => data.plat = Some(rd_array(buf, map::plat::read)?),
         b"term" => data.term = Some(rd_array(buf, map::term::read)?),
         _       => data.unkn.push((iden, buf.to_vec())),
      }

      p = end;
   }

   Ok(data)
}

/// Reads all of the data from an entry map.
pub fn read_all(head: &head::Header,
                map:  &entr::EntryMap<'_>) -> ResultS<EntryDataMap>
{
   let mut data_map = EntryDataMap::new();

   for (&index, entry) in map {
      data_map.insert(index, read(head, entry.data)?);
   }

   Ok(data_map)
}

/// The loaded data of a Map file entry.
#[cfg_attr(feature = "serde_obj", derive(serde::Serialize))]
#[derive(Debug, Default, Eq, PartialEq)]
pub struct EntryData
{
   /** `EPNT` chunk data. */ pub epnt: Option<Vec<map::epnt::Endpoint>>,
   /** `FXpx` chunk data. */ pub fxpx: Option<Vec<map::fxpx::Effect>>,
   /** `LINS` chunk data. */ pub lins: Option<Vec<map::lins::Line>>,
   /** `LITE` chunk data. */ pub lite: Option<Vec<map::lite::Light>>,
   /** `MNpx` chunk data. */ pub mnpx: Option<Vec<map::mnpx::Monster>>,
   /** `Minf` chunk data. */ pub minf: Option<map::minf::Info>,
   /** `NAME` chunk data. */ pub name: Option<Vec<String>>,
   /** `NOTE` chunk data. */ pub note: Option<Vec<map::note::Note>>,
   /** `OBJS` chunk data. */ pub objs: Option<Vec<map::objs::Object>>,
   /** `PICT` chunk data. */ pub pict: Option<image::Image8>,
   /** `PNTS` chunk data. */ pub pnts: Option<Vec<map::pnts::Point>>,
   /** `POLY` chunk data. */ pub poly: Option<Vec<map::poly::Polygon>>,
   /** `PRpx` chunk data. */ pub prpx: Option<Vec<map::prpx::Projectile>>,
   /** `PXpx` chunk data. */ pub pxpx: Option<Vec<map::pxpx::Physics>>,
   /** `SIDS` chunk data. */ pub sids: Option<Vec<map::sids::Side>>,
   /** `WPpx` chunk data. */ pub wppx: Option<Vec<map::wppx::Weapon>>,
   /** `ambi` chunk data. */ pub ambi: Option<Vec<map::ambi::SoundAmbi>>,
   /** `bonk` chunk data. */ pub bonk: Option<Vec<map::bonk::SoundRand>>,
   /** `iidx` chunk data. */ pub iidx: Option<Vec<u16>>,
   /** `medi` chunk data. */ pub medi: Option<Vec<map::medi::Media>>,
   /** `plac` chunk data. */ pub plac: Option<Vec<map::plac::ObjectFreq>>,
   /** `plat` chunk data. */ pub plat: Option<Vec<map::plat::Platform>>,
   /** `term` chunk data. */ pub term: Option<Vec<map::term::Terminal>>,

   pub unkn: Vec<(Ident, Vec<u8>)>,
}

/// A map of indexed entries.
pub type EntryDataMap = BTreeMap<u16, EntryData>;

// EOF