use std::env;
use std::error::Error;
use std::path::PathBuf;

use log::LevelFilter;

use nsga_rs::algorithms::{
    Algorithm, NSGA3Arg, Nsga3NumberOfIndividuals, StoppingCondition, NSGA3,
};
use nsga_rs::core::builtin_problems::DTLZ2Problem;
use nsga_rs::operators::SimulatedBinaryCrossoverArgs;
use nsga_rs::utils::{DasDarren1998, NumberOfPartitions};

/// Solve the DTLZ2 problem from Deb et al. (2013) with 3 objectives.
///
/// Make sure to compile this in release mode to speed up the calculation:
///
/// `cargo run --example nsga3_dtlz2 -p nsga_rs --release`
fn main() -> Result<(), Box<dyn Error>> {
    // Add log
    env_logger::builder().filter_level(LevelFilter::Info).init();

    let number_objectives: usize = 3;
    // Set the number of variables to use in the DTLZ1 problem
    let k: usize = 10;
    let number_variables: usize = number_objectives + k - 1;
    // Get the built-in problem
    let problem = DTLZ2Problem::create(number_variables, number_objectives)?;

    // Set the number of partitions to create the reference points for the NSGA3 algorithm. This
    // uses one layer of 12 uniform gaps
    // let number_of_partitions = NumberOfPartitions::OneLayer(6);
    let number_of_partitions = NumberOfPartitions::OneLayer(12);
    // NSGA3 internally uses the Das & Darren approach to generate the points. This is also
    // available using:
    let das_darren = DasDarren1998::new(number_objectives, &number_of_partitions)?;
    println!(
        "Number of reference points to generate: {}",
        das_darren.number_of_points()
    );

    // Customise the SBX and PM operators like in the paper
    let crossover_operator_options = SimulatedBinaryCrossoverArgs {
        distribution_index: 30.0,
        crossover_probability: 1.0,
        ..SimulatedBinaryCrossoverArgs::default()
    };

    // Set up the NSGA3 algorithm
    let args = NSGA3Arg {
        // number of individuals from the paper (possibly equal to number of reference points)
        number_of_individuals: Nsga3NumberOfIndividuals::Custom(92),
        number_of_partitions,
        crossover_operator_options: Some(crossover_operator_options),
        mutation_operator_options: None,
        // stop at generation 400
        stopping_condition: StoppingCondition::MaxGeneration(400),
        parallel: None,
        export_history: None,
        // to reproduce results
        seed: Some(1),
        resume_from_file: None,
    };

    // Initialise the algorithm
    let mut algo = NSGA3::new(problem, args, false).unwrap();

    // Run the algorithm
    algo.run()?;

    // Export the last results to a JSON file
    let destination = PathBuf::from(&env::current_dir().unwrap())
        .join("examples")
        .join("results");
    algo.save_to_json(&destination, Some("DTLZ2_3obj"))?;

    Ok(())
}
