/*
    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 book_html;
pub mod diagram_dot;
pub mod diagram_svg;
pub mod graph;
pub mod graph_summary;
pub mod map_linter;

use crate::{
    book_html::render_html_book,
    diagram_dot::{diagram_dot, diagram_dot_svg},
    diagram_svg::diagram_svg,
    graph::graph,
    graph_summary::graph_summary,
    map_linter::check_map,
};
use anyhow::Result;
use clap::Parser;
use hurrycurry_data::{
    book::{book, diagram_layout::diagram_layout, print_book, recipe_diagram::recipe_diagram},
    index::DataIndex,
};
use hurrycurry_locale::FALLBACK_LOCALE;

#[derive(Parser)]
enum Action {
    Graph,
    GraphSummary,
    GraphSingle {
        out: String,
        #[arg(short)]
        custom_svg: bool,
        #[arg(short)]
        dot_out: bool,
    },
    Book,
    BookHtml,
    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,
            custom_svg,
            dot_out,
        } => {
            let mut index = DataIndex::default();
            index.reload()?;
            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 if custom_svg {
                diagram_layout(&mut diagram)?;
                diagram_svg(&data, &diagram)?
            } else {
                diagram_layout(&mut diagram)?;
                diagram_dot_svg(&data, &diagram)?
            };
            println!("{out}");
        }
        Action::Book => {
            let mut index = DataIndex::default();
            index.reload()?;
            let (data, serverdata) = index.generate("5star")?;
            print_book(&data, &serverdata)?
        }
        Action::BookHtml => {
            let mut index = DataIndex::default();
            index.reload()?;
            let (data, serverdata) = index.generate("5star")?;
            let book = book(&data, &serverdata)?;
            println!("{}", render_html_book(&data, &book, &FALLBACK_LOCALE));
        }
        Action::MapDemands { map } => {
            let mut index = DataIndex::default();
            index.reload()?;
            let (data, _) = index.generate(&map)?;
            for demand in &data.demands {
                println!("{}", data.item_name(demand.input))
            }
        }
        Action::MapItems { map } => {
            let mut index = DataIndex::default();
            index.reload()?;
            let (data, _) = index.generate(&map)?;
            for name in &data.item_names {
                println!("{name}")
            }
        }
        Action::MapTiles { map } => {
            let mut index = DataIndex::default();
            index.reload()?;
            let (data, _) = index.generate(&map)?;
            for name in &data.tile_names {
                println!("{name}")
            }
        }
        Action::CheckMap { map } => {
            if map == "all" {
                let mut index = DataIndex::default();
                index.reload()?;
                for map in index.maps.keys() {
                    check_map(map)?;
                }
            } else {
                check_map(&map)?;
            }
        }
    }
    Ok(())
}