/*
    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/>.

*/

pub mod diagram_dot;
pub mod graph;
pub mod graph_summary;
pub mod map_linter;

use crate::{
    diagram_dot::{diagram_dot, diagram_dot_svg},
    graph::graph,
    graph_summary::graph_summary,
    map_linter::check_map,
};
use anyhow::Result;
use clap::Parser;
use hurrycurry_data::{
    book::{diagram_layout::diagram_layout, recipe_diagram::recipe_diagram},
    index::DataIndex,
};

#[derive(Parser)]
enum Action {
    Graph,
    GraphSummary,
    GraphSingle {
        out: String,
        #[arg(short)]
        dot_out: bool,
    },
    MapDemands {
        map: String,
    },
    MapItems {
        map: String,
    },
    MapTiles {
        map: String,
    },
    CheckMap {
        map: String,
    },
}

fn main() -> Result<()> {
    env_logger::init_from_env("LOG");
    let action = Action::parse();

    match action {
        Action::Graph => graph()?,
        Action::GraphSummary => graph_summary()?,
        Action::GraphSingle { out, dot_out } => {
            let index = DataIndex::new("data".into())?;
            let (data, serverdata) = index.generate("5star")?;
            let out = data.get_item_by_name(&out).unwrap();
            let mut diagram = recipe_diagram(&data, &serverdata, &[out])?;
            let out = if dot_out {
                diagram_dot(&data, &diagram, false)?
            } else {
                diagram_layout(&mut diagram)?;
                diagram_dot_svg(&data, &diagram)?
            };
            println!("{out}");
        }
        Action::MapDemands { map } => {
            let index = DataIndex::new("data".into())?;
            let (data, _) = index.generate(&map)?;
            for demand in &data.demands {
                println!("{}", data.item_name(demand.input))
            }
        }
        Action::MapItems { map } => {
            let index = DataIndex::new("data".into())?;
            let (data, _) = index.generate(&map)?;
            for name in &data.item_names {
                println!("{name}")
            }
        }
        Action::MapTiles { map } => {
            let index = DataIndex::new("data".into())?;
            let (data, _) = index.generate(&map)?;
            for name in &data.tile_names {
                println!("{name}")
            }
        }
        Action::CheckMap { map } => {
            if map == "all" {
                let index = DataIndex::new("data".into())?;
                for map in index.maps.keys() {
                    check_map(map)?;
                }
            } else {
                check_map(&map)?;
            }
        }
    }
    Ok(())
}
