use std::{fs, io, path::Path, process::ExitCode};

use advent_of_code_2023::{cli::AppCliArguments, solutions};
use clap::Parser;

use thiserror::Error;

fn main() -> ExitCode {
    let args = AppCliArguments::parse();
    let solution = solve_given(&args);
    match solution {
        Ok(found_solution) => {
            println!("{}", found_solution);
            ExitCode::SUCCESS
        }
        Err(error) => {
            eprintln!("{}", error);
            ExitCode::FAILURE
        }
    }
}

fn solve_given(args: &AppCliArguments) -> Result<String, CouldNotSolveError> {
    let all_solutions = solutions::create_solutions();

    let found_task = {
        let day: u32 = args.day().into();
        let task: u32 = args.task().into();
        let found_day = all_solutions
            .get(day.saturating_sub(1) as usize)
            .ok_or_else(|| CouldNotSolveError::DayNotFound(day))?;
        found_day
            .get(task.saturating_sub(1) as usize)
            .ok_or_else(|| CouldNotSolveError::TaskNotFound { day, task })
    }?;

    let solved = (found_task)(args.input());
    Ok(solved)
}

fn try_read_from_file_if_demanded(args: &AppCliArguments) -> io::Result<String> {
    let content = if args.read_as_file() {
        let path = Path::new(args.input());
        let input_as_file = fs::read_to_string(path)?;
        input_as_file
    } else {
        args.input().to_string()
    };
    Ok(content)
}

#[derive(Debug, Clone, Copy, Error)]
enum CouldNotSolveError {
    #[error("There is no solution for the day {0}")]
    DayNotFound(u32),
    #[error("There is not solution for task {task} under the day {day}")]
    TaskNotFound { day: u32, task: u32 },
    #[error("Could not read puzzel input from the given file\n {0}")]
    CouldNotReadFromFile(#[from] io::Error),
}