/*
    Hurry Curry! - a game about cooking
    Copyright 2024 metamuffin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, version 3 of the License only.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/
use super::EntityT;
use crate::game::Game;
use hurrycurry_protocol::PacketC;
use rand::random;
use serde::{Deserialize, Serialize};
use std::{
    collections::VecDeque,
    time::{Duration, Instant},
};

#[derive(Clone, Debug, Deserialize, Serialize, Default)]
pub struct EnvironmentEffect {
    name: String,
    #[serde(default = "default_onoff")]
    on: f32,
    #[serde(default = "default_onoff")]
    off: f32,
}
fn default_onoff() -> f32 {
    40.
}

#[derive(Clone, Debug)]
pub struct EnvironmentEffectController {
    config: EnvironmentEffect,
    next_transition: Instant,
    active: bool,
}

impl EnvironmentEffectController {
    pub fn new(config: EnvironmentEffect) -> Self {
        Self {
            next_transition: Instant::now() + Duration::from_secs_f32(config.on),
            active: false,
            config,
        }
    }
}
impl EntityT for EnvironmentEffectController {
    fn tick(
        &mut self,
        game: &mut Game,
        packet_out: &mut VecDeque<PacketC>,
        _dt: f32,
    ) -> anyhow::Result<()> {
        if self.next_transition < Instant::now() {
            if self.active {
                self.next_transition +=
                    Duration::from_secs_f32(self.config.on + (0.5 + random::<f32>()));
                self.active = false;
                game.environment_effects.remove(&self.config.name);
            } else {
                self.next_transition +=
                    Duration::from_secs_f32(self.config.off * (0.5 + random::<f32>()));
                self.active = true;
                game.environment_effects.insert(self.config.name.clone());
            }
            packet_out.push_back(PacketC::Environment {
                effects: game.environment_effects.clone(),
            })
        }
        Ok(())
    }
}

#[derive(Debug, Clone)]
pub struct EnvironmentController(pub Vec<String>);
impl EntityT for EnvironmentController {
    fn tick(
        &mut self,
        game: &mut Game,
        packet_out: &mut VecDeque<PacketC>,
        _dt: f32,
    ) -> anyhow::Result<()> {
        if game.environment_effects.is_empty() {
            game.environment_effects.extend(self.0.clone());
            packet_out.push_back(PacketC::Environment {
                effects: game.environment_effects.clone(),
            })
        }
        Ok(())
    }
}