#[derive(Clone, PartialEq, PartialOrd, Debug)]
pub struct Stop{
    pub id:u32,
    pub name:String,
    pub lat: f64,
    pub lon: f64,
}
impl std::hash::Hash for Stop {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        state.write_u32(self.id);
    }
}
impl From<Stop> for crate::types::Coords {
    fn from(value: Stop) -> Self {
        crate::types::Coords {lat: value.lat, lon: value.lon}
    }
}

#[derive(serde::Deserialize)]
struct OcctStop{
    id:u32,
    name:String,
    lat: f64,
    #[serde(rename(deserialize = "lng"))]
    lon: f64,
}
impl From<OcctStop> for Stop{
    fn from(OcctStop{id,name,lat,lon}: OcctStop) -> Self {
        Self {
            id,
            name,
            lat,
            lon
        }
    }
}
#[derive(serde::Deserialize)]
struct BCStop{
    id:u32,
    name:String,
    lat: f64,
    lon: f64,
}
impl From<BCStop> for Stop{
    fn from(BCStop{id,name,lat,lon}: BCStop) -> Self {
        Self {
            id,
            name,
            lat,
            lon
        }
    }
}

#[derive(serde::Deserialize)]
struct OcctWrap{
    get_stops:Vec<OcctStop>
}
pub async fn occt_stops_get()->anyhow::Result<Vec<Stop>>{
    let resp = reqwest::get("http://binghamtonupublic.etaspot.net/service.php?service=get_stops&token=TESTING").await?;
    let body = resp.text().await?;
    let OcctWrap {get_stops: stops}= serde_json::from_str(body.as_str())?;
    Ok(stops.into_iter().map(Stop::from).collect())
}
pub async fn bc_stops_get()->anyhow::Result<Vec<Stop>>{
    let resp = reqwest::get("https://bctransit.doublemap.com/map/v2/stops").await?;
    let body = resp.text().await?;
    let stops:Vec<BCStop> = serde_json::from_str(body.as_str())?;
    Ok(stops.into_iter().map(Stop::from).collect())
}
pub fn poly_encode_stops(stops:Vec<Stop>)->String{
    println!("{:?}",stops);
    stops.into_iter()
        .map(|stop|{
            "".to_owned()//enc_float(stop.lat) + &enc_float(stop.lon)
        })
        .reduce(|s1,s2|s1+&s2).unwrap_or("".into())
}
fn enc_float(num:f64)->String{ 

    let working:i32 = invoke_e5(num);
    let working = two_comp(working,num);
    let working = lshf(working);
    let working = if_negative_invert(working,num);
    let chunks = chunks(working);
    chunks.iter().map(|v| char::from_u32(*v as u32).unwrap()).collect()
}

fn invoke_e5(n:f64)->i32{
    (n*1e5).round() as i32
}

fn two_comp(n:i32, orig:f64)->i32{
    if orig < 0.0{
        n^-1 + 1
    }
    else {
        n
    }
}

fn lshf(n:i32)->i32{
    n << 1
}
fn if_negative_invert(n:i32, orig:f64)->i32{
    if orig < 0.0{
        n ^ -1
    }
    else {
        n
    }
}
fn chunks(n:i32)->[u8;6]{
    let mut chunks:[u8;6] = [0;6];
    for i in 0..6{
        chunks[i] = (n >> (5*i) ) as u8 & 0x1f;
        if i != 5 {chunks[i] |= 0x20;}
        chunks[i] += 63;
    }
    chunks
}

#[derive(serde::Serialize)]
pub struct RouteDraw{
    pub color:String,
    pub poly_line:String
}