use integral_geometry::Size;

use landgen::wavefront_collapse::generator::*;
use serde_derive::Deserialize;

use std::collections::hash_map::HashMap;

#[derive(Deserialize)]
#[serde(remote = "EdgeDescription")]
pub struct EdgeDesc {
    pub name: String,
    pub reversed: Option<bool>,
    pub symmetrical: Option<bool>,
}

#[derive(Deserialize)]
#[serde(remote = "EdgesDescription")]
pub struct EdgesDesc {
    #[serde(with = "EdgeDesc")]
    pub top: EdgeDescription,
    #[serde(with = "EdgeDesc")]
    pub right: EdgeDescription,
    #[serde(with = "EdgeDesc")]
    pub bottom: EdgeDescription,
    #[serde(with = "EdgeDesc")]
    pub left: EdgeDescription,
}

#[derive(Deserialize)]
#[serde(remote = "TileDescription")]
pub struct TileDesc {
    pub name: String,
    #[serde(with = "EdgesDesc")]
    pub edges: EdgesDescription,
    pub is_negative: Option<bool>,
    pub can_flip: Option<bool>,
    pub can_mirror: Option<bool>,
    pub can_rotate90: Option<bool>,
    pub can_rotate180: Option<bool>,
    pub can_rotate270: Option<bool>,
}

#[derive(Deserialize)]
pub struct TileDescriptionHelper(#[serde(with = "TileDesc")] TileDescription);
#[derive(Deserialize)]
pub struct EdgeDescriptionHelper(#[serde(with = "EdgeDesc")] EdgeDescription);

#[derive(Deserialize)]
pub struct NonStrictEdgesDesc {
    pub top: Option<EdgeDescriptionHelper>,
    pub right: Option<EdgeDescriptionHelper>,
    pub bottom: Option<EdgeDescriptionHelper>,
    pub left: Option<EdgeDescriptionHelper>,
}

#[derive(Deserialize)]
pub struct TemplateDesc {
    pub width: usize,
    pub height: usize,
    pub can_invert: bool,
    pub is_negative: bool,
    pub put_girders: bool,
    pub max_hedgehogs: u8,
    pub wrap: bool,
    pub edges: Option<NonStrictEdgesDesc>,
    pub tiles: Vec<TileDescriptionHelper>,
}

#[derive(Deserialize)]
pub struct TemplateCollectionDesc {
    pub templates: Vec<TemplateDesc>,
    pub template_types: HashMap<String, Vec<usize>>,
}

impl From<&TemplateDesc> for TemplateDescription {
    fn from(desc: &TemplateDesc) -> Self {
        let [top, right, bottom, left] = if let Some(edges) = &desc.edges {
            [
                edges.top.as_ref(),
                edges.right.as_ref(),
                edges.bottom.as_ref(),
                edges.left.as_ref(),
            ]
            .map(|e| e.map(|EdgeDescriptionHelper(e)| e.clone()))
        } else {
            [None, None, None, None]
        };

        Self {
            size: Size::new(desc.width, desc.height),
            tiles: desc
                .tiles
                .iter()
                .map(|TileDescriptionHelper(t)| t.clone())
                .collect(),
            wrap: desc.wrap,
            edges: NonStrictEdgesDescription {
                top,
                right,
                bottom,
                left,
            },
        }
    }
}