/*
 * 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 crate::{
    api::game::Game,
    game_status::GameStatus,
    plugins::{game::GameData, FinishedRefreshGameEvent},
};

use bevy::{
    prelude::*,
    tasks::{AsyncComputeTaskPool, Task},
};
use futures_lite::future;

use super::GameEndCallEvent;

#[derive(Component)]
pub struct ParseGameStatus(Task<GameStatus>);

#[derive(Clone)]
pub struct ParseGameStatusEvent {
    pub game: Game,
}

pub fn start_call(mut commands: Commands, mut start_ev_r: EventReader<ParseGameStatusEvent>) {
    for ev in start_ev_r.iter() {
        let thread_pool = AsyncComputeTaskPool::get();
        let ev = ev.clone();
        let task = thread_pool.spawn(async move { GameStatus::new(&ev.game) });
        commands.spawn(ParseGameStatus(task));
    }
}

pub fn handle_call(
    mut commands: Commands,
    mut tasks: Query<(Entity, &mut ParseGameStatus)>,
    mut game_data: ResMut<GameData>,
    mut eg_ev_w: EventWriter<GameEndCallEvent>,
    mut frg_ev_w: EventWriter<FinishedRefreshGameEvent>,
) {
    if let Ok((entity, mut task)) = tasks.get_single_mut() {
        if let Some(response) = future::block_on(future::poll_once(&mut task.0)) {
            game_data.game_status = Some(response);
            game_data.locked = false;

            // NOTE: checking for end conditions
            let mut empty_piles = 0;
            for pile in &game_data.game_status.as_ref().unwrap().supply_piles {
                if pile.amount == 0 {
                    empty_piles += 1;
                }
            }
            if empty_piles >= 2 {
                // end me daddy
                eg_ev_w.send(GameEndCallEvent {
                    game_id: game_data.game.as_ref().unwrap().id.clone(),
                });
            } else {
                // dont end me daddy
                frg_ev_w.send(FinishedRefreshGameEvent);
            }

            // remove the task
            commands.entity(entity).remove::<ParseGameStatus>();
            commands.entity(entity).despawn_recursive();
        }
    }
}