extern crate integral_geometry;

extern crate land2d;

extern crate landgen;

extern crate lfprng;

extern crate png;

extern crate structopt;

use png::HasParameters;

use std::fs::File;

use std::io::BufWriter;

use std::path::Path;

use structopt::StructOpt;

use integral_geometry::{Point, Rect, Size};

use landgen::outline_template::OutlineTemplate;

use landgen::template_based::TemplatedLandGenerator;

use landgen::LandGenerationParameters;

use landgen::LandGenerator;

use lfprng::LaggedFibonacciPRNG;

#[derive(StructOpt, Debug)]

#[structopt(name = "basic")]

struct Opt {

    #[structopt(short = "s", long = "seed", default_value = "TEST_SEED")]

    seed: String,

    #[structopt(short = "d", long = "dump-before-distort")]

    dump_before_distort: bool,

    #[structopt(short = "b", long = "dump-before-bezierize")]

    dump_before_bezierize: bool,

}

fn template() -> OutlineTemplate {

    let mut template = OutlineTemplate::new(Size::new(4096, 2048));

    template.islands = vec![vec![

        Rect::new(100, 2050, 1, 1),

        Rect::new(100, 500, 400, 1200),

        Rect::new(3600, 500, 400, 1200),

        Rect::new(3900, 2050, 1, 1),

    ]];

    template.fill_points = vec![Point::new(2047, 2047)];

    template

}

fn dump(

    seed: &[u8],

    skip_distort: bool,

    skip_bezier: bool,

    file_name: &Path,

) -> std::io::Result<()> {

    let params = LandGenerationParameters::new(0 as u8, 255, 100, skip_distort, skip_bezier);

    let landgen = TemplatedLandGenerator::new(template());

    let mut prng = LaggedFibonacciPRNG::new(seed);

    let land = landgen.generate_land(&params, &mut prng);

    let file = File::create(file_name)?;

    let ref mut w = BufWriter::new(file);

    let mut encoder = png::Encoder::new(w, land.width() as u32, land.height() as u32); // Width is 2 pixels and height is 1.

    encoder

        .set(png::ColorType::Grayscale)

        .set(png::BitDepth::Eight);

    let mut writer = encoder.write_header()?;

    writer.write_image_data(land.raw_pixels()).unwrap();

    Ok(())

}

fn main() {

    let opt = Opt::from_args();

    println!("{:?}", opt);

    if opt.dump_before_distort {

        dump(

            opt.seed.as_str().as_bytes(),

            true,

            true,

            Path::new("out.before_distort.png"),

        )

        .unwrap();

    }

    if opt.dump_before_bezierize {

        dump(

            opt.seed.as_str().as_bytes(),

            false,

            true,

            Path::new("out.before_bezier.png"),

        )

        .unwrap();

    }

    dump(

        opt.seed.as_str().as_bytes(),

        false,

        true,

        Path::new("out.full.png"),

    )

    .unwrap();

}