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

use bevy::prelude::*;
use bevy_egui::{egui, EguiContexts};

use crate::{cfg::CfgUser, plugins::menu::MenuState, util::egui::menuwindow};

use super::{PlayScreenBrowseState, PlayScreenData, PlayScreenState};

pub fn ui(
    mut commands: Commands,
    mut egui_contexts: EguiContexts,
    mut data: ResMut<PlayScreenData>,
    cfg_user: Res<CfgUser>,
) {
    menuwindow(
        egui_contexts.ctx_mut(),
        data.state.clone().display(),
        &egui::Vec2::new(800., 600.),
        |ui| match data.state {
            PlayScreenState::Main => {
                egui::SidePanel::left("play_side_panel")
                    .resizable(false)
                    .show_inside(ui, |ui| {
                        ui.vertical_centered(|ui| {
                            if ui.button("Create").clicked() {
                                data.state = PlayScreenState::CreateGame;
                            }

                            if ui.button("Back").clicked() {
                                commands.insert_resource(NextState(Some(MenuState::Menu)));
                            }
                        });
                    });

                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 data.browse_state,
                                PlayScreenBrowseState::Forming,
                                "Forming",
                            );
                            ui.selectable_value(
                                &mut data.browse_state,
                                PlayScreenBrowseState::InProgress,
                                "In Progress",
                            );
                            ui.selectable_value(
                                &mut data.browse_state,
                                PlayScreenBrowseState::Finished,
                                "Finished",
                            );

                            ui.with_layout(
                                egui::Layout::right_to_left(egui::Align::Center),
                                |ui| {
                                    if ui.button("Refresh").clicked() {
                                        match data.browse_state {
                                            PlayScreenBrowseState::Forming => {
                                                //if !rtdmenu.waiting_for_all_forming_call {
                                                //    allforming_ev_w.send(AllFormingEvent);
                                                //}
                                            }
                                            PlayScreenBrowseState::InProgress => {
                                                //if !rtdmenu.waiting_for_my_games_call {
                                                //    mygames_ev_w.send(MyGamesEvent);
                                                //}
                                            }
                                            PlayScreenBrowseState::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 data.browse_state {
                        PlayScreenBrowseState::Forming => {
                            browse_forming(&mut ui, &mut data, &cfg_user);
                        }
                        PlayScreenBrowseState::InProgress => {
                            browse_inprogress(&mut ui, &mut data);
                        }
                        PlayScreenBrowseState::Finished => {
                            browse_finished(&mut ui, &mut data);
                        }
                    });
                });
            }
            PlayScreenState::CreateGame => {
                ui.vertical_centered(|ui| {
                    ui.add_enabled_ui(
                        /* !rtdmenu.waiting_for_create_game_call */ false,
                        |ui| {
                            if ui.button("Confirm").clicked() {
                                //creategame_ev_w.send(CreateGameEvent);
                            }

                            if ui.button("Cancel").clicked() {
                                data.state = PlayScreenState::Main;
                            }
                        },
                    );
                });
            }
            PlayScreenState::InLobbyHost => {
                if ui.button("Start").clicked() {
                    //startgame_ev_w.send(StartGameEvent);
                }

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

                if ui.button("Back").clicked() {
                    data.state = PlayScreenState::Main;
                }
            }
        },
    );
}

fn browse_forming(ui: &mut egui::Ui, rtdmenu: &mut PlayScreenData, cfg_user: &CfgUser) {
    /*
    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 PlayScreenData) {
    /*
    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 PlayScreenData) {
    /*
    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));
                        });
                    });
            }
        }
    }
    */
}