use super::error::TimedOperatorError;
use crate::trace::Trace;
use crate::{Formula, Metric};

pub struct Next<P> {
    phi: P,
}

impl<P> Next<P> {
    pub fn new(phi: P) -> Next<P> {
        Next { phi }
    }
}

impl<T, P> Formula<Trace<T>> for Next<P>
where
    P: Formula<Trace<T>>,
{
    type Error = TimedOperatorError<P::Error>;

    fn satisfied_by(&self, trace: &Trace<T>) -> Result<bool, Self::Error> {
        if trace.len() < 1 {
            return Err(TimedOperatorError::EmptyTrace);
        }

        let second_time = trace.times().nth(1);
        let future_trace = second_time.and_then(|time| trace.clone().split_at(time));

        match future_trace {
            Some(future) => self
                .phi
                .satisfied_by(&future)
                .map_err(TimedOperatorError::SubformulaError),
            None => Ok(false),
        }
    }
}

impl<T, P> Metric<Trace<T>> for Next<P>
where
    P: Metric<Trace<T>>,
{
    type Error = TimedOperatorError<P::Error>;

    fn distance(&self, trace: &Trace<T>) -> Result<f64, Self::Error> {
        if trace.len() < 1 {
            return Err(TimedOperatorError::EmptyTrace);
        }

        let second_time = trace.times().nth(1);
        let future_trace = second_time.and_then(|time| trace.clone().split_at(time));

        match future_trace {
            Some(future) => self.phi.distance(&future).map_err(TimedOperatorError::SubformulaError),
            None => Ok(f64::NEG_INFINITY),
        }
    }
}