/*
    Hurry Curry! - a game about cooking
    Copyright 2024 metamuffin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, version 3 of the License only.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/
use crate::{
    game::Game,
    network::Network,
    render::{sprite::SpriteDraw, AtlasLayout, Renderer},
    tilemap::Tilemap,
    ui::UiState,
    State,
};
use hurrycurry_protocol::{
    glam::{IVec2, Vec2},
    TileIndex,
};
use rand::{random, seq::IndexedRandom, thread_rng};
use sdl2::{
    keyboard::{KeyboardState, Keycode},
    mouse::MouseState,
};

pub struct Menu {
    map: Tilemap,
    fade_in: f32,
    ui_state: UiState,
    background: Vec2,
    next_state: Option<Box<State>>,
}

impl Menu {
    pub fn new(layout: &AtlasLayout) -> Self {
        let mut map = Tilemap::default();
        map.init(
            &[
                "floor",
                "tomato-crate",
                "raw-steak-crate",
                "table",
                "chair",
                "counter",
                "sink",
                "stove",
            ]
            .map(String::from),
            layout,
        );
        static BUCKETS: &[&[usize]] = &[&[], &[0, 0, 0, 0, 1, 2], &[3, 4, 5], &[6, 7]];

        for x in -10..11 {
            for y in -10..11 {
                let p = Vec2::new(x as f32, y as f32);
                let w = (-p.length() * 0.15).exp();
                let k = ((random::<f32>() * w) * BUCKETS.len() as f32) as usize;
                if let Some(ti) = BUCKETS[k.min(BUCKETS.len())].choose(&mut thread_rng()) {
                    map.set(IVec2::new(x, y), Some(TileIndex(*ti)), [None; 4])
                }
            }
        }

        Self {
            map,
            fade_in: 0.,
            ui_state: UiState::default(),
            background: Vec2::ZERO,
            next_state: None,
        }
    }
    pub fn tick(
        &mut self,
        dt: f32,
        keyboard: &KeyboardState,
        mouse: &MouseState,
        _layout: &AtlasLayout,
    ) -> Option<Box<State>> {
        self.fade_in = (self.fade_in + dt).min(1.);
        self.background += Vec2::new(2., 3.) * dt;
        self.ui_state.update(keyboard, mouse, dt);

        self.next_state.take()
    }
    pub fn keyboard_event(&mut self, keycode: Keycode, down: bool) {
        self.ui_state.keyboard_event(keycode, down);
    }
    pub fn draw(&mut self, ctx: &mut Renderer) {
        ctx.set_world_view(
            ctx.size / ctx.get_world_scale() * Vec2::new(0.8, 0.2),
            ctx.size.max_element() / 32. / 15.,
        );

        for x in -1..=2 {
            for y in -1..=2 {
                ctx.draw_ui(SpriteDraw::underlay(
                    ctx.misc_textures.clouds,
                    Vec2::new(x as f32, y as f32) * 256. + self.background,
                    Vec2::ONE * 256.,
                    None,
                ));
            }
        }
        ctx.draw_ui(SpriteDraw::underlay(
            ctx.misc_textures.solid,
            Vec2::ZERO,
            ctx.ui_size,
            Some([0, 0, 0, 50]),
        ));

        self.map.draw(ctx);

        let mut request_join = false;
        self.ui_state.draw(ctx, |ui| {
            if ui.button(80., "Join") {
                request_join = true
            }
            if ui.button(80., "Settings") {
                eprintln!("settings button")
            }
            if ui.button(80., "Quit") {
                self.next_state = Some(Box::new(State::Quit));
            }
            ui.fill();
        });
        if request_join {
            self.next_state = Some(Box::new(State::Ingame(Box::new(Game::new(
                Network::connect("ws://127.0.0.1").unwrap(),
                ctx.atlas_layout(),
            )))))
        }

        ctx.draw_ui(SpriteDraw::overlay(
            ctx.misc_textures.solid,
            Vec2::ZERO,
            ctx.ui_size,
            Some([0, 0, 0, 255 - (self.fade_in * 255.) as u8]),
        ));
    }
}