use std::collections::HashMap;
use std::future::Future;

use tokio::task::JoinHandle;

use crate::BoxError;

enum SignalKind {
    ClosePosition,
    OpenPosition,
}

struct EventMetadata {
    position_id: Option<u64>,
    order_id: Option<u64>,
}

#[derive(PartialEq, Eq, Hash)]
enum EventKind {
    NewMinimum,
    NewMaximum,
    ReachedLoss,
    ReachedBreakEven,
    ReachedMinProfit,
    ReachedGoodProfit,
    ReachedMaxLoss,
    TrailingStopSet,
    TrailingStopMoved,
    OrderSubmitted,
    NewTick,
}

pub struct Event {
    kind: EventKind,
    tick: u64,
    metadata: Option<EventMetadata>,
}

impl Event {
    pub fn new(kind: EventKind, tick: u64, metadata: Option<EventMetadata>) -> Self {
        Event {
            kind,
            tick,
            metadata,
        }
    }

    fn has_metadata(&self) -> bool {
        self.metadata.is_some()
    }
}

pub struct EventDispatcher {
    event_handlers: HashMap<EventKind, Box<dyn Fn(String) -> JoinHandle<()>>>
}

impl EventDispatcher {
    pub fn new() -> Self {
        EventDispatcher {
            event_handlers: HashMap::new()
        }
    }

    pub fn call_handler(&self, event: &EventKind) {
        self.event_handlers.iter()
            .filter(|(e, _)| e == event)
            .map(|(_, f)| f("test".into()));
    }

    pub fn register_event_handler<F: 'static, Fut: 'static>(&mut self, event: EventKind, f: F)
        where
            F: Fn(String) -> Fut,
            Fut: Future<Output=()> + Send,
    {
        self.event_handlers.insert(event, Box::new(move |args| tokio::spawn(f(args))));
    }
}