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

use bevy::{
    prelude::*,
    tasks::{AsyncComputeTaskPool, Task},
};
use bevy_console::PrintConsoleLine;

use futures_lite::future;

use crate::{
    api::{
        self,
        user::{ResponseRegister, ResponseToken},
    },
    cfg::{self, CfgDirs, CfgHidden, CfgUser},
    util,
};

use super::MenuState;

pub mod ui;

pub struct AccountRegisterPlugin;

impl Plugin for AccountRegisterPlugin {
    fn build(&self, app: &mut App) {
        app.add_state(RegisterState::None)
            // UI system
            .insert_resource(ui::InputsUserRegister::new())
            .add_system_set(
                SystemSet::on_update(RegisterState::Input).with_system(ui::account_register_ui),
            )
            // Register system, as in calling the API
            .add_system_set(
                SystemSet::on_enter(RegisterState::Registering).with_system(start_register_call),
            )
            .add_system_set(
                SystemSet::on_update(RegisterState::Registering).with_system(handle_register_call),
            );
    }
}

/// Register State
#[derive(Clone, Eq, PartialEq, Debug, Hash)]
pub enum RegisterState {
    None,
    Input,
    Registering,
}

struct RegisterCallResponse {
    register: ResponseRegister,
    token: ResponseToken,
}

#[derive(Component)]
struct RegisterCall(Task<RegisterCallResponse>);

fn start_register_call(
    mut commands: Commands,
    cfg_hidden: Res<CfgHidden>,
    inputs: Res<ui::InputsUserRegister>,
) {
    let api_address = cfg_hidden.api_server.clone();
    let i = inputs.clone();

    let thread_pool = AsyncComputeTaskPool::get();
    let task = thread_pool.spawn(async move {
        let register_response = api::user::register(
            api_address.clone(),
            i.username.clone(),
            i.email.clone(),
            i.password.clone(),
        );

        // TODO: This is bad, if the above fails, this will too. Or maybe that doesn't matter?
        let token_response =
            api::user::token(api_address.clone(), i.email.clone(), i.password.clone());

        RegisterCallResponse {
            register: register_response,
            token: token_response,
        }
    });
    commands.spawn(RegisterCall(task));
}

fn handle_register_call(
    mut commands: Commands,
    mut register_call_tasks: Query<(Entity, &mut RegisterCall)>,
    mut inputs: ResMut<ui::InputsUserRegister>,
    mut register_state: ResMut<State<RegisterState>>,
    mut menu_state: ResMut<State<MenuState>>,
    mut cfg_user: ResMut<CfgUser>,
    cfg_dirs: Res<CfgDirs>,
    mut console: EventWriter<PrintConsoleLine>,
) {
    let (entity, mut task) = register_call_tasks.single_mut();
    if let Some(register_call_response) = future::block_on(future::poll_once(&mut task.0)) {
        match register_call_response.register {
            ResponseRegister::Valid(register_res) => {
                console.send(PrintConsoleLine::new(format!(
                    "Registered user: {}",
                    register_res.username,
                )));

                match register_call_response.token {
                    ResponseToken::Valid(token_res) => {
                        *cfg_user = CfgUser {
                            logged_in: true,
                            user_token: token_res.token,
                            id: register_res.id,
                            username: register_res.username,
                            email: register_res.email,
                        };

                        util::sl::save(
                            cfg_dirs.0.config_dir().to_str().unwrap(),
                            cfg::FILE_CFG_USER,
                            &cfg_user.into_inner(),
                            console,
                        );
                    }
                    ResponseToken::Error { error } => {
                        // TODO: Handle? Is it possible to even get here without the server shitting itself between the register and token calls?
                        // And if the server does indeed shit itself between those calls, the user can just login normally, so 🤷‍♀️
                        console.send(PrintConsoleLine::new(format!(
                            "Something went wrong with getting the user token after registering, got error: '{}'", error
                        )));
                    }
                }

                register_state.set(RegisterState::None).unwrap();
                menu_state.set(MenuState::AccountLoggedIn).unwrap();
            }
            ResponseRegister::Error { error } => {
                inputs.error = error;
                register_state.set(RegisterState::Input).unwrap();
            }
        }

        // Remove the task, since it's done now
        commands.entity(entity).remove::<RegisterCall>();
        commands.entity(entity).despawn_recursive();
    }
}