/*
    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 super::{background::MenuBackground, credits::CreditsMenu, settings::SettingsMenu};
use crate::{
    game::Game,
    network::Network,
    render::{sprite::SpriteDraw, AtlasLayout, Renderer},
    ui::UiState,
    State,
};
use hurrycurry_protocol::glam::Vec2;
use sdl2::{
    keyboard::{KeyboardState, Keycode},
    mouse::MouseState,
};

pub struct MainMenu {
    background: MenuBackground,
    fade_in: f32,
    pub ui_state: UiState,
    server_address: String,
    next_state: Option<Box<State>>,
    settings: Option<SettingsMenu>,
    credits: Option<CreditsMenu>,
}

impl MainMenu {
    pub fn new(layout: &AtlasLayout) -> Self {
        Self {
            background: MenuBackground::new(layout),
            fade_in: 0.,
            server_address: String::from("ws://127.0.0.1"),
            ui_state: UiState::default(),
            next_state: None,
            settings: None,
            credits: 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.ui_state.update(keyboard, mouse, dt);
        self.background.tick(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) {
        self.background.draw(ctx);

        self.ui_state.draw(ctx, |ui| {
            if let Some(settings) = &mut self.settings {
                if settings.draw(ui) {
                    self.settings = None;
                }
                return;
            }
            if let Some(credits) = &mut self.credits {
                if credits.draw(ui) {
                    self.credits = None;
                }
                return;
            }
            if ui.button(80., "Join") {
                self.next_state = Some(Box::new(State::Ingame(Box::new(Game::new(
                    Network::connect(&self.server_address).unwrap(),
                    ui.renderer.atlas_layout(),
                )))))
            }
            ui.textedit(80., &mut self.server_address);
            if ui.button(80., "Settings") {
                self.settings = Some(SettingsMenu::default())
            }
            if ui.button(80., "Credits") {
                self.credits = Some(CreditsMenu::default())
            }
            if ui.button(80., "Quit") {
                self.next_state = Some(Box::new(State::Quit));
            }
            ui.fill();
        });

        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]),
        ));
    }
}