use argh::FromArgs;

use sol_chess::board::Board;
use sol_chess::generator;
use sol_chess::solver::Solver;

fn main() {
    let args: Args = argh::from_env();

    if args.generate {
        let puzzle = generate_puzzle(args.num_pieces, args.solutions);
        let Some(board) = puzzle else {
            return;
        };

        board.pretty_print();
        if args.print {
            solve_puzzle(board);
        }
    } else {
        let board = if let Some(board_string) = args.solve_board {
            Board::from_string(board_string)
        } else if let Some(board_id) = args.solve {
            Board::from_id(board_id)
        } else {
            println!("Use --help to see available options");
            return;
        };
        let Ok(board) = board else {
            println!("Invalid board string/id");
            return;
        };
        board.pretty_print();
        solve_puzzle(board);
    }
}

fn solve_puzzle(board: Board) {
    let solutions = Solver::new(board).solve();
    if solutions.len() == 0 {
        println!("No solutions found");
        return;
    }
    println!("Found {} solutions", solutions.len());
    let solution = solutions.first().unwrap();
    let mut idx = 0;
    solution.iter().for_each(|m| {
        idx += 1;
        println!("{}. {}", idx, m.notation());
    });
}

fn generate_puzzle(num_pieces: Option<u32>, num_solutions: Option<u32>) -> Option<Board> {
    let mut num_pieces = num_pieces.unwrap_or(5);
    if num_pieces < 2 {
        num_pieces = 2;
    }

    let mut num_solutions = num_solutions.unwrap_or(5);
    if num_solutions < 1 {
        num_solutions = 5;
    }

    println!(
        "Generating a puzzle with {} pieces with a maximum of {} solutions",
        num_pieces, num_solutions
    );
    let gen = generator::generate(num_pieces, num_solutions);
    gen.print_stats();

    let Some(board) = gen.board() else {
        println!("Failed to generate a puzzle, try again");
        return None;
    };

    Some(board)
}

/// Solitaire Chess puzzle generator and solver
/// - v0.0.1 cool-mist
#[derive(FromArgs)]
struct Args {
    #[argh(switch, short = 'g')]
    /// generate a puzzle
    generate: bool,

    #[argh(option, short = 'n')]
    /// number of pieces to place on the board while generating a puzzle
    num_pieces: Option<u32>,

    #[argh(option)]
    /// maximum number of solutions allowed for the generated puzzle. atleast 1. defaults to 5
    solutions: Option<u32>,

    #[argh(switch)]
    /// print the solution. When solving a puzzle, this is always set to true
    print: bool,

    #[argh(option, short = 's')]
    /// the id of the board to solve
    solve: Option<u128>,

    #[argh(option)]
    /// the board to solve in board representation
    solve_board: Option<String>,
}