/*
    Hurry Curry! - a game about cooking
    Copyright (C) 2025 Hurry Curry! Contributors

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, version 3 of the License only.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/

use anyhow::{Context, Result, anyhow, bail};
use hurrycurry_protocol::{Gamedata, MapMetadata};
use log::debug;
use serde::Deserialize;
use std::{
    collections::{HashMap, HashSet},
    fs::{File, read_to_string},
    path::PathBuf,
};

use crate::{MapDecl, Serverdata, book::book, build_data};

#[derive(Debug, Deserialize)]
pub struct DataIndex {
    #[serde(skip)]
    pub path: PathBuf,
    pub maps: HashMap<String, MapMetadata>,
    pub recipes: HashSet<String>,
}

impl DataIndex {
    pub fn new(path: PathBuf) -> Result<Self> {
        let mut s = Self {
            path,
            maps: HashMap::new(),
            recipes: HashSet::new(),
        };
        s.reload()?;
        Ok(s)
    }
    pub fn reload(&mut self) -> Result<()> {
        let path = self.path.clone();
        *self = serde_yml::from_reader(
            File::open(self.path.join("index.yaml")).context("Failed opening data index")?,
        )?;
        self.path = path;
        Ok(())
    }

    pub fn read_map(&self, name: &str) -> Result<String> {
        // Scary!
        if name.contains("..") || name.starts_with("/") || name.contains("//") {
            bail!("illegal map path");
        }
        let path = self.path.join(format!("maps/{name}.yaml"));
        Ok(read_to_string(path)?)
    }
    pub fn read_recipes(&self, name: &str) -> Result<String> {
        if !self.recipes.contains(name) {
            bail!("unknown recipes: {name:?}");
        }
        let path = self.path.join(format!("recipes/{name}.yaml"));
        Ok(read_to_string(path)?)
    }
    pub fn generate(&self, map: &str) -> Result<(Gamedata, Serverdata)> {
        debug!("Loading map {map}...");
        let map_in: MapDecl = serde_yml::from_str(
            &self
                .read_map(map)
                .context(anyhow!("Failed to read map file ({map})"))?,
        )
        .context(anyhow!("Failed to parse map file ({map})"))?;
        let recipes_in = serde_yml::from_str(
            &self
                .read_recipes(map_in.recipes.as_deref().unwrap_or("default"))
                .context("Failed read recipe file")?,
        )
        .context("Failed to parse recipe file")?;

        let data = build_data(&self.maps, map.to_string(), map_in, recipes_in)?;
        debug!("Done.");
        Ok(data)
    }
    pub fn generate_with_book(&self, map: &str) -> Result<(Gamedata, Serverdata)> {
        let (gd, mut sd) = self.generate(map)?;
        sd.book = book(&gd, &sd).context("within book")?;
        Ok((gd, sd))
    }
}
