use png::HasParameters;

use std::{

    fs::File,

    io::{BufWriter, Read},

};

use structopt::StructOpt;

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

use landgen::{

};

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,

    #[structopt(short = "f", long = "distance-divisor", default_value = "100")]

    distance_divisor: u32,

    #[structopt(short = "i", long = "templates-file")]

    templates_file: Option<String>,

    #[structopt(short = "t", long = "template-type")]

    template_type: Option<String>,

    #[structopt(short = "z", long = "theme-dir")]

}

fn template() -> OutlineTemplate {

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

    template.islands = vec![vec![

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

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

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

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

    ]];

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

    template

}

fn dump(

    template: &OutlineTemplate,

    seed: &[u8],

    distance_divisor: u32,

    skip_distort: bool,

    skip_bezier: bool,

    file_name: &Path,

) -> std::io::Result<Land2D<u8>> {

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

    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(land)

}

fn texturize(theme_dir: &Path, land: &Land2D<u8>, output_filename: &Path) {

    let theme = Theme::load(theme_dir).unwrap();

    let texture = MapGenerator::new().make_texture(land, &theme);

    let file = File::create(output_filename).unwrap();

    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.

    let mut writer = encoder.write_header().unwrap();

}

fn main() {

    let opt = Opt::from_args();

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

    if opt.dump_before_distort {

        dump(

            &template,

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

            opt.distance_divisor,

            true,

            true,

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

        )

        .unwrap();

    }

    if opt.dump_before_bezierize {

        dump(

            &template,

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

            opt.distance_divisor,

            false,

            true,

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

        )

        .unwrap();

    }

    let land = dump(

        &template,

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

        opt.distance_divisor,

        false,

        false,

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

    )

    .unwrap();

    if let Some(dir) = opt.theme_dir {

    }

}