use crate::{
    column::ColumnSample,
    util::{RandomField, Sampler},
    sim::SimChunk,
    Index,
};
use common::{
    assets,
    comp,
    lottery::Lottery,
    terrain::{Block, BlockKind},
    vol::{BaseVol, ReadVol, RectSizedVol, Vox, WriteVol},
    generation::{ChunkSupplement, EntityInfo},
};
use noise::NoiseFn;
use std::{
    f32,
    ops::{Mul, Sub},
};
use vek::*;
use rand::prelude::*;

fn close(x: f32, tgt: f32, falloff: f32) -> f32 { (1.0 - (x - tgt).abs() / falloff).max(0.0).powf(0.5) }

pub fn apply_scatter_to<'a>(
    wpos2d: Vec2<i32>,
    mut get_column: impl FnMut(Vec2<i32>) -> Option<&'a ColumnSample<'a>>,
    vol: &mut (impl BaseVol<Vox = Block> + RectSizedVol + ReadVol + WriteVol),
    index: &Index,
    chunk: &SimChunk,
) {
    use BlockKind::*;
    let scatter: &[(_, fn(&SimChunk) -> (f32, Option<(f32, f32)>))] = &[
        // (density, Option<(wavelen, threshold)>)
        (BlueFlower, |c| (close(c.temp, -0.3, 0.7).min(close(c.humidity, 0.6, 0.35)) * 0.05, Some((48.0, 0.6)))),
        (PinkFlower, |c| (close(c.temp, 0.15, 0.5).min(close(c.humidity, 0.6, 0.35)) * 0.05, Some((48.0, 0.6)))),
        (DeadBush, |c| (close(c.temp, 0.8, 0.3).min(close(c.humidity, 0.0, 0.4)) * 0.015, None)),
        (Twigs, |c| ((c.tree_density - 0.5).max(0.0) * 0.0025, None)),
        (Stones, |c| ((c.rockiness - 0.5).max(0.0) * 0.005, None)),
    ];

    for y in 0..vol.size_xy().y as i32 {
        for x in 0..vol.size_xy().x as i32 {
            let offs = Vec2::new(x, y);

            let wpos2d = wpos2d + offs;

            // Sample terrain
            let col_sample = if let Some(col_sample) = get_column(offs) {
                col_sample
            } else {
                continue;
            };

            let bk = scatter
                .iter()
                .enumerate()
                .find_map(|(i, (bk, f))| {
                    let (density, patch) = f(chunk);
                    if density <= 0.0 || patch.map(|(wavelen, threshold)| index
                        .noise
                        .scatter_nz
                        .get(wpos2d.map(|e| e as f64 / wavelen as f64 + i as f64 * 43.0).into_array()) < threshold as f64)
                        .unwrap_or(false)
                        || !RandomField::new(i as u32).chance(Vec3::new(wpos2d.x, wpos2d.y, 0), density)
                    {
                        None
                    } else {
                        Some(*bk)
                    }
                });

            if let Some(bk) = bk {
                let mut z = col_sample.alt as i32 - 4;
                for _ in 0..8 {
                    if vol.get(Vec3::new(offs.x, offs.y, z)).map(|b| !b.is_solid()).unwrap_or(true) {
                        let _ = vol.set(Vec3::new(offs.x, offs.y, z), Block::new(bk, Rgb::broadcast(0)));
                        break;
                    }
                    z += 1;
                }
            }
        }
    }
}

pub fn apply_paths_to<'a>(
    wpos2d: Vec2<i32>,
    mut get_column: impl FnMut(Vec2<i32>) -> Option<&'a ColumnSample<'a>>,
    vol: &mut (impl BaseVol<Vox = Block> + RectSizedVol + ReadVol + WriteVol),
    index: &Index,
) {
    for y in 0..vol.size_xy().y as i32 {
        for x in 0..vol.size_xy().x as i32 {
            let offs = Vec2::new(x, y);

            let wpos2d = wpos2d + offs;

            // Sample terrain
            let col_sample = if let Some(col_sample) = get_column(offs) {
                col_sample
            } else {
                continue;
            };
            let surface_z = col_sample.riverless_alt.floor() as i32;

            let noisy_color = |col: Rgb<u8>, factor: u32| {
                let nz = RandomField::new(0).get(Vec3::new(wpos2d.x, wpos2d.y, surface_z));
                col.map(|e| {
                    (e as u32 + nz % (factor * 2))
                        .saturating_sub(factor)
                        .min(255) as u8
                })
            };

            if let Some((path_dist, path_nearest, path, _)) = col_sample
                .path
                .filter(|(dist, _, path, _)| *dist < path.width)
            {
                let inset = 0;

                // Try to use the column at the centre of the path for sampling to make them
                // flatter
                let col_pos = (offs - wpos2d).map(|e| e as f32) + path_nearest;
                let col00 = get_column(col_pos.map(|e| e.floor() as i32) + Vec2::new(0, 0));
                let col10 = get_column(col_pos.map(|e| e.floor() as i32) + Vec2::new(1, 0));
                let col01 = get_column(col_pos.map(|e| e.floor() as i32) + Vec2::new(0, 1));
                let col11 = get_column(col_pos.map(|e| e.floor() as i32) + Vec2::new(1, 1));
                let col_attr = |col: &ColumnSample| {
                    Vec3::new(col.riverless_alt, col.alt, col.water_dist.unwrap_or(1000.0))
                };
                let [riverless_alt, alt, water_dist] = match (col00, col10, col01, col11) {
                    (Some(col00), Some(col10), Some(col01), Some(col11)) => Lerp::lerp(
                        Lerp::lerp(col_attr(col00), col_attr(col10), path_nearest.x.fract()),
                        Lerp::lerp(col_attr(col01), col_attr(col11), path_nearest.x.fract()),
                        path_nearest.y.fract(),
                    ),
                    _ => col_attr(col_sample),
                }
                .into_array();
                let (bridge_offset, depth) = (
                    ((water_dist.max(0.0) * 0.2).min(f32::consts::PI).cos() + 1.0) * 5.0,
                    ((1.0 - ((water_dist + 2.0) * 0.3).min(0.0).cos().abs())
                        * (riverless_alt + 5.0 - alt).max(0.0)
                        * 1.75
                        + 3.0) as i32,
                );
                let surface_z = (riverless_alt + bridge_offset).floor() as i32;

                for z in inset - depth..inset {
                    let _ = vol.set(
                        Vec3::new(offs.x, offs.y, surface_z + z),
                        if bridge_offset >= 2.0 && path_dist >= 3.0 || z < inset - 1 {
                            Block::new(BlockKind::Normal, noisy_color(Rgb::new(80, 80, 100), 8))
                        } else {
                            let path_color = path.surface_color(
                                col_sample.sub_surface_color.map(|e| (e * 255.0) as u8),
                            );
                            Block::new(BlockKind::Normal, noisy_color(path_color, 8))
                        },
                    );
                }
                let head_space = path.head_space(path_dist);
                for z in inset..inset + head_space {
                    let pos = Vec3::new(offs.x, offs.y, surface_z + z);
                    if vol.get(pos).unwrap().kind() != BlockKind::Water {
                        let _ = vol.set(pos, Block::empty());
                    }
                }
            }
        }
    }
}

pub fn apply_caves_to<'a>(
    wpos2d: Vec2<i32>,
    mut get_column: impl FnMut(Vec2<i32>) -> Option<&'a ColumnSample<'a>>,
    vol: &mut (impl BaseVol<Vox = Block> + RectSizedVol + ReadVol + WriteVol),
    index: &Index,
) {
    for y in 0..vol.size_xy().y as i32 {
        for x in 0..vol.size_xy().x as i32 {
            let offs = Vec2::new(x, y);

            let wpos2d = wpos2d + offs;

            // Sample terrain
            let col_sample = if let Some(col_sample) = get_column(offs) {
                col_sample
            } else {
                continue;
            };
            let surface_z = col_sample.riverless_alt.floor() as i32;

            if let Some((cave_dist, cave_nearest, cave, _)) = col_sample
                .cave
                .filter(|(dist, _, cave, _)| *dist < cave.width)
            {
                let cave_x = (cave_dist / cave.width).min(1.0);

                // Relative units
                let cave_floor = 0.0 - 0.5 * (1.0 - cave_x.powf(2.0)).max(0.0).sqrt() * cave.width;
                let cave_height = (1.0 - cave_x.powf(2.0)).max(0.0).sqrt() * cave.width;

                // Abs units
                let cave_base = (cave.alt + cave_floor) as i32;
                let cave_roof = (cave.alt + cave_height) as i32;

                for z in cave_base..cave_roof {
                    if cave_x < 0.95
                        || index.noise.cave_nz.get(
                            Vec3::new(wpos2d.x, wpos2d.y, z)
                                .map(|e| e as f64 * 0.15)
                                .into_array(),
                        ) < 0.0
                    {
                        let _ = vol.set(Vec3::new(offs.x, offs.y, z), Block::empty());
                    }
                }

                // Stalagtites
                let stalagtites = index
                    .noise
                    .cave_nz
                    .get(wpos2d.map(|e| e as f64 * 0.125).into_array())
                    .sub(0.5)
                    .max(0.0)
                    .mul(
                        (col_sample.alt - cave_roof as f32 - 5.0)
                            .mul(0.15)
                            .clamped(0.0, 1.0) as f64,
                    )
                    .mul(45.0) as i32;

                for z in cave_roof - stalagtites..cave_roof {
                    let _ = vol.set(
                        Vec3::new(offs.x, offs.y, z),
                        Block::new(BlockKind::Rock, Rgb::broadcast(200)),
                    );
                }

                // Scatter things in caves
                if RandomField::new(index.seed).chance(wpos2d.into(), 0.001)
                    && cave_base < surface_z as i32 - 25
                {
                    let kind = *assets::load_expect::<Lottery<BlockKind>>("common.cave_scatter")
                        .choose_seeded(RandomField::new(index.seed + 1).get(wpos2d.into()));
                    let _ = vol.set(
                        Vec3::new(offs.x, offs.y, cave_base),
                        Block::new(kind, Rgb::zero()),
                    );
                }
            }
        }
    }
}

pub fn apply_caves_supplement<'a>(
    rng: &mut impl Rng,
    wpos2d: Vec2<i32>,
    mut get_column: impl FnMut(Vec2<i32>) -> Option<&'a ColumnSample<'a>>,
    vol: &(impl BaseVol<Vox = Block> + RectSizedVol + ReadVol + WriteVol),
    index: &Index,
    supplement: &mut ChunkSupplement,
) {
    for y in 0..vol.size_xy().y as i32 {
        for x in 0..vol.size_xy().x as i32 {
            let offs = Vec2::new(x, y);

            let wpos2d = wpos2d + offs;

            // Sample terrain
            let col_sample = if let Some(col_sample) = get_column(offs) {
                col_sample
            } else {
                continue;
            };
            let surface_z = col_sample.riverless_alt.floor() as i32;

            if let Some((cave_dist, cave_nearest, cave, _)) = col_sample
                .cave
                .filter(|(dist, _, cave, _)| *dist < cave.width)
            {
                let cave_x = (cave_dist / cave.width).min(1.0);

                // Relative units
                let cave_floor = 0.0 - 0.5 * (1.0 - cave_x.powf(2.0)).max(0.0).sqrt() * cave.width;
                let cave_height = (1.0 - cave_x.powf(2.0)).max(0.0).sqrt() * cave.width;

                // Abs units
                let cave_base = (cave.alt + cave_floor) as i32;
                let cave_roof = (cave.alt + cave_height) as i32;

                // Scatter things in caves
                if RandomField::new(index.seed).chance(wpos2d.into(), 0.00005)
                    && cave_base < surface_z as i32 - 40
                {
                    let entity = EntityInfo::at(Vec3::new(wpos2d.x as f32, wpos2d.y as f32, cave_base as f32))
                        .with_alignment(comp::Alignment::Enemy)
                        .with_body(match rng.gen_range(0, 6) {
                            0 => {
                                let species = match rng.gen_range(0, 2) {
                                    0 => comp::quadruped_small::Species::Truffler,
                                    _ => comp::quadruped_small::Species::Hyena,
                                };
                                comp::quadruped_small::Body::random_with(rng, &species).into()
                            },
                            1 => {
                                let species = match rng.gen_range(0, 3) {
                                    0 => comp::quadruped_medium::Species::Tarasque,
                                    1 => comp::quadruped_medium::Species::Frostfang,
                                    _ => comp::quadruped_medium::Species::Bonerattler,
                                };
                                comp::quadruped_medium::Body::random_with(rng, &species).into()
                            },
                            2 => {
                                let species = match rng.gen_range(0, 3) {
                                    0 => comp::quadruped_low::Species::Maneater,
                                    1 => comp::quadruped_low::Species::Rocksnapper,
                                    _ => comp::quadruped_low::Species::Salamander,
                                };
                                comp::quadruped_low::Body::random_with(rng, &species).into()
                            },
                            3 => {
                                let species = match rng.gen_range(0, 3) {
                                    0 => comp::critter::Species::Fungome,
                                    1 => comp::critter::Species::Axolotl,
                                    _ => comp::critter::Species::Rat,
                                };
                                comp::critter::Body::random_with(rng, &species).into()
                            },
                            4 => {
                                let species = match rng.gen_range(0, 1) {
                                    _ => comp::golem::Species::StoneGolem,
                                };
                                comp::golem::Body::random_with(rng, &species).into()
                            },
                            _ => {
                                let species = match rng.gen_range(0, 4) {
                                    0 => comp::biped_large::Species::Ogre,
                                    1 => comp::biped_large::Species::Cyclops,
                                    2 => comp::biped_large::Species::Wendigo,
                                    _ => comp::biped_large::Species::Troll,
                                };
                                comp::biped_large::Body::random_with(rng, &species).into()
                            },
                        })
                        .with_automatic_name();

                    supplement.add_entity(entity);
                }
            }
        }
    }
}