use super::search::Street;
use regex::Regex;
use rocket::http::RawStr;
use rocket::request::FromFormValue;
use serde::ser::{Serialize, SerializeStruct, Serializer};
use std::error::Error;

const BASE_URL: &str = "https://www.ivago.be/nl/particulier/afval/ophaling";

/// Represents a very simple Timezoneless date. Considering the timezone will
/// always be CEST (aka Belgium's timezone), this is good enough.
pub struct BasicDate {
    year: u32,
    month: u8,
    day: u8,
}

impl<'v> FromFormValue<'v> for BasicDate {
    type Error = &'v RawStr;

    fn from_form_value(form_value: &'v RawStr) -> Result<BasicDate, Self::Error> {
        // Beautiful how  this exact example is in the docs
        let re = Regex::new(r"^(\d{4})-(\d{2})-(\d{2})$").unwrap();
        match re.captures(form_value) {
            None => Err(form_value),
            // Here, we can assume these parses will work, because the regex
            // didn't fail
            Some(caps) => Ok(BasicDate {
                year: caps.get(1).unwrap().as_str().parse().unwrap(),
                month: caps.get(2).unwrap().as_str().parse().unwrap(),
                day: caps.get(3).unwrap().as_str().parse().unwrap(),
            }),
        }
    }
}

impl ToString for BasicDate {
    fn to_string(&self) -> String {
        format!("{}-{}-{}", self.year, self.month, self.day)
    }
}

impl Serialize for BasicDate {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&self.to_string())
    }
}

impl Serialize for PickupTime {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = serializer.serialize_struct("PickupTime", 4)?;
        s.serialize_field("date", &self.date)?;
        s.serialize_field("label", &self.label)?;
        s.serialize_field("classes", &self.classes)?;
        s.serialize_field("url", &self.url)?;

        s.end()
    }
}

/// Represents a pickup time instance. All fields are a direct map of the
/// original API
pub struct PickupTime {
    date: BasicDate,
    label: String,
    classes: Vec<String>,
    url: String,
}

pub fn get_pickup_times(
    street: Street,
    number: u32,
    start_date: BasicDate,
    end_date: BasicDate,
) -> Result<Vec<PickupTime>, Box<dyn Error>> {
    Ok(Vec::new())
}