/*
 * This file is part of sdbclient
 * Copyright (C) 2023 Jonni Liljamo <jonni@liljamo.com>
 *
 * Licensed under GPL-3.0-only.
 * See LICENSE for licensing information.
 */

use bevy::prelude::*;
use bevy_inspector_egui::bevy_egui::{egui, EguiContext};
use iyes_loopless::prelude::*;

use crate::{
    api::game::types::GameState,
    cfg::CfgUser,
    plugins::menu::MenuState,
    runtime::menu::{BrowseMenuTab, PlayMenuUIState, RTDMenu},
};

use super::{
    AllFormingEvent, CreateGameEvent, JoinGameEvent, MyGamesEvent, PlayMenuState, StartGameEvent,
};

pub(super) fn show(
    mut commands: Commands,
    mut egui_context: ResMut<EguiContext>,
    mut rtdmenu: ResMut<RTDMenu>,
    cfg_user: Res<CfgUser>,
    mut creategame_ev_w: EventWriter<CreateGameEvent>,
    mut allforming_ev_w: EventWriter<AllFormingEvent>,
    mut joingame_ev_w: EventWriter<JoinGameEvent>,
    mut mygames_ev_w: EventWriter<MyGamesEvent>,
    mut startgame_ev_w: EventWriter<StartGameEvent>,
) {
    egui::Window::new(egui::RichText::new(rtdmenu.play_menu_ui_state.display()).size(32.))
        .resizable(false)
        .collapsible(false)
        .anchor(egui::Align2::CENTER_CENTER, egui::Vec2::ZERO)
        .fixed_size(egui::Vec2::new(800., 600.))
        .show(egui_context.ctx_mut(), |ui| {
            // Override egui style for this scope.
            let mut egui_style = (*ui.style_mut()).clone();
            egui_style.text_styles = [
                (
                    egui::TextStyle::Heading,
                    egui::FontId::new(30.0, egui::FontFamily::Proportional),
                ),
                (
                    egui::TextStyle::Body,
                    egui::FontId::new(18.0, egui::FontFamily::Proportional),
                ),
                (
                    egui::TextStyle::Monospace,
                    egui::FontId::new(14.0, egui::FontFamily::Proportional),
                ),
                (
                    egui::TextStyle::Button,
                    egui::FontId::new(24.0, egui::FontFamily::Proportional),
                ),
                (
                    egui::TextStyle::Small,
                    egui::FontId::new(10.0, egui::FontFamily::Proportional),
                ),
            ]
            .into();
            ui.set_style(egui_style);

            match rtdmenu.play_menu_ui_state {
                PlayMenuUIState::Main => {
                    egui::SidePanel::left("play_side_panel")
                        .resizable(false)
                        .show_inside(ui, |ui| {
                            ui.vertical_centered(|ui| {
                                if ui.button("Create").clicked() {
                                    rtdmenu.play_menu_ui_state = PlayMenuUIState::CreateGame
                                }

                                if ui.button("Back").clicked() {
                                    commands.insert_resource(NextState(PlayMenuState::None));
                                    commands.insert_resource(NextState(MenuState::Main));
                                }
                            });
                        });

                    egui::TopBottomPanel::top("play_top_panel")
                        .resizable(false)
                        .show_inside(ui, |ui| {
                            ui.horizontal(|ui| {
                                ui.label(egui::RichText::new("Browse: ").size(24.));

                                ui.selectable_value(
                                    &mut rtdmenu.browse_tab,
                                    BrowseMenuTab::Forming,
                                    "Forming",
                                );
                                ui.selectable_value(
                                    &mut rtdmenu.browse_tab,
                                    BrowseMenuTab::InProgress,
                                    "In Progress",
                                );
                                ui.selectable_value(
                                    &mut rtdmenu.browse_tab,
                                    BrowseMenuTab::Finished,
                                    "Finished",
                                );

                                ui.with_layout(
                                    egui::Layout::right_to_left(egui::Align::Center),
                                    |ui| {
                                        if ui.button("Refresh").clicked() {
                                            match rtdmenu.browse_tab {
                                                BrowseMenuTab::Forming => {
                                                    if !rtdmenu.waiting_for_all_forming_call {
                                                        allforming_ev_w.send(AllFormingEvent);
                                                    }
                                                }
                                                BrowseMenuTab::InProgress => {
                                                    if !rtdmenu.waiting_for_my_games_call {
                                                        mygames_ev_w.send(MyGamesEvent);
                                                    }
                                                }
                                                BrowseMenuTab::Finished => {
                                                    if !rtdmenu.waiting_for_my_games_call {
                                                        mygames_ev_w.send(MyGamesEvent);
                                                    }
                                                }
                                            }
                                        }
                                    },
                                );
                            });
                        });

                    ui.vertical_centered(|ui| {
                        egui::ScrollArea::vertical().show(ui, |mut ui| match rtdmenu.browse_tab {
                            BrowseMenuTab::Forming => {
                                browse_forming(
                                    &mut ui,
                                    &mut rtdmenu,
                                    &cfg_user,
                                    &mut joingame_ev_w,
                                );
                            }
                            BrowseMenuTab::InProgress => {
                                browse_inprogress(&mut ui, &mut rtdmenu);
                            }
                            BrowseMenuTab::Finished => {
                                browse_finished(&mut ui, &mut rtdmenu);
                            }
                        });
                    });
                }
                PlayMenuUIState::CreateGame => {
                    ui.vertical_centered(|ui| {
                        ui.add_enabled_ui(!rtdmenu.waiting_for_create_game_call, |ui| {
                            if ui.button("Confirm").clicked() {
                                creategame_ev_w.send(CreateGameEvent);
                            }

                            if ui.button("Cancel").clicked() {
                                rtdmenu.play_menu_ui_state = PlayMenuUIState::Main
                            }
                        });
                    });
                }
                PlayMenuUIState::InLobbyHost => {
                    if ui.button("Start").clicked() {
                        startgame_ev_w.send(StartGameEvent);
                    }

                    if ui.button("Back").clicked() {
                        rtdmenu.play_menu_ui_state = PlayMenuUIState::Main
                    }
                }
                PlayMenuUIState::InLobbyGuest => {
                    ui.label(egui::RichText::new(format!(
                        "Host: {}",
                        rtdmenu.cur_game.as_ref().unwrap().host.username
                    )));

                    if ui.button("Back").clicked() {
                        rtdmenu.play_menu_ui_state = PlayMenuUIState::Main
                    }
                }
            }
        });
}

fn browse_forming(
    ui: &mut egui::Ui,
    rtdmenu: &mut RTDMenu,
    cfg_user: &CfgUser,
    joingame_ev_w: &mut EventWriter<JoinGameEvent>,
) {
    if rtdmenu.waiting_for_all_forming_call {
        ui.horizontal(|ui| {
            ui.spinner();
            ui.label("loading...");
        });
    } else {
        if rtdmenu.all_forming_games.is_empty() {
            ui.label("No forming games found.");
        } else {
            for game in rtdmenu.all_forming_games.clone() {
                egui::Frame::none()
                    .fill(egui::Color32::BLACK)
                    .rounding(4.)
                    .outer_margin(4.)
                    .inner_margin(4.)
                    .show(ui, |ui| {
                        ui.horizontal(|ui| {
                            ui.label(format!("Host: {}", game.host.username));
                            ui.with_layout(
                                egui::Layout::right_to_left(egui::Align::Center),
                                |ui| {
                                    if game.guest_id == cfg_user.id {
                                        ui.add_enabled(false, egui::Button::new("Joined"));
                                        if ui.button("Inspect").clicked() {
                                            rtdmenu.cur_game = Some(game.clone());
                                            rtdmenu.play_menu_ui_state =
                                                PlayMenuUIState::InLobbyGuest;
                                        }
                                    } else if game.host_id == cfg_user.id {
                                        ui.add_enabled(false, egui::Button::new("Host"));
                                        if ui.button("Inspect").clicked() {
                                            rtdmenu.cur_game = Some(game.clone());
                                            rtdmenu.play_menu_ui_state =
                                                PlayMenuUIState::InLobbyHost;
                                        }
                                    } else {
                                        if ui.button("Join").clicked() {
                                            rtdmenu.cur_game = Some(game.clone());
                                            joingame_ev_w.send(JoinGameEvent);
                                        }
                                    }
                                },
                            );
                        });
                    });
            }
        }
    }
}

fn browse_inprogress(
    ui: &mut egui::Ui,
    rtdmenu: &mut RTDMenu,
    /*resumegame_ev_w: &mut EventWriter<ResumeGameEvent>*/
) {
    if rtdmenu.waiting_for_my_games_call {
        ui.horizontal(|ui| {
            ui.spinner();
            ui.label("loading...");
        });
    } else {
        if rtdmenu.my_games.is_empty() {
            ui.label("No games found.");
        } else {
            let mut games = rtdmenu.my_games.clone();
            games.retain(|g| g.state == GameState::InProgress);

            for game in games {
                egui::Frame::none()
                    .fill(egui::Color32::BLACK)
                    .rounding(4.)
                    .outer_margin(4.)
                    .inner_margin(4.)
                    .show(ui, |ui| {
                        ui.horizontal(|ui| {
                            ui.label(format!("Host: {}", game.host.username));
                            ui.with_layout(
                                egui::Layout::right_to_left(egui::Align::Center),
                                |ui| {
                                    if ui.button("Resume").clicked() {
                                        rtdmenu.cur_game = Some(game.clone());
                                        //resumegame_ev_w.send(ResumeGameEvent);
                                    }
                                },
                            );
                        });
                    });
            }
        }
    }
}

fn browse_finished(
    ui: &mut egui::Ui,
    rtdmenu: &mut RTDMenu,
    /*resumegame_ev_w: &mut EventWriter<ResumeGameEvent>*/
) {
    if rtdmenu.waiting_for_my_games_call {
        ui.horizontal(|ui| {
            ui.spinner();
            ui.label("loading...");
        });
    } else {
        if rtdmenu.my_games.is_empty() {
            ui.label("No games found.");
        } else {
            let mut games = rtdmenu.my_games.clone();
            games.retain(|g| g.state == GameState::Finished);

            for game in games {
                egui::Frame::none()
                    .fill(egui::Color32::BLACK)
                    .rounding(4.)
                    .outer_margin(4.)
                    .inner_margin(4.)
                    .show(ui, |ui| {
                        ui.horizontal(|ui| {
                            ui.label(format!("Host: {}", game.host.username));
                        });
                    });
            }
        }
    }
}