use crate::nix_util::running_build::is_transparent_predicate;
use crate::nix_util::running_build::print_dag;

use super::ReverseTreeIter;
use super::get_draw_order;
use super::test_util::BuildInstruction;
use super::test_util::build_activity_tree_from_instructions;
use super::test_util::get_every_possible_addition;

fn compare_single_tree(
    instructions: &Vec<BuildInstruction>,
) -> Result<(), Box<dyn std::error::Error>> {
    let activity_tree = build_activity_tree_from_instructions(instructions, true)?;
    let original_draw_order = get_draw_order(&activity_tree);
    let reverse_draw_order = ReverseTreeIter::new(
        &activity_tree,
        None,
        |entry| entry.get_activity().is_active(),
        is_transparent_predicate,
        |_entry| true,
    )
    .get_draw_order();

    if original_draw_order != reverse_draw_order {
        println!("Draw order mismatch!");
        println!("Instructions: {:?}", instructions);
        println!("Original: {:?}", original_draw_order);
        println!("Reverse: {:?}", reverse_draw_order);
        print_dag(&activity_tree, original_draw_order);
        print_dag(&activity_tree, reverse_draw_order);
        return Err("mismatch".into());
    }

    Ok(())
}

#[test]
#[ignore]
fn reverse_tree_order_draw_order_iterative() -> Result<(), Box<dyn std::error::Error>> {
    let mut prev_generation: Vec<Vec<BuildInstruction>> = Vec::new();
    let mut current_generation: Vec<Vec<BuildInstruction>> = vec![vec![]];

    // Iterate through every possible tree with N nodes.
    for _ in 0..7 {
        std::mem::swap(&mut prev_generation, &mut current_generation);
        for old_state in prev_generation.drain(..) {
            for new_state in get_every_possible_addition(&old_state) {
                compare_single_tree(&new_state)?;
                current_generation.push(new_state);
            }
        }
    }

    Ok(())
}