use crate::{
    domain::Message,
    responses::{ApplicationError, ApplicationResponse, BaseError},
};
use tokio::sync::{
    mpsc::{channel, error::TryRecvError, Receiver, Sender},
    RwLock,
};

use crate::domain::Command;
use std::{
    any::{Any, TypeId},
    collections::HashMap,
    pin::Pin,
    sync::Arc,
};

pub type Future<T, E> = Pin<Box<dyn futures::Future<Output = Result<T, E>> + Send>>;
pub type TEventHandler<T, R, E> =
    HashMap<String, Vec<Box<dyn Fn(Box<dyn Message>, T) -> Future<R, E> + Send + Sync>>>;
pub type TCommandHandler<T, R, E> =
    HashMap<TypeId, Box<dyn Fn(Box<dyn Any + Send + Sync>, T) -> Future<R, E> + Send + Sync>>;

pub type AtomicContextManager = Arc<RwLock<ContextManager>>;

/// Task Local Context Manager
/// This is called for every time Messagebus.handle is invoked within which it manages events raised in service.
/// It spawns out Executor that manages transaction.
pub struct ContextManager {
    pub sender: Sender<Box<dyn Message>>,
}

impl ContextManager {
    /// Creation of context manager returns context manager AND event receiver
    pub fn new() -> (Arc<RwLock<Self>>, Receiver<Box<dyn Message>>) {
        let (sender, receiver) = channel(20);
        (Arc::new(RwLock::new(Self { sender })), receiver)
    }
}
pub struct MessageBus<
    R: ApplicationResponse,
    E: ApplicationError + std::convert::From<crate::responses::BaseError>,
> {
    command_handler: &'static TCommandHandler<AtomicContextManager, R, E>,
    event_handler: &'static TEventHandler<AtomicContextManager, R, E>,
}

impl<
        R: ApplicationResponse,
        E: ApplicationError + std::convert::From<crate::responses::BaseError>,
    > MessageBus<R, E>
{
    pub fn new(
        command_handler: &'static TCommandHandler<AtomicContextManager, R, E>,
        event_handler: &'static TEventHandler<AtomicContextManager, R, E>,
    ) -> Arc<Self> {
        Self {
            command_handler,
            event_handler,
        }
        .into()
    }

    pub async fn handle<C>(&self, message: C) -> Result<R, E>
    where
        C: Command,
    {
        let (context_manager, mut event_receiver) = ContextManager::new();

        let res = self
            .command_handler
            .get(&message.type_id())
            .ok_or_else(|| {
                eprintln!("Unprocessable Command Given!");
                BaseError::CommandNotFound
            })?(Box::new(message), context_manager.clone())
        .await?;

        'event_handling_loop: loop {
            // * use of try_recv is to stop blocking it when all events are drained.

            match event_receiver.try_recv() {
                // * Logging!
                Ok(msg) => {
                    println!("BreakPoint on OK");
                    if let Err(err) = self.handle_event(msg, context_manager.clone()).await {
                        // ! Safety:: BaseError Must Be Enforced To Be Accepted As Variant On ServiceError
                        if let "EventNotFound" = err.to_string().as_str() {
                            continue;
                        }
                    }
                }
                Err(TryRecvError::Empty) => {
                    println!("BreakPoint on Empty");
                    if Arc::strong_count(&context_manager) == 1 {
                        break 'event_handling_loop;
                    } else {
                        continue;
                    }
                }
                Err(TryRecvError::Disconnected) => {
                    println!("BreakPoint on Disconnected");
                    break 'event_handling_loop;
                }
            };
        }
        drop(context_manager);
        Ok(res)
    }

    async fn handle_event(
        &self,
        msg: Box<dyn Message>,
        context_manager: AtomicContextManager,
    ) -> Result<(), E> {
        // ! msg.topic() returns the name of event. It is crucial that it corresponds to the key registered on Event Handler.

        let handlers = self
            .event_handler
            .get(&msg.metadata().topic)
            .ok_or_else(|| {
                eprintln!("Unprocessable Event Given! {:?}", msg);
                BaseError::EventNotFound
            })?;

        for handler in handlers.iter() {
            match handler(msg.message_clone(), context_manager.clone()).await {
                Ok(_val) => {
                    println!("Event Handling Succeeded!");
                }

                // ! Safety:: BaseError Must Be Enforced To Be Accepted As Variant On ServiceError
                Err(err) => match err.to_string().as_str() {
                    "StopSentinel" => {
                        eprintln!("Stop Sentinel Arrived!");
                        break;
                    }
                    _ => {
                        eprintln!("Error Occurred While Handling Event! Error:{}", err);
                    }
                },
            };
        }
        drop(context_manager);
        Ok(())
    }
}

/// init_command_handler creating macro
#[macro_export]
macro_rules! init_command_handler {
    (
        {$($command:ty:$handler:expr $(=>($($injectable:ident),*))? ),* $(,)?}
    )
        => {
        pub async fn init_command_handler() -> HashMap::<TypeId,Box<dyn Fn(Box<dyn Any + Send + Sync>, AtomicContextManager) -> Future<ServiceResponse,ServiceError> + Send + Sync>>{
            let _dependency= dependency();

            let mut _map: HashMap::<_,Box<dyn Fn(_, _ ) -> Future<_,_> + Send + Sync>> = HashMap::new();
            $(
                _map.insert(
                    // ! Only one command per one handler is acceptable, so the later insertion override preceding one.
                    TypeId::of::<$command>(),
                    Box::new(
                        |c:Box<dyn Any+Send+Sync>, context_manager: AtomicContextManager|->Future<ServiceResponse,ServiceError>{
                            // * Convert event so event handler accepts not Box<dyn Message> but `event_happend` type of message.
                            // ! Logically, as it's from TypId of command, it doesn't make to cause an error.
                            Box::pin($handler(
                                *c.downcast::<$command>().unwrap(),
                                context_manager,
                            $(
                                // * Injectable functions are added here.
                                $(dependency.$injectable(),)*
                            )?
                          ))
                        },
                    )
                );
            )*
            _map
        }
    };
}

/// init_event_handler creating macro
#[macro_export]
macro_rules! init_event_handler {
    (
        {$($event:ty: [$($handler:expr $(=>($($injectable:ident),*))? ),* $(,)? ]),* $(,)?}
    ) =>{
        pub async fn init_event_handler() -> HashMap<String, Vec<Box<dyn Fn(Box<dyn Message>, AtomicContextManager) -> Future<ServiceResponse,ServiceError> + Send + Sync>>>{
            let dependency= dependency();
            let mut _map : HashMap<String, Vec<Box<dyn Fn(_, _) -> Future<_,_> + Send + Sync>>> = HashMap::new();
            $(
                _map.insert(
                    stringify!($event).into(),
                    vec![
                        $(
                            Box::new(
                                |e:Box<dyn Message>, context_manager:AtomicContextManager| -> Future<ServiceResponse,ServiceError>{
                                    Box::pin($handler(
                                        // * Convert event so event handler accepts not Box<dyn Message> but `event_happend` type of message.
                                        // Safety:: client should access this vector of handlers by providing the corresponding event name
                                        // So, when it is followed, it logically doesn't make sense to cause an error.
                                        *e.downcast::<$event>().expect("Not Convertible!"), context_manager,
                                    $(
                                        // * Injectable functions are added here.
                                        $(dependency.$injectable(),)*
                                    )?
                                    ))
                                }
                                ),
                        )*
                    ]
                );
            )*
            _map
        }
    };
}