use std::{collections::HashMap, sync::Arc};

use common::{BulbPrefs, Param};
use lighter_lib::BulbId;
use lighter_manager::manager::BulbManager;
use std::sync::Mutex;

use crate::util::DeadMansHandle;

use super::LightScript;

pub struct Auto {
    state: Arc<Mutex<AutoState>>,
    _task_handle: DeadMansHandle,
}

struct AutoState {
    manager: BulbManager,
    enabled_bulbs: HashMap<BulbId, AutoBulbState>,
}

#[derive(Default)]
struct AutoBulbState {}

impl LightScript for Auto {
    fn get_params(&mut self, bulb: &BulbId) -> BulbPrefs {
        let state = self.state.lock().unwrap();
        let enabled = state.enabled_bulbs.contains_key(bulb);

        BulbPrefs {
            kvs: [("Auto".to_string(), Param::Toggle(enabled))]
                .into_iter()
                .collect(),
        }
    }

    fn set_param(&mut self, bulb: &BulbId, name: &str, param: Param) {
        if name != "Auto" {
            error!("invalid param name");
            return;
        }

        let Param::Toggle(enabled) = param else {
            error!("invalid param kind");
            return;
        };

        let mut state = self.state.lock().unwrap();
        if !enabled {
            state.enabled_bulbs.remove(bulb);
        } else {
            let bulb_state = AutoBulbState::default();
            state.enabled_bulbs.insert(bulb.clone(), bulb_state);
        }
    }
}

async fn auto_task(state: Arc<Mutex<AutoState>>) {
    loop {}
}