//! Map model.

use super::qobj::*;
use maraiah::{backtrace, err::*, fixed, map::{self, data::*}};
use crate::cc;

fn to_screen(coord: fixed::Unit) -> i16
{
	let long = fixed::FixedLong::from_unit(coord);
	(long * 10).integ() as i16
}

fn draw_points<'a, P>(paint: *mut cc::QPainter, pnts: &'a [P])
	where P:                Into<map::pnts::Point>,
	      map::pnts::Point: From<&'a P>
{
	for p in pnts.iter() {
		let p: map::pnts::Point = p.into();
		cc::paint_point(paint, to_screen(p.x), to_screen(p.y));
	}
}

fn draw_map(paint: *mut cc::QPainter, entry: &EntryData)
{
	cc::paint_fg(paint, 0, 255, 0, 255);

	if let Some(pnts) = &entry.pnts {
		draw_points(paint, pnts.as_slice());
	} else if let Some(epnt) = &entry.epnt {
		draw_points(paint, epnt.as_slice());
	}
}

impl IMapModel
{
	pub fn open_map(path: String) -> ResultS<EntryDataMap>
	{
		let mut fp = maraiah::file::open_mac(path)?;

		let map = map::head::read(&mut fp)?;
		let ent = map::entr::read_all(&map)?;

		map::data::read_all(map.head(), &ent)
	}

	pub fn get(&self, index: usize) -> (&u16, &EntryData)
	{
		self.map.iter().nth(index).unwrap()
	}

	/*
	pub fn get_mut(&mut self, index: usize) -> (&u16, &mut EntryData)
	{
	   self.map.iter_mut().nth(index).unwrap()
	}
	*/
}

impl IMapModelTrait for IMapModel
{
	/// Returns a new `IMapModel` instance.
	fn new(emit: IMapModelEmitter, _: IMapModelList) -> Self
	{
		if cfg!(debug_assertions) {
			eprintln!("new IMapModel");
		}

		Self{emit, map: EntryDataMap::default(), selected: None, dirty: false}
	}

	/// Returns the emitter of `self`.
	fn emit(&mut self) -> &mut IMapModelEmitter {&mut self.emit}

	fn row_count(&self) -> usize {self.map.len()}

	fn prop_index(&self, index: usize) -> u64 {(*self.get(index).0).into()}

	fn prop_icon(&self, index: u16) -> String
	{
		match self.get(index.into()).1.get_type() {
			EntryType::Image   => "image-x-generic".to_string(),
			EntryType::Map     => "tycho-map".to_string(),
			EntryType::Other   => "image-missing".to_string(),
			EntryType::Physics => "applications-system".to_string(),
		}
	}

	/// Opens the map file at `path`.
	fn open(&mut self, path: String) -> bool
	{
		match Self::open_map(path) {
			Ok(map) => {
				self.map = map;
				true
			}
			Err(e) => {
				backtrace!(e);
				cc::critical_msg("Error opening map", e);
				false
			}
		}
	}

	/// Saves the project into the original file.
	fn save(&self) -> bool
	{
		if cfg!(debug_assertions) {
			eprintln!("saving project");
		}

		false
	}

	/// Saves the project into `path`.
	fn save_as(&self, path: String) -> bool
	{
		if cfg!(debug_assertions) {
			eprintln!("saving project as {}", path);
		}

		false
	}

	/// Returns `true` if the file has been modified from its original state.
	fn dirty(&self) -> bool {self.dirty}

	fn set_dirty(&mut self, dirty: bool) {self.dirty = dirty;}

	fn deselect(&mut self) {self.selected = None;}

	fn select(&mut self, index: u16)
	{
		self.selected = Some(index);
	}

	fn draw_view(&self, paint: *mut cc::QPainter)
	{
		if let Some(selected) = self.selected {
			if let Some(entry) = self.map.get(&selected) {
				if entry.get_type() == EntryType::Map {
					draw_map(paint, entry);
				}
			}
		}
	}
}

impl Drop for IMapModel
{
	fn drop(&mut self)
	{
		if cfg!(debug_assertions) {
			eprintln!("drop IMapModel");
		}
	}
}

pub struct IMapModel {
	emit:     IMapModelEmitter,
	map:      EntryDataMap,
	selected: Option<u16>,
	dirty:    bool,
}

// EOF