extern crate wasm_bindgen;
extern crate argus;
extern crate serde_json;
extern crate js_sys;
extern crate serde;
extern crate serde_wasm_bindgen;

use wasm_bindgen::prelude::*;

use argus::expr::{Expr};
use argus::{Trace, Signal, AnySignal, BooleanSemantics};
use argus::signals::interpolation;
use std::collections::HashMap;
use std::vec;
use serde::{Serialize, Deserialize};
use serde_wasm_bindgen::{from_value, to_value};
use std::time::Duration;

// #[wasm_bindgen]
// pub struct WrappedExpr {
//     expr: Expr,
// }

// #[wasm_bindgen]
// pub fn parse_str(s: &str) -> WrappedExpr {
//     let expr = argus::parse_str(s);
//     return WrappedExpr{
//         expr: expr.expect("fuck!!!!"),
//     };
// }

struct TraceMap<'a> {
    events: HashMap<&'a str, Signal<bool>>,
}

impl<'a> Trace for TraceMap<'a> {
    fn signal_names(&self) -> Vec<&str> {
        self.events.keys().cloned().collect()
    }

    fn get<T: 'static>(&self, name: &str) -> Option<&Signal<T>> {
        let sig: &dyn AnySignal = match self.events.get(name) {
            Some(signal) => signal,
            None => return None,
        };
        sig.as_any().downcast_ref::<Signal<T>>()
    }
}



// type MyTrace = Vec<TraceItem>
// struct MyResult {
//     ok: ,
// }

// pub struct DefaultFalse;

// use argus::signals::{InterpolationMethod, Sample};

// use argus::core::utils::Neighborhood;

// impl InterpolationMethod<bool> for DefaultFalse {
//     fn at(a: &super::Sample<bool>, b: &super::Sample<bool>, time: std::time::Duration) -> Option<bool> {
//         if time == a.time {
//             Some(a.value)
//         }
//         else if time == b.time {
//             Some(b.value)
//         }
//         else {
//             Some(false)
//         }
//     }

//     fn find_intersection(_a: &Neighborhood<bool>, _b: &Neighborhood<bool>) -> Option<Sample<bool>> {
//         None
//     }
// }

#[derive(Serialize, Deserialize)]
pub struct StateBuddyTraceEntry {
    simtime: f64,
    inputEvent: String,
    outputEvents: Vec<String>,
}

#[derive(Serialize, Deserialize)]
pub struct StateBuddyTrace {
    entries: Vec<StateBuddyTraceEntry>,
}

// #[wasm_bindgen]
// impl StateBuddyTrace {
//     #[wasm_bindgen(constructor)]
//     pub fn new(entries: &Vec<StateBuddyTraceEntry>) {
//         StateBuddyTrace{entries}
//     }
// }


#[wasm_bindgen]
pub fn eval_boolean(s: &str, js_trace: JsValue) -> JsValue {
    let trace: StateBuddyTrace = from_value(js_trace).expect("fuuuuck");
    let mut traceMap = HashMap::<&str, Signal<bool>>::new();
    for entry in &trace.entries {
        let value = traceMap.entry(entry.inputEvent.as_str()).or_insert_with(|| Signal::<bool>::Sampled {
            values: vec![],
            time_points: vec![],
        });
        if let Signal::<bool>::Sampled { values, time_points } = value {
            values.push(true);
            time_points.push(Duration::from_millis(entry.simtime as u64));
        }
        else {
            panic!("fuck!!!");
        }
    }

    let parse_result = argus::parse_str(s);
    let expr = parse_result.expect("fuuuckk!!");
    let eval_result = match expr {
        Expr::Bool(bool_expr) => BooleanSemantics::eval::<interpolation::Constant>(&bool_expr, &TraceMap{events: traceMap}),
        _ => panic!("fuuuck"),
    };
    let mut result = Vec::<StateBuddyEvalResultEntry>::new();
    eval_result.expect("fuuuck").iter().for_each(|(timestamp, satisfied), | {
        result.push(StateBuddyEvalResultEntry{
            timestamp: timestamp.as_millis() as f64,
            satisfied: *satisfied,
        });
    });
    to_value(&StateBuddyEvalResult { entries: result }).expect("fuuuck")
}

#[derive(Serialize, Deserialize)]
pub struct StateBuddyEvalResultEntry {
    timestamp: f64,
    satisfied: bool,
}

#[derive(Serialize, Deserialize)]
pub struct StateBuddyEvalResult {
    entries: Vec<StateBuddyEvalResultEntry>,
}