mod floor;
use floor::{Floor, MaterialStorage, Plank, Row};
/// The length of a new plank
//static PLANKMAX: u32 = 2200;
//static PLANKMAX: u32 = 2010;
/// The smallest allowable plank length
//static PLANKMIN: u32 = 200;
//static PLANKWIDTH: u32 = 185;
//static PLAY: u32 = 20;
//static SAWBLADE: u32 = 10;
//static ROOMLENGTH: u32 = 3800;
//static ROOMLENGTH: u32 = 1000;
//static ROOMDEPTH: u32 = 555;
//static ROOMDEPTH: u32 = 2800;
/// The length of a new plank
static PLANKMAX: u32 = 2200;
//static PLANKMAX: u32 = 1900;
/// The smallest allowable plank length
static PLANKMIN: u32 = 200;
static PLANKWIDTH: u32 = 100;
static PLAY: u32 = 5;
static SAWBLADE: u32 = 10;
//static ROOMLENGTH: u32 = 3800;
static ROOMLENGTH: u32 = 5000;
static ROOMDEPTH: u32 = 1000;
//static ROOMDEPTH: u32 = 2800;

use parkett::constants::{
    PLANKMAX, PLANKMIN, PLANKWIDTH, PLAY, ROOMDEPTH, ROOMLENGTH, SAWBLADE,
};
use parkett::{Floor, MaterialStorage, Row};

// How many planks are available?
// Add ability to add "used"/pre-cut planks
static AVAILABLEPLANKS: u32 = 10;

    // Create a pool of planks, modify the constant AVAILABLEPLANKS
    // to the total number of full length available planks
    let ms = MaterialStorage::default();

    // Create a pool of planks
    // To change, modify constants.rs
    let mut ms = MaterialStorage::default();
    //println!("MS: {:#?}", ms);

    let floor: Floor = Floor::default();

    // Create an empty "room", floor with no planks
    let mut floor: Floor = Floor::default();

    //println!("Material storage:\n {:#?}", ms);

    floor_build(&mut floor, &mut ms);
    //println!("Floor: {:#?}", finished_floor);

    let (finished_floor, ms) = floor_build(floor, ms);
    //println!("Floor: {:#?}", finished_floor);
    floor_print(&finished_floor);

    floor_print(&floor, &ms);

    //println!("Material storage:\n {:#?}", ms);

fn floor_print(floor: &Floor) -> () {
    let printmax = 100;

    let mut plank_count_sum = 0;

fn floor_print(floor: &Floor, ms: &MaterialStorage) -> () {
    let scalefactor = 100;

        plank_count_sum += row.planks_count();

        // Try to compensate for the extra size taken by
        // the number printout
        //let comp = 30 * row.planks_count();
        let comp = 0;

            for _ in 0..(plank.length() / printmax) / 2 {

            for _ in 0..((plank.length() - comp) / scalefactor) / 2 {

            print!("{:-^5}", plank.length());

            print!("{:-^8}", plank.length());

            for _ in 0..(plank.length() / printmax) / 2 {

            for _ in 0..((plank.length() - comp) / scalefactor) / 2 {

            print!("|");

        println!("row: {:#?}", num + 1);

        // Print the end of the row of planks
        print!("|");
        println!("\t\trow: {:#?}", num + 1);

    println!("Number of planks required: {}", plank_count_sum);

    println!(
        "Number of planks required: {}",
        ms.total_planks - ms.planks_new.len() as u32
    );

fn floor_build(mut floor: Floor, mut ms: MaterialStorage) -> (Floor, MaterialStorage) {

fn floor_build(floor: &mut Floor, mut ms: &mut MaterialStorage) -> () {

        //println!("coverage: {:#?}", floor.get_coverage());
        // TODO, deal with unwrap
        floor.add(build_row(&mut ms).unwrap());
        floor.add_coverage(PLANKWIDTH);

        match build_row(&mut ms) {
            Some(row) => {
                floor.add(row);
                floor.add_coverage(PLANKWIDTH);
            }
            None => {
                println!("Error: Unable to add more rows.\nExiting");
                return ();
            }
        }

    (floor, ms)

    //let mut plank: Plank = Default::default();

    //

        //} else {
            //println!("No more planks available!");
            //plank = None;
        //}

        // Check if the plank is too short, then take a new one

            // Check if the plank is too short, then take a new one
            ms.discard_unusable(plank);

            let newplank: Plank = Default::default();
            plank = newplank;

            plank = ms.try_get_used()?;

            // Set the leftover as the new plank
            plank = leftover;

            // Add the remaining plank to material storage
            ms.store_used(leftover);

            let newplank: Plank = Default::default();

            plank = ms.try_get_used()?;

            plank = newplank;

            let newplank: Plank = Default::default();

            plank = ms.try_get_used()?;

            plank = newplank;

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

    // Set first and last planks as endpieces
    row.set_first_and_last_as_endpieces();

    // Annotate the planks in the beginning and end as endpieces
    if let Some(plank) = row.planks_mut().first_mut() {
        plank.set_endpiece()
    }
    if let Some(plank) = row.planks_mut().last_mut() {
        plank.set_endpiece()
    }

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

/// The length of a new plank
pub static PLANKMAX: u32 = 2200;
/// The smallest allowable plank length
pub static PLANKMIN: u32 = 200;
/// Width of a plank
pub static PLANKWIDTH: u32 = 185;
/// Amount of desired play between end planks
/// and the wallss
pub static PLAY: u32 = 5;
/// Size of the sawblade, how much material is lost
pub static SAWBLADE: u32 = 10;
/// Length of the room
pub static ROOMLENGTH: u32 = 4760;
/// Depth of the room
pub static ROOMDEPTH: u32 = 2800;
/// How many planks are available?
pub static AVAILABLEPLANKS: u32 = 30;

use crate::PLANKMAX;
use crate::PLANKMIN;
use crate::SAWBLADE;
use crate::AVAILABLEPLANKS;

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

    total_planks: u32,
    planks_new: Vec<Plank>,
    planks_used: Vec<Plank>,
    planks_too_short: Vec<Plank>,

    pub total_planks: u32,
    pub planks_new: Vec<Plank>,
    pub planks_used: Vec<Plank>,
    pub planks_too_short: Vec<Plank>,

    }
    /// Store a used plank
    pub fn store_used(&mut self, plank: Plank) {
        self.planks_used.push(plank)

    /// Try get a used plank, fallback by getting a new
    pub fn try_get_used(&mut self) -> Option<Plank> {
        if let Some(plank) = self.planks_used.pop() {
            Some(plank)
        } else {
            self.planks_new.pop()
        }
    }

    }
    /// Put a too short plank aside
    pub fn discard_unusable(&mut self, plank: Plank) {
        self.planks_too_short.push(plank)

    pub fn set_first_and_last_as_endpieces(&mut self) -> () {
        // #TODO Remove unwrap
        self.planks.first_mut().unwrap().set_endpiece();
        self.planks.last_mut().unwrap().set_endpiece();
    }