/*
 * 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 laurelin_shared::types::game::{GAMESTATE_FINISHED, GAMESTATE_INPROGRESS};

use crate::{
    cfg::CfgUser,
    plugins::{
        menu::MenuState,
        networking::send::game::{GameAllFormingEvent, GameCreateEvent, GameMyGamesEvent},
    },
    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>,
    mut creategame_ev_w: EventWriter<GameCreateEvent>,
    mut allforming_ev_w: EventWriter<GameAllFormingEvent>,
    mut mygames_ev_w: EventWriter<GameMyGamesEvent>,
) {
    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 !data.waiting_for_all_forming {
                                                    allforming_ev_w.send(GameAllFormingEvent);
                                                }
                                            }
                                            PlayScreenBrowseState::InProgress => {
                                                if !data.waiting_for_my_games {
                                                    mygames_ev_w.send(GameMyGamesEvent);
                                                }
                                            }
                                            PlayScreenBrowseState::Finished => {
                                                if !data.waiting_for_my_games {
                                                    mygames_ev_w.send(GameMyGamesEvent);
                                                }
                                            }
                                        }
                                    }
                                },
                            );
                        });
                    });

                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(!data.waiting_for_create_game, |ui| {
                        if ui.button("Confirm").clicked() {
                            data.waiting_for_create_game = true;
                            creategame_ev_w.send(GameCreateEvent);
                        }

                        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, data: &mut PlayScreenData, cfg_user: &CfgUser) {
    if data.waiting_for_all_forming {
        ui.horizontal(|ui| {
            ui.spinner();
            ui.label("loading...");
        });
    } else {
        if data.all_forming.is_empty() {
            ui.label("No forming games found.");
        } else {
            for game in data.all_forming.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.label("Host: host-username-here");
                            ui.with_layout(
                                egui::Layout::right_to_left(egui::Align::Center),
                                |ui| {
                                    if game.guest_id.clone().unwrap_or_default().to_string()
                                        == cfg_user.id
                                    {
                                        ui.add_enabled(false, egui::Button::new("Joined"));
                                        if ui.button("Inspect").clicked() {
                                            data.cur_game = Some(game.clone());
                                            data.state = PlayScreenState::InLobbyGuest;
                                        }
                                    } else if game.host_id.to_string() == cfg_user.id {
                                        ui.add_enabled(false, egui::Button::new("Host"));
                                        if ui.button("Inspect").clicked() {
                                            data.cur_game = Some(game.clone());
                                            data.state = PlayScreenState::InLobbyHost;
                                        }
                                    } else {
                                        if ui.button("Join").clicked() {
                                            //data.cur_game = Some(game.clone());
                                            //joingame_ev_w.send(JoinGameEvent);
                                        }
                                    }
                                },
                            );
                        });
                    });
            }
        }
    }
}

fn browse_inprogress(ui: &mut egui::Ui, data: &mut PlayScreenData) {
    if data.waiting_for_my_games {
        ui.horizontal(|ui| {
            ui.spinner();
            ui.label("loading...");
        });
    } else {
        if data.my_games.is_empty() {
            ui.label("No games found.");
        } else {
            let mut games = data.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.label("Host: host-username-here");
                            ui.with_layout(
                                egui::Layout::right_to_left(egui::Align::Center),
                                |ui| {
                                    if ui.button("Resume").clicked() {
                                        data.cur_game = Some(game.clone());
                                        //resumegame_ev_w.send(ResumeGameEvent);
                                    }
                                },
                            );
                        });
                    });
            }
        }
    }
}

fn browse_finished(ui: &mut egui::Ui, data: &mut PlayScreenData) {
    if data.waiting_for_my_games {
        ui.horizontal(|ui| {
            ui.spinner();
            ui.label("loading...");
        });
    } else {
        if data.my_games.is_empty() {
            ui.label("No games found.");
        } else {
            let mut games = data.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("Host: host-username-here");
                            //ui.label(format!("Host: {}", game.host.username));
                        });
                    });
            }
        }
    }
}