Playing with NWS

use serde::{Deserialize, Serialize};
use serde_json::Value;

pub mod api;

pub use anyhow::Result;
pub use chrono::{DateTime, Utc};

// ...

/// Result of Forecast query
#[derive(Debug, Serialize, Deserialize)]
pub struct Forecast {
  pub properties: ForecastProps,
}

// Inner properties object of Forecast
#[derive(Debug, Serialize, Deserialize)]
pub struct ForecastProps {
  pub updated: DateTime<Utc>,
  pub units: String,
  #[serde(rename(deserialize = "generatedAt"))]
  pub generated_at: DateTime<Utc>,
  pub elevation: Value,
  pub periods: Vec<ForecastPeriod>,
}

// ...

// ...

#[derive(Deserialize, Serialize, Debug)]
pub struct City {
  pub city: String,
  pub state_id: String,
  pub lat: f32,
  pub lng: f32,
}

impl City {
  pub fn into_point(&self) -> Result<Point> {
    Ok(Point {
      lat: self.lat,
      lng: self.lng,
    })
  }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Point {
  pub lat: f32,
  pub lng: f32,
}

impl Point {
  // create a new 'Point' from (f32, f32)
  pub fn new(lat: &f32, lng: &f32) -> Result<Self> {
    Ok(Point {
      lat: *lat,
      lng: *lng,
    })
  }
}

// ...

/// Weather output representation
#[derive(Debug, Serialize, Deserialize)]
pub struct WeatherBundle {
  pub location: City,
  pub forecast: Vec<ForecastBundle>,
  pub updated: DateTime<Utc>,
}

impl WeatherBundle {
  pub fn new(loc: City, fcb: Forecast) -> Self {
    let mut vec = Vec::new();
    for i in fcb.properties.periods.iter() {
      let i = ForecastBundle {
        start: i.start_time,
        end: i.end_time,
        temperature: i.temperature,
        wind_speed: i.wind_speed.to_string(),
        wind_direction: i.wind_direction.to_string(),
        short_forecast: i.short_forecast.to_string(),
      };
      vec.push(i);
    }
    WeatherBundle {
      location: loc,
      forecast: vec,
      updated: fcb.properties.updated,
    }
  }
}

[dependencies]
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.11.3", features = ["json"] }
# ...

use crate::{Forecast, Point, PointInfo, Result};
pub use reqwest::{Client, StatusCode};
use std::env;

/// User-Agent HTTP Header value
pub static APP_USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);

pub async fn get_point(pnt: &Point, client: &Client) -> Result<PointInfo> {
  let mut url: String = String::from("http://api.weather.gov/");
  for i in &["points/", &pnt.lat.to_string(), ",", &pnt.lng.to_string()] {
    url.push_str(i);
  }
  let response = client.get(&url).send().await?;
  let body = response.text().await?;
  let res: PointInfo = serde_json::from_str(&body)?;
  Ok(res)
}

pub async fn get_forecast(pnt: &PointInfo, client: &Client) -> Result<Forecast> {
  let response = client.get(&pnt.properties.forecast).send().await?;
  let body = response.text().await?;
  let res: Forecast = serde_json::from_str(&body)?;
  Ok(res)
}

pub async fn get_forecast_hourly(pnt: &PointInfo, client: &Client) -> Result<Forecast> {
  let response = client.get(&pnt.properties.forecast_hourly).send().await?;
  let body = response.text().await?;
  let res: Forecast = serde_json::from_str(&body)?;
  Ok(res)
}

use std::env;
use weather::api::{get_forecast, get_point, Client, APP_USER_AGENT};
use weather::{Point, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let args: Vec<String> = env::args().collect();
  let lat: &f32 = &args[1].parse::<f32>()?;
  let lng: &f32 = &args[2].parse::<f32>()?;
  let pnt = Point::new(lat, lng)?;
  let client = Client::builder().user_agent(APP_USER_AGENT).build()?;

  let res = get_point(&pnt, &client).await?;
  let resf = get_forecast(&res, &client).await?;
  for i in resf.properties.periods.iter() {
    println!("{:#?}, {:#?}", &i.name, &i.detailed_forecast);
  }
  Ok(())
}

# weather {LAT} {LONG}
# cd ./target/debug/
./weather 40.7580 -73.9855

use std::fs::File;
use std::io::Write;
use weather::City;
fn main() -> Result<(), csv::Error> {
  let mut input = csv::Reader::from_path("data/uscities.csv")?;
  let mut output = File::create("data/uscities.ron")?;

  for city in input.deserialize() {
    let city: City = city?;
    write!(&mut output, "{}\n", ron::ser::to_string(&city).unwrap())?;
  }
  Ok(())
}

for line in lines.into_iter()
.choose_multiple(&mut rand::thread_rng(), 16) {...}

use rand::seq::IteratorRandom;
use ron::de::from_str;
use std::io::{self, BufRead};
use std::{fs::File, path::Path};
use tokio::fs::File as TFile;
use tokio::io::{AsyncWriteExt, BufWriter};
use weather::{api, City, Point, Result, WeatherBundle};

/// Collect (lat,lng) values from file, return a Vec<Point>
fn collect_lines(input_path: &str) -> Result<Vec<City>> {
  let mut result = Vec::new();
  if let Ok(lines) = read_lines(&input_path) {
    for line in lines
      .into_iter()
      .choose_multiple(&mut rand::thread_rng(), 16)
    {
      if let Ok(city) = line {
        let pcity: City = from_str(&city)?;
        result.push(pcity);
      }
    }
  }
  Ok(result)
}

/// Returns an Iterator to the Reader of the lines of the file.
fn read_lines<P>(path: P) -> io::Result<io::Lines<io::BufReader<File>>>
where
  P: AsRef<Path>,
{
  let file = File::open(path)?;
  Ok(io::BufReader::new(file).lines())
}

#[tokio::main]
async fn main() -> Result<()> {
  // Create a single reqwest::Client that is re-used
  let client = api::Client::builder()
    .user_agent(api::APP_USER_AGENT)
    .build()?;

  let input_path: &str = "data/uscities.ron"; // ../data/uscities.ron
  let cities: Vec<City> = collect_lines(&input_path)?; // get our list of cities

  let out_file = TFile::create("data/forecast.ron").await?;

  let mut handles = Vec::new(); // stores async tasks

  // loop over the sample, spawning two new async handles for the
  // network client and out_file writer.
  for city in cities {
    let pnt = Point::new(&city.lat, &city.lng)?;
    let out = out_file.try_clone().await?;
    let client = client.clone();
    let mut writer = BufWriter::new(out);
    let handle = tokio::spawn(async move {
      let res = api::get_point(&pnt, &client).await.unwrap();
      let result = api::get_forecast_hourly(&res, &client).await;
      if let Ok(r) = result {
        println!("{:#?} - got result", &city.city);
        let output = WeatherBundle::new(city, r);
        let ronr = ron::ser::to_string(&output) // ron::ser::PrettyConfig::new()
          .unwrap()
          .into_bytes();
        writer.write_all(&ronr).await.unwrap();
        writer.write_all(b"\n").await.unwrap();
        writer.flush().await.unwrap();
      }
    });
    handles.push(handle)
  }

  for handle in &mut handles {
    handle.await?;
  }
  Ok(())
}

for (idx,c) in fc.into_iter().enumerate() {
    let key = bincode::serialize([&i.location.city, &idx]).unwrap(); // city0, city1, city2
    // ...

use rocksdb::{ColumnFamilyDescriptor, Options, DB};
use ron::de::from_str;
use std::fs::File;
use std::io::{self, BufRead};
use weather::WeatherBundle;
// from rust_rocksdb/tests
// fn get_byte_slice<T: AsRef<[u8]>>(source: &'_ T) -> &'_ [u8] {
//   source.as_ref()
// }

fn main() {
  let input_path: &str = "data/forecast.ron";
  let input = File::open(&input_path).expect("couldnt open file");
  let mut result: Vec<WeatherBundle> = Vec::new();
  let db_path: &str = "data/db";

  {
    for line in io::BufReader::new(input).lines() {
      // this is bloat!
      match from_str(&line.unwrap()) {
        Ok(x) => result.push(x),
        Err(e) => {
          println!("error: {}", e);
          std::process::exit(1);
        }
      }
    }
  }

  {
    let loc_opts = Options::default();
    let fc_opts = Options::default();
    let mut db_opts = Options::default();
    db_opts.create_if_missing(true);
    db_opts.create_missing_column_families(true);
    let loc_cf = ColumnFamilyDescriptor::new("location", loc_opts);
    let fc_cf = ColumnFamilyDescriptor::new("forecast", fc_opts);
    let db = DB::open_cf_descriptors(&db_opts, db_path, vec![loc_cf, fc_cf]).unwrap();
    let cf1 = db.cf_handle("location").unwrap();
    let cf2 = db.cf_handle("forecast").unwrap();
    for i in result.into_iter() {
      let fc = i.forecast;
      for c in fc.into_iter() {
        let key = bincode::serialize(&i.location.city).unwrap();
        let val = bincode::serialize(&[
          c.start.timestamp().to_string(),
          c.wind_speed,
          c.wind_direction,
          c.temperature.to_string(),
          c.short_forecast,
        ])
        .unwrap();
        db.put_cf(cf2, key, val).unwrap();
      }
      let key = bincode::serialize(&i.location.city).unwrap();
      let val = bincode::serialize(&[i.location.lat, i.location.lng]).unwrap();
      db.put_cf(cf1, &key, val).unwrap();
      println!("inserted: {}", i.location.city);
      if let Some(i) = db.get_cf(cf1, &key).unwrap() {
        let (_pre, res, _suf) = unsafe { i.align_to::<f32>() };
        println!("coords: {:#?}", res);
      }
    }
    db.compact_range_cf(cf1, None::<&[u8]>, None::<&[u8]>);
    db.compact_range_cf(cf1, None::<&[u8]>, None::<&[u8]>);
  }
}