rs-eda 0.1.5

use serde_json::Value;
use std::collections::HashMap;

pub struct Event {
    name: String,        // 事件名
    data: Option<Value>, // 数据使用Value格式
}
impl Event {
    pub fn new(name: &str, data: Option<Value>) -> Self {
        Self {
            name: name.to_string(),
            data,
        }
    }
}

type EventListener = fn(Option<Value>);
type ListenersMap = HashMap<String, Vec<EventListener>>;

pub struct EventDispatcher {
    listeners: ListenersMap,
}
impl EventDispatcher {
    pub fn new() -> Self {
        Self {
            listeners: HashMap::new(),
        }
    }
    /**

     * @description: 获取事件列表
     * @author: tgy3300
     * @Date: 2025-03-29 12:20:36
     * @param {*} self
     * @return {*}
     */
    pub fn get_listeners(&self) -> &ListenersMap {
        &self.listeners
    }
    /**

     * @description: 订阅事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:20:08
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @return {*}
     */
    pub fn add_event_listener(&mut self, name: &str, listener: EventListener) {
        let arr = self
            .listeners
            .entry(name.to_string())
            .or_insert_with(Vec::new);

        let func = &(listener);
        if !arr.contains(func) {
            arr.push(listener);
        }
    }
    /**

     * @description: 判断事件名下指定事件方法是否存在
     * @author: tgy3300
     * @Date: 2025-03-29 12:19:38
     * @param {*} name
     * @param {EventListener} listener
     * @return {*}
     */
    pub fn has_event_listener(&self, name: &str, listener: EventListener) -> bool {
        if let Some(listeners) = self.listeners.get(name) {
            let func = &(listener);
            return listeners.contains(func);
        }
        false
    }
    /**

     * @description: 判断事件是否存在
     * @author: tgy3300
     * @Date: 2025-03-29 12:19:11
     * @param {*} name
     * @return {*}
     */
    pub fn has_event(&self, name: &str) -> bool {
        if let Some(_) = self.listeners.get(name) {
            true
        } else {
            false
        }
    }
    /**

     * @description: 移除事件下指定事件方法(包括该事件对应的节流事件和防抖事件)
     * @author: tgy3300
     * @Date: 2025-03-29 12:17:39
     * @param {*} name 事件名
     * @param {EventListener} listener 事件方法
     * @return {*}
     */
    pub fn remove_event_listener(&mut self, name: &str, listener: EventListener) {
        if let Some(arr) = self.listeners.get_mut(name) {
            // 删除节流事件
            // 删除防抖事件

            // 通过指针地址对比，过滤掉传入的事件
            arr.retain(|x| format!("{:?}", x) != format!("{:?}", &(listener)));
        }
    }
    /**

     * @description: 移除事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:17:00
     * @param {*} name 事件名
     * @return {*}
     */
    pub fn remove_event(&mut self, name: &str) {
        if self.listeners.contains_key(name) {
            self.listeners.remove(name);
        }
    }
    /**

     * @description: 触发事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:15:47
     * @param {Event} event 事件数据
     * @return {*}
     */
    pub fn dispatch_event(&self, event: Event) {
        if let Some(listeners) = self.listeners.get(&event.name) {
            for listener in listeners {
                listener(event.data.clone());
            }
        }
    }
    /**

     * @description: 一次性触发，触发之后会自动移除，再次触发无效果
     * @author: tgy3300
     * @Date: 2025-03-29 12:13:34
     * @param {*} self
     * @param {*} _name
     * @param {Option} _listener
     * @return {*}
     */
    pub fn once(&self, _name: &str, _listener: EventListener) {}
    /**

     * @description: 触发事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:13:05
     * @param {*} name 事件名
     * @param {Option} params 事件参数
     * @return {*}
     */
    pub fn emit(&self, name: &str, params: Option<Value>) {
        self.dispatch_event(Event::new(name, params))
    }
    /**

     * @description: 订阅事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:12:40
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @return {*}
     */
    pub fn on(&mut self, name: &str, listener: EventListener) {
        self.add_event_listener(name, listener);
    }
    /**

     * @description: 判断事件名、事件名下指定事件方法是否存在，通过listener区分判断
     * @author: tgy3300
     * @Date: 2025-03-29 12:10:06
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @return {*}
     */
    pub fn has(&self, name: &str, listener: Option<EventListener>) -> bool {
        if let Some(x) = listener {
            self.has_event_listener(name, x)
        } else {
            self.has_event(name)
        }
    }
    /**

     * @description: 移除事件，如果不传listener就会移除整个name事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:09:22
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @return {*}
     */
    pub fn off(&mut self, name: &str, listener: Option<EventListener>) {
        if let Some(func) = listener {
            self.remove_event_listener(name, func);
        } else {
            self.remove_event(name);
        }
    }
    /**

     * @description: 获取该事件类型下的事件数量
     * @author: tgy3300
     * @Date: 2025-03-29 12:06:55
     * @param {*} name 事件名
     * @return {*}
     */
    pub fn event_count(&self, name: &str) -> usize {
        if let Some(x) = self.listeners.get(name) {
            x.len()
        } else {
            0
        }
    }
    /**

     * @description: 销毁该类型的最后一个事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:05:38
     * @param {*} name 事件名
     * @return {*}
     */
    pub fn pop_latest_event(&mut self, name: &str) -> bool {
        if let Some(arr) = self.listeners.get_mut(name) {
            if let Some(_) = arr.pop() {
                return true;
            }
        }
        false
    }
    /**

     * @description: 清空所有事件类型的事件
     * @author: tgy3300
     * @Date: 2025-03-29 12:05:14
     * @return {*}
     */
    pub fn clear(&mut self) {
        self.listeners.clear();
    }
    /**

     * @description: 当前派发器是否使用
     * @author: tgy3300
     * @Date: 2025-03-29 12:04:43
     * @return {*}
     */
    pub fn useful(&self) -> bool {
        self.listeners.keys().len() > 0
    }
    /**

     * @description: 节流触发
     * @author: tgy3300
     * @Date: 2025-03-29 12:06:04
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @param {u64} time 节流时间
     * @return {*}
     */
    pub fn on_throttle(&self, _name: &str, _listener: EventListener, _time: u64) {}
    /**

     * @description: 防抖触发
     * @author: tgy3300
     * @Date: 2025-03-29 12:06:23
     * @param {*} name 事件名
     * @param {Option} listener 事件方法
     * @param {u64} time 防抖时间
     * @return {*}
     */
    pub fn on_anti_shake(&self, _name: &str, _listener: EventListener, _time: u64) {}
}