// Use the same global constants
use crate::PLANKMAX;
use crate::SAWBLADE;
// Define a plank piece structure
#[derive(Debug)]
pub struct Plank {
    length: u32,
    endpiece: bool,
    new: bool,
}
impl Default for Plank {
    /// Create a new, default plank
    fn default() -> Self {
        Self {
            length: PLANKMAX,
            endpiece: false,
            new: true,
        }
    }
}
impl Plank {
    /// Create a new plank
    pub fn new(&self) -> Self {
        Plank::default()
    }
    /// Is this a new plank?
    pub fn is_new(&self) -> bool {
        self.new
    }
    /// Is this at the end of a row
    pub fn get_endpiece(&self) -> bool {
        self.endpiece
    }
    /// Make this plank an endpiece
    pub fn set_endpiece(&mut self) -> () {
        self.endpiece = true;
    }
    /// Return the length of the plank
    pub fn length(&self) -> u32 {
        self.length
    }
    /// Return the original plank with the new length along with leftover
    pub fn cut_to_length(mut self, measure: u32) -> (Plank, Plank) {
        if measure > PLANKMAX {
            panic!("Can't cut a plank longer than it is!");
        }
        // Create the leftover plank, correct for material loss due to sawing
        let leftover_plank = Plank {
            length: self.length - (measure + SAWBLADE),
            endpiece: false,
            new: false,
        };
        // Trim self to the new length
        self.length = measure;
        // In case the plank was new, mark it as cut
        if self.new {
            self.new = false;
        }
        // Return the original plank and the leftover
        (self, leftover_plank)
    }
}
// Define a row structure
#[derive(Debug)]
pub struct Row {
    planks: Vec<Plank>,
    coverage: u32,
    full: bool,
}
impl Default for Row {
    /// Create a new, empty row
    fn default() -> Self {
        Self {
            planks: vec![],
            coverage: 0,
            full: false,
        }
    }
}
impl Row {
    /// Is this row considered full?
    pub fn get_full(&self) -> bool {
        self.full
    }
    /// Mark this row as full
    pub fn set_full(&mut self) -> () {
        self.full = true;
    }
    /// Get the number of plank rows for this floor
    pub fn rows_count(&self) -> usize {
        self.planks.len()
    }
    /// Get the number of plank rows for this floor
    pub fn planks(&mut self) -> &mut Vec<Plank> {
        &mut self.planks
    }
    /// Increase how much of the row is filled
    pub fn add_coverage(&mut self, coverage: u32) -> () {
        self.coverage += coverage;
    }
    /// Get the number of plank rows for this floor
    pub fn get_coverage(&self) -> u32 {
        self.coverage
    }
    /// Add a plank to this row
    pub fn add(&mut self, plank: Plank) -> () {
        self.planks.push(plank);
    }
}
// Define a floor structure
#[derive(Debug)]
pub struct Floor {
    rows: Vec<Row>,
    coverage: u32,
    complete: bool,
}
impl Default for Floor {
    /// Create a new, empty row
    fn default() -> Self {
        Self {
            rows: vec![],
            coverage: 0,
            complete: false,
        }
    }
}
impl Floor {
    /// Is this floor considered complete?
    pub fn is_complete(&self) -> bool {
        self.complete
    }
    /// Get the number of plank rows for this floor
    pub fn rows_count(&self) -> usize {
        self.rows.len()
    }
    pub fn add(&mut self, row: Row) -> () {
        self.rows.push(row);
    }
}

static PLANKMAX: u32 = 2200;

// Import and use floor.rs
mod floor;
use floor::{Plank, Row, Floor};
//static PLANKMAX: u32 = 2200;
static PLANKMAX: u32 = 2010;

static SAWBLADE: u32 = 10;

// Define a plank piece structure
#[derive(Debug)]
struct Plank {
    length: u32,
    endpiece: bool,
    new: bool,
}
impl Default for Plank {
    /// Create a new, default plank
    fn default() -> Self {
        Self {
            length: PLANKMAX,
            endpiece: false,
            new: true,
        }
    }
}
impl Plank {
    /// Is this a new plank?
    fn is_new(&self) -> bool {
        self.new
    }
    /// Is this at the end of a row
    fn is_endpiece(&self) -> bool {
        self.endpiece
    }
    /// Return the length of the plank
    fn length(&self) -> u32 {
        self.length
    }
    /// Return the original plank with the new length along with leftover
    fn cut_to_length(mut self, measure: u32) -> (Plank, Plank) {
        let leftover_plank = Plank {
            length: self.length - measure,
            endpiece: false,
            new: false,
        };
        // Trim self to the new length
        self.length = measure;
        // In case the plank was new, mark it as cut
        if self.new {
            self.new = false;
        }
        // Return the original plank and the leftover
        (self, leftover_plank)
    }
}

// Define a row structure
#[derive(Debug)]
struct Row {
    planks: Vec<Plank>,
    coverage: u32,
    full: bool,
}
impl Default for Row {
    /// Create a new, empty row
    fn default() -> Self {
        Self {
            planks: vec![],
            coverage: 0,
            full: false,
        }
    }
}

impl Row {
    /// Is this row considered complete?
    fn is_full(&self) -> bool {
        self.full
    }
    /// Get the number of plank rows for this floor
    fn rows_count(&self) -> usize {
        self.planks.len()
    }
    fn add(&mut self, plank: Plank) -> () {
        self.planks.push(plank);
    }
}
// Define a floor structure
#[derive(Debug)]
struct Floor {
    rows: Vec<Row>,
    coverage: u32,
    complete: bool,
}
impl Default for Floor {
    /// Create a new, empty row
    fn default() -> Self {
        Self {
            rows: vec![],
            coverage: 0,
            complete: false,
        }
    }
}
impl Floor {
    /// Is this floor considered complete?
    fn is_complete(&self) -> bool {
        self.complete
    }
    /// Get the number of plank rows for this floor
    fn rows_count(&self) -> usize {
        self.rows.len()
    }
    fn add(&mut self, row: Row) -> () {
        self.rows.push(row);
    }
}

        floor.coverage += PLANKWIDTH;

    while row.coverage <= ROOMLENGTH {
        if plank.length > ROOMLENGTH {
            // Planks are longer than the room, need to cut them
            //let leftover;
            let (plankpart, leftover) = plank.cut_to_length(ROOMLENGTH);

    while row.get_coverage() <= ROOMLENGTH {
        // TODO should also check if the plank is too short, then WARN or take a new
        if plank.length() < 200 {
            // Take a new plank and continue
            let newplank: Plank = Default::default();
            plank = newplank;
        }
        if plank.length() > ROOMLENGTH - row.get_coverage() {
            // Cut the plank to length
            let (plankpart, leftover) = plank.cut_to_length(ROOMLENGTH - row.get_coverage());

            row.coverage += plankpart.length();

            row.add_coverage(plankpart.length());

        } else if plank.length() == ROOMLENGTH - row.get_coverage() {
            // If the plank is the same length as the room, no need to cut
            // Use the whole plank, add to row coverage
            row.add_coverage(plank.length());
            row.add(plank);
            // Take a new plank and continue
            let newplank: Plank = Default::default();
            plank = newplank;
        } else {
            // Plank is shorter than the room, need multiple
            // Use the whole plank, add to row coverage
            row.add_coverage(plank.length());
            row.add(plank);
            // Take a new plank and continue
            let newplank: Plank = Default::default();
            plank = newplank;

        println!("Row: {:#?}", row);

    // The row is now full
    row.set_full();
    // Annotate the planks in the beginning and end as endpieces
    if let Some(plank) = row.planks().first_mut() {
        plank.set_endpiece()
    }
    if let Some(plank) = row.planks().last_mut() {
        plank.set_endpiece()
    }