static PLANKMAX: i32 = 2200;
static PLANKWIDTH: i32 = 185;
static PLAY: i32 = 20;
static ROOMLENGTH: i32 = 3800 - PLAY;
static ROOMDEPTH: i32 = 2800 - PLAY;

static PLANKMAX: u32 = 2200;
static PLANKWIDTH: u32 = 185;
static PLAY: u32 = 20;
static ROOMLENGTH: u32 = 3800;
static ROOMDEPTH: u32 = 2800;
// TODO Add PLAY at the end when printing

// Define a plank structure
#[derive(Debug)]
struct Plank {
    length: u32,
    endpiece: bool,
}

    println!("Room dimensions: {} x {} mm", ROOMLENGTH + PLAY, ROOMDEPTH + PLAY);

    println!(
        "Room dimensions: {} x {} mm",
        ROOMLENGTH + PLAY,
        ROOMDEPTH + PLAY
    );

    let mut temp = 0;

    let mut leftover = 0;

    let mut planklist = vec![];

    let mut rowlist: Vec<Vec<Plank>> = vec![];

    temp = calc_new_length(PLANKMAX, ROOMLENGTH - temp);

    //println!("First plank length: {}", PLANKMAX - leftover);

    println!("First plank length: {}", PLANKMAX - temp);

    while coverage < ROOMDEPTH {
        // Create new plank vector
        let mut row = vec![];

    while coverage < ROOMDEPTH {
        // Store the old length for the list
        let tempold = temp;

        let mut rowfilled = 0;
        while rowfilled < ROOMLENGTH {
            // Length of the plank is greater than the remainder room
            if ROOMLENGTH - rowfilled > PLANKMAX {
                // If this is the first plank
                let end = rowfilled == 0;
                // Store the full length plank
                row.push(Plank {
                    length: PLANKMAX,
                    endpiece: end,
                });
                rowfilled += PLANKMAX;

        // Length of the plank is greater than the room
        if temp > ROOMLENGTH {

                // For each iteration, we have used another plank
                plankcount += 1;

            // Store the full length plank and the next
            planklist.push((ROOMLENGTH, 0));

                // If a whole plank was used, the leftover is 0
                leftover = 0;

            temp -= ROOMLENGTH;
        // Length of the plank is smaller than the room
        } else {
            // Store the two plank lengths as a tuple
            planklist.push((tempold, ROOMLENGTH - temp));

            // Length of the plank is smaller than the room
            } else {
                // Add the remainder
                let remainder = ROOMLENGTH - rowfilled;
                row.push(Plank {
                    length: remainder,
                    endpiece: true,
                });
                rowfilled += remainder;

            // Calculate the next plank length
            temp = calc_new_length(PLANKMAX, ROOMLENGTH - temp);

                // Calculate the leftover plank length
                leftover = PLANKMAX - (ROOMLENGTH - rowfilled);
            }

            let mut leftoverold = leftover;

        rowlist.push(row);

        // For each iteration, we have added another plank
        plankcount += 1;

    println!("\n: {:#?}\n", rowlist);

    /*

    */

fn calc_new_length(prev: i32, next: i32) -> i32 {

fn calc_new_length(prev: u32, next: u32) -> u32 {