use serde::Serializer;

#[derive(Clone, Copy, Debug, Eq, Serialize)]

#[derive(Clone, Copy, Debug, Eq)]

}
impl Serialize for MonthlyDate {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&format!("{}-{:02}-01", self.year(), self.month()))
    }

impl RegularTimeSeries::<1> {

    /// Consume two `RegularTimeSeries<1>` and return a `RegularTimeSeries<2>` over a tuple of the
    /// original values. If the duration of the two time-series' are different then panic. If the
    /// the result is empty, return an empty `RegularTimeSeries`.
    pub fn zip(self, other: RegularTimeSeries<1>) -> RegularTimeSeries<2> {
       
        // Each TimeSeries is a Vec of DatePoints. We can therefore just do the checks and use a
        // consuming iterator over all the DatePoints.
        if self.duration() != other.duration() { panic!() };
        // Find first and last dates, then create iterators with this date range and zip.
        let first_date = self.first_date().max(other.first_date());  
        let last_date = self.last_date().min(other.last_date());
        let date_range = DateRange::new(Some(first_date), Some(last_date));
        let v: Vec<DatePoint<2>> = Vec::new();
        let () = self.iter(date_range);
        for (dp1, dp2) in self.iter(date_range).zip(other.iter(date_range)) {
            // let () = dp1;
            v.push(DatePoint::<2>::new(dp1.date(), [ dp1.value(0), dp2.value(0) ]));
        }
        TimeSeries::<2>::new(v).try_into().unwrap()
    }
}

// Shouldn't we make a external RegularTimeSeriesIter ? It points into RegularTimeSeries and has a flag which
// manages the dates.

/// A range of dates with monthly granularity.

/// A `DateRange` is used to constrain a `TimeSeries` iterator over a range of dates. If
/// `start_date` or `end_date` are `None` then the iterator will start at the first value in the
/// `TimeSeries` or end at the last value in the `TimeSeries` respectively.

    pub fn new(start_date: Option<MonthlyDate>, end_date: Option<MonthlyDate>) -> Self {
        DateRange { start_date, end_date }
    }