use constants::{AVAILABLEPLANKS, PLANKMAX, PLANKMIN, SAWBLADE};

use constants::{AVAILABLEPLANKS, CUTADJACENCY, PLANKMAX, PLANKMIN, PLAY, ROOMLENGTH, SAWBLADE};

    }
}
// Define a plank cut structure
#[derive(Debug, Clone, Copy)]
pub struct Cut {
    pub coordinate: u32,
}
impl Cut {
    pub fn new(coordinate: u32) -> Self {
        Cut { coordinate }

    planks_used: u32,

    cut_coordinates: Vec<Cut>,

            planks_used: 1,

            cut_coordinates: vec![],

    pub fn get_cut_coordinates(&self) -> Vec<Cut> {
        return self.cut_coordinates.clone();
    }
    pub fn check_if_cut_is_valid(&self, new_cut: Cut) -> bool {
        // If we have no cuts, no need to check them
        if !self.cut_coordinates.is_empty() {
            for cut in &self.cut_coordinates {
                println!("Cut coordinate {}", cut.coordinate);
                if cut.coordinate.abs_diff(new_cut.coordinate) < CUTADJACENCY {
                    // Invalid, cut is too close!
                    return false;
                }
            }
        }
        return true;
    }

/// The smalles allowed space between plank cuts
pub static CUTADJACENCY: u32 = 400;

use parkett::{Floor, MaterialStorage, Row};

use parkett::{Cut, Floor, MaterialStorage, Row};

        let required_length = ROOMLENGTH - row.get_coverage();

        let required_length = row.get_max_length() - row.get_coverage();
        if let Some(adjacent_row) = adjacent_row {
            println!("Cut coordinates: {:?}", row.get_cut_coordinates());
            // Check if the new plank lands too close to a previous cut
            // Or a new one
            if !adjacent_row.check_if_cut_is_valid(Cut::new(required_length)) {
                println!("Invalid cut at {required_length}!!! Handle this");
            } else if !adjacent_row.check_if_cut_is_valid(Cut::new(PLANKMAX)) {
                println!("Invalid cut at {PLANKMAX}!!! Handle this");
            }
        }