#![allow(dead_code)]
#![allow(unused_must_use)]

use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::hash::Hash;
use crate::task_pool::{TaskEntity,TaskPoolType,Task};
use async_trait::async_trait;
use crate::context::Context;
use crate::obj_pool::ObjectManage;

//------------------------------------配置文件--------------------------------------------

pub struct EConfig{
    pub task_pool_type:TaskPoolType, //事件任务池类型
    pub task_pool_cache:usize,        //事件缓存大小
    pub obj_cache:usize,            //对象池缓存
}

impl Default for EConfig{
    fn default()->Self{
        EConfig{
            task_pool_cache:1024,
            task_pool_type:TaskPoolType::Default,
            obj_cache:1024,
        }
    }
}

//-----------------------------------任务池相关--------------------------------------------
/// 任务对象
struct Tasker{
    pub arc_event:Arc<Eventer>,
    pub ctx:Arc<Context>,
}
impl  Tasker{
    fn new(e:Arc<Eventer>,ctx:Arc<Context>)->Tasker{
        Tasker{
            arc_event:e,
            ctx:ctx,
        }
    }
    fn set(&mut self,e:Arc<Eventer>,ctx:Arc<Context>){
        self.arc_event = e;
        self.ctx = ctx;
    }
}
impl Default for Tasker{
    fn default()->Self{
        Tasker{
            arc_event:Arc::new(Eventer::new_nil()),
            ctx:Arc::new(Context::new_null()),
        }
    }
}

#[async_trait]
impl Task for Tasker{
    async fn handle(&self){
        if let EType::Async = self.arc_event.etype{
            Eventer::allocate_async(self.arc_event.event_async.clone(),self.ctx.clone()).await;
        }else {
            self.arc_event.allocate(self.ctx.clone());
        }
    }
}

//-----------------------------------事件相关--------------------------------------------
pub trait Event{
    fn handle_mut(&mut self,ctx:Arc<Context>){}
    fn handle(&self,ctx:Arc<Context>){}
}

#[async_trait]
pub trait AsyncEvent : Sync {
    async fn handle(&self,ctx:Arc<Context>);
}

pub enum EType{
    /// 默认执行handle方法
    Default,
    /// 会执行handle_mut方法
    Mutable,
    /// 异步方法回调,add方法无效,add_sync 方法默认调用
    Async,
}

struct Eventer{
    event:Option<Arc<RwLock<dyn Event + Sync + Send+'static>>>,
    event_async:Option<Arc<dyn Send + AsyncEvent>>,
    etype:EType
}

unsafe impl Sync for Eventer{}

impl Eventer{
    fn new_nil()->Self{
        Eventer{
            event:None,
            event_async:None,
            etype:EType::Default,
        }
    }
    fn new(event:Arc<RwLock<dyn Event + Sync+Send>>,etype:EType)->Eventer{
        Eventer{
            event:Some(event),
            event_async:None,
            etype:etype,
        }
    }
    fn new_async(event:Arc<dyn Send + AsyncEvent>,etype:EType)->Eventer{
        Eventer{
            event:None,
            event_async:Some(event),
            etype:etype,
        }
    }
    /// 根据策略执行
    fn allocate(&self,ctx:Arc<Context>){
        match self.etype {
            EType::Mutable=>{
                if let Some(e)= &self.event{
                    if let Ok(mut wevent) = e.write(){
                        wevent.handle_mut(ctx)
                    }
                }
            }
            EType::Default=>{
                match &self.event {
                    Some(e)=>{
                        if let Ok(revent) = e.read(){
                            revent.handle(ctx)
                        }
                    }
                    None=>{}
                }
            }
            EType::Async=>{
                match &self.event_async {
                    Some(s)=>{
                        let a =s.clone();
                        //let mut object = s as Arc<dyn AsyncEvent>;
                        tokio::spawn(async move{
                            a.handle(ctx).await;
                        });
                    }
                    None=>{}
                }
            }
        }
    }
    async fn allocate_async(event:Option<Arc<dyn Send + AsyncEvent>>,ctx:Arc<Context>){
        if let Some(e) = event{
            e.handle(ctx).await;
        }
    }
}

//-----------------------------------事件发生器--------------------------------------------
pub struct EventManage<K:Eq + Hash>{
    events:Arc<RwLock<HashMap<K,Vec<Arc<Eventer>>>>>,
    tasks:TaskEntity,
    tasker_pool:ObjectManage<Tasker>,
}

impl<K> EventManage<K>
    where K:Eq + Hash,
{
    /// 在非async函数中创建
    pub fn new(conf:EConfig) -> EventManage<K>{
        let em = EventManage{
            events:Arc::new(RwLock::new(HashMap::new())),
            tasks: TaskEntity::new(conf.task_pool_type,conf.task_pool_cache),
            tasker_pool:ObjectManage::new(conf.obj_cache),
        };
        em.tasks.init();
        em
    }

    /// 异步创建
    pub async fn new_async(conf:EConfig) -> EventManage<K>{
        let em = EventManage{
            events:Arc::new(RwLock::new(HashMap::new())),
            tasks: TaskEntity::new(conf.task_pool_type,conf.task_pool_cache),
            tasker_pool:ObjectManage::new(conf.obj_cache),
        };
        em.tasks.init_task_pool().await;
        em
    }

    pub fn add<E:Event + Sync + Send + 'static>(&self, key:K, event:E,etype:EType) ->Result<(),String>{
        let mut eventw = match self.events.write(){
            Err(e)=>{return Err(e.to_string());}
            Ok(o)=>{o}
        };
        let arc_event = Arc::new(Eventer::new(Arc::new(RwLock::new(event)),etype));
        if let Some(s)  = eventw.get_mut(&key){
            s.push(arc_event)
        }else{
            eventw.insert(key, vec![arc_event]);
        }
        Ok(())
    }

    pub fn add_async<E:AsyncEvent +Send+ 'static>(&self, key:K, event:E) ->Result<(),String>{
        let mut eventw = match self.events.write(){
            Err(e)=>{return Err(e.to_string());}
            Ok(o)=>{o}
        };
        let etype = EType::Async;
        let arc_event = Arc::new(Eventer::new_async(Arc::new(event),etype));
        if let Some(s)  = eventw.get_mut(&key){
            s.push(arc_event)
        }else{
            eventw.insert(key, vec![arc_event]);
        }
        Ok(())
    }

    pub fn remove(&self, key:K) ->Result<(),String>{
        let mut eventw = match self.events.write(){
            Err(e)=>{return Err(e.to_string());}
            Ok(o)=>{o}
        };
        eventw.remove(&key);
        Ok(())
    }

    pub fn clear(&self) ->Result<(),String>{
        let mut eventw = match self.events.write(){
            Err(e)=>{return Err(e.to_string());}
            Ok(o)=>{o}
        };
        eventw.clear();
        Ok(())
    }

    /// 按顺序执行，先注册的先执行，后注册的后执行。
    /// 同一时间一个注册方法只会有一个线程调用。
    /// 顺序执行事件，会受到上线文状态影响，失败状态则不再执行后去内容
    pub fn exec_sequence(&self, key:&K,ctx:Option<Context>) ->Result<(),String>
    {
        let eventr = match self.events.read(){
            Err(e)=>{return Err(e.to_string());}
            Ok(o)=>{o}
        };
        let events = if let Some(s) = eventr.get(key){s}else{
            return Ok(());
        };
        let ctx = match ctx {
            Some(s)=>{Arc::new(s)}
            None=>{Arc::new(Context::new_null())}
        };
        for eventi in events.iter(){
            if !ctx.get_status(){
                break;
            }
            eventi.allocate(ctx.clone());
        }
        Ok(())
    }

    /// 按顺序执行异步方法，先注册的先执行，后注册的后执行。
    /// 同一时间一个注册方法只会有一个线程调用。
    /// 顺序执行事件，会受到上线文状态影响，失败状态则不再执行后去内容
    /// 该方法在spawn中执行无法通过编译
    pub async fn exec_sequence_async(&self, key:&K,ctx:Option<Context>) ->Result<(),String>
    {
        let eventr = match self.events.read(){
            Err(e)=>{return Err(e.to_string());}
            Ok(o)=>{o}
        };
        let events = if let Some(s) = eventr.get(key){s}else{
            return Ok(());
        };
        let ctx = match ctx {
            Some(s)=>{Arc::new(s)}
            None=>{Arc::new(Context::new_null())}
        };
        for eventi in events.iter(){
            let arc_event = Arc::clone(eventi);
            let arc_ctx = ctx.clone();
            if let EType::Async = arc_event.etype{
                Eventer::allocate_async(eventi.event_async.clone(),arc_ctx).await;
                // tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
            }else {
                arc_event.allocate(arc_ctx);
            }
        }
        Ok(())
    }

    /// 加入到任务池中执行,支持多种任务池
    pub fn exec_pool(&self, key:&K ,ctx:Option<Context>)
    {
        let eventr = match self.events.read(){
            Err(e)=>{return;}
            Ok(o)=>{o}
        };
        let events = if let Some(s) = eventr.get(key){s}else{
            return ;
        };
        let ctx = match ctx {
            Some(s)=>{Arc::new(s)}
            None=>{Arc::new(Context::new_null())}
        };
        for eventi in events.iter(){
            let arc_event = Arc::clone(eventi);
            let mut tasker = self.tasker_pool.get();
            tasker.set(arc_event,ctx.clone());
            self.tasks.run( Arc::new(tasker));
        }
    }

    /// 立即进行异步执行,速度更快,开启任务的开销较小
    pub async fn exec_immediately(&self, key:&K,ctx:Option<Context>)
    {
        let eventr = match self.events.read(){
            Err(e)=>{return ;}
            Ok(o)=>{o}
        };
        let events = if let Some(s) = eventr.get(key){s}else{
            return ;
        };
        let ctx = match ctx {
            Some(s)=>{Arc::new(s)}
            None=>{Arc::new(Context::new_null())}
        };
        for eventi in events.iter(){
            let arc_event = Arc::clone(eventi);
            let arc_ctx = ctx.clone();
            tokio::spawn(async move{
                if let EType::Async = arc_event.etype{
                    Eventer::allocate_async(arc_event.event_async.clone(),arc_ctx).await;
                }else {
                   arc_event.allocate(arc_ctx);
                }
            });
        }
    }

    pub fn delay_exec<E:Event + Sync + Send + 'static>(&self, mut event:E,ctx:Context)
    {
        let arc_ctx = Arc::new(ctx);
        tokio::spawn(async move{
            loop {
                tokio::time::sleep(arc_ctx.get_delay()).await;
                event.handle_mut(arc_ctx.clone());
                if !arc_ctx.get_status(){
                    break;
                }
            }
        });
    }
    pub fn delay_exec_async<E:AsyncEvent +Send+ 'static>(&self,event:E,ctx:Context)
    {
        let arc_ctx = Arc::new(ctx);
        tokio::spawn(async move{
            loop {
                tokio::time::sleep(arc_ctx.get_delay()).await;
                event.handle(arc_ctx.clone()).await;
                if !arc_ctx.get_status(){
                    break;
                }
            }
        });
    }
}