//! Map editor state.

use super::block;
use crate::marathon::{machdr, wad};

impl OpenMap
{
   pub(super) fn open_buf(b: &[u8]) -> Self
   {
      // TODO: handle errors gracefully
      let b = &b[machdr::try_mac_header(b)..];
      let wad = wad::read_wad(b).unwrap();

      let ent = wad.entries.iter().nth(0).unwrap().1;
      let info = ent.chunks.iter().find_map(|cnk| {
         match cnk {
            wad::Chunk::Minf(info) => Some(info),
            _ => None,
         }
      }).unwrap().clone();

      let block = block::Block{info};

      dbg!(&block);

      Self{blocks: vec![block],
           tools:  Self::default_tools()}
   }

   pub(super) fn cur_block(&self) -> &block::Block
   {
      self.blocks.last().unwrap()
   }

   pub(super) fn cur_block_mut(&mut self) -> &mut block::Block
   {
      self.blocks.last_mut().unwrap()
   }

   pub(super) fn tool(&self) -> &Tool {&self.tools.0}

   pub(super) fn set_tool(&mut self, t: Tool) -> &Tool
   {
      self.tools.1 = self.tools.0.clone();
      self.tools.0 = t;

      &self.tools.1
   }

   const fn default_tools() -> (Tool, Tool) {(Tool::Points, Tool::Lines)}
}

impl Default for OpenMap
{
   #[inline]
   fn default() -> Self
   {
      Self{blocks: vec![block::Block::default()],
           tools:  Self::default_tools()}
   }
}

/// The state of an opened map editor.
pub(super) struct OpenMap
{
   blocks: Vec<block::Block>,
   tools:  (Tool, Tool),
}

/// A tool in the map editor.
#[derive(Clone, Debug)]
pub(super) enum Tool
{
   Points,
   Lines,
   Polygons,
}

// EOF