use failure::Error;
use serde::{Serialize, Deserialize};
use std::collections::HashMap;
use std::time::SystemTime;

#[macro_use]
mod adapter_macro;
mod apiservice;
pub mod world_geo;

pub use self::apiservice::{APIService, FetchTask};

use crate::config::Config;

impl<Message: 'static> APIService<Message> {
	pub fn api_world_geo<F>(&self, config: &Config, callback: F) -> Option<FetchTask>
	where
		F: FnOnce(Result<world_geo::FeatureCollection, Error>) -> Message + 'static,
	{
		self.api_get(config, format_args!("/geo/world.geojson"), callback)
	}
}

pub type DateTime = chrono::DateTime<chrono::Utc>;

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Global {
	#[serde(rename = "gps-offset-ns")]
	pub gps_offset_ns: f64,
	#[serde(rename = "gps-utc-offset-ns")]
	pub gps_utc_offset_ns: f64,
	#[serde(rename = "last-seen", with = "chrono::serde::ts_seconds")]
	pub last_seen: DateTime,
	#[serde(rename = "leap-second-planned")]
	pub leap_second_planned: bool,
	#[serde(rename = "leap-seconds")]
	pub leap_seconds: f64,
	#[serde(rename = "utc-offset-ns")]
	pub utc_offset_ns: f64,
}

impl<Message: 'static> APIService<Message> {
	pub fn api_global<F>(&self, config: &Config, callback: F) -> Option<FetchTask>
	where
		F: FnOnce(Result<Global, Error>) -> Message + 'static,
	{
		self.api_get(config, format_args!("/global.json"), callback)
	}
}

#[derive(Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash, Debug, serde_repr::Serialize_repr, serde_repr::Deserialize_repr)]
#[repr(u8)]
pub enum GNS {
	GPS = 0, // US
	Galileo = 2, // EU
	BeiDou = 3, // CN
	Glonass = 6, // RU
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct AlmanacEntry {
	// NOT in Glonass
	#[serde(rename = "eph-ecefX")]
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub eph_ecef_x: Option<f64>,
	#[serde(rename = "eph-ecefY")]
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub eph_ecef_y: Option<f64>,
	#[serde(rename = "eph-ecefZ")]
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub eph_ecef_z: Option<f64>,

	// optional in Glonass
	#[serde(rename = "eph-latitude")]
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub eph_latitude: Option<f64>,
	#[serde(rename = "eph-longitude")]
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub eph_longitude: Option<f64>,

	// NOT in Glonass
	pub t: Option<f64>,
	pub t0e: Option<f64>,

	// all
	pub gnssid: GNS,
	pub name: String,
	pub observed: bool,
	pub inclination: f64,
}

pub type Almanac = HashMap<String, AlmanacEntry>;

impl<Message: 'static> APIService<Message> {
	pub fn api_almanac<F>(&self, config: &Config, callback: F) -> Option<FetchTask>
	where
		F: FnOnce(Result<Almanac, Error>) -> Message + 'static,
	{
		self.api_get(config, format_args!("/almanac.json"), callback)
	}
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Observer {
	pub id: u32,
	#[serde(rename = "last-seen", with = "chrono::serde::ts_seconds")]
	pub last_seen: DateTime,
	pub latitude: f64,
	pub longitude: f64,
	#[serde(rename = "svs")]
	pub satellite_vehicles: HashMap<String, ObservedSatelliteVehicle>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ObservedSatelliteVehicle {
	#[serde(rename = "age-s")]
	pub age_s: f32, // u32?
	pub azi: f64,
	pub db: u32,
	pub elev: f64,
	#[serde(rename = "fullName")]
	pub full_name: String,
	pub gnss: GNS,
	#[serde(rename = "last-seen")]
	pub last_seen: i64,
	pub name: String,
	pub prres: f64,
	pub sigid: u32,
	pub sv: u32,
}

pub type ObserverList = Vec<Observer>;

impl<Message: 'static> APIService<Message> {
	pub fn api_observers<F>(&self, config: &Config, callback: F) -> Option<FetchTask>
	where
		F: FnOnce(Result<ObserverList, Error>) -> Message + 'static,
	{
		self.api_get(config, format_args!("/observers.json"), callback)
	}
}

#[derive(Clone, Copy, Debug)]
/// A certain point in time in some reference system, in seconds
pub struct Instant {
	pub week_number: u16, // depending on source only might have rolled on 8-bit
	pub time_of_week: u32,
}

impl Instant {
	pub fn system_time(self) -> SystemTime {
		SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(self.epoch())
	}

	pub fn unroll_weeknumber(self) -> u32 {
		let current_epoch = SystemTime::now().duration_since(SystemTime::now()).expect("before 1970-01-01").as_secs();
		let current_wn = (current_epoch / (86400*7)) as u32;
		let wn = self.week_number as u32;
		let wn_bits = (16 - self.week_number.leading_zeros()).min(8); // assume at least 8-bit precision in weeknumber
		let wn_mask = !0u32 << wn_bits;
		let round_up = 1 << (wn_bits - 1); // if we already reached "halftime" round up
		wn + ((current_wn + round_up) & wn_mask) // add bits from current_wn
	}

	pub fn epoch(self) -> u64 {
		self.unroll_weeknumber() as u64 * (86400*7) + self.time_of_week as u64
	}
}

#[derive(Clone, Copy, Debug)]
pub struct Vec3 {
	pub x: f64,
	pub y: f64,
	pub z: f64,
}

#[derive(Clone, Debug)]
pub struct ReferenceTimeOffset {
	/// offset in 2**(-30) seconds at base Instant (close to nanoseconds)
	pub base_offset: i32,
	/// correction in 2**(-50) seconds per second since base Instant
	pub correction: i32,
	/// time at which constant offset was measured
	pub base: Instant,
	/// text describing delta for some "current" (last_seen) Instant in nanoseconds offset and change in nanoseconds per day.
	pub delta: String,
}

mod sv {
	use super::*;

	adapter!{
		LastSeen => Instant {
			#[serde(rename = "wn")]
			week_number: u16,
			#[serde(rename = "tow")]
			time_of_week: u32,
		}
	}

	adapter!{
		Position => Option<Vec3> {
			x: f64,
			y: f64,
			z: f64,
		}
	}

	adapter!{
		UtcOffsetInstant => Option<Instant> {
			#[serde(rename = "wn0t")]
			week_number: u16,
			#[serde(rename = "t0t")]
			time_of_week: u32,
		}
	}

	adapter!{
		// bug https://github.com/ahupowerdns/galmon/issues/8: Glonass sends a0 and a1, but not the other values
		UtcOffset => Option<ReferenceTimeOffset> {
			#[serde(rename = "a0")]
			base_offset: i32,
			#[serde(rename = "a1")]
			correction: i32,
			#[serde(flatten, with = "UtcOffsetInstant")]
			base: Instant,
			#[serde(rename = "delta-utc")]
			delta: String,
		}
	}

	adapter!{
		GpsOffsetInstant => Option<Instant> {
			#[serde(rename = "wn0g")]
			week_number: u16,
			#[serde(rename = "t0g")]
			time_of_week: u32,
		}
	}

	adapter!{
		GpsOffset => Option<ReferenceTimeOffset> {
			#[serde(rename = "a0g")]
			base_offset: i32,
			#[serde(rename = "a1g")]
			correction: i32,
			#[serde(flatten, with = "GpsOffsetInstant")]
			base: Instant,
			#[serde(rename = "delta-gps")]
			delta: String,
		}
	}
}

// TODO: "undo" flatten	#[serde(default, skip_serializing_if = "Option::is_none")]

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SatelliteVehicle {
	/* Identification: */
	gnssid: GNS,
	svid: u32, /* vehicle id; can be moved between satellites */
	sigid: u32, /* "signal", also appended as "@{sigid}" to the full name */
	/* Data: */
	/// Signal In Space Accuracy
	#[serde(default, skip_serializing_if = "Option::is_none")]
	sisa: Option<String>,
	#[serde(rename = "eph-age-m", default, skip_serializing_if = "Option::is_none")]
	/// Age of ephemeris in minutes
	eph_age_m: Option<f32>,

	#[serde(rename = "best-tle", default, skip_serializing_if = "Option::is_none")]
	best_tle: Option<String>,
	#[serde(rename = "best-tle-dist", default, skip_serializing_if = "Option::is_none")]
	best_tle_dist: Option<f64>,
	#[serde(rename = "best-tle-int-desig", default, skip_serializing_if = "Option::is_none")]
	best_tle_int_desig: Option<String>,
	#[serde(rename = "best-tle-norad", default, skip_serializing_if = "Option::is_none")]
	best_tle_norad: Option<i32>,

	#[serde(rename = "alma-dist", default, skip_serializing_if = "Option::is_none")]
	alma_dist: Option<f64>, // distance from almanac position in kilometers

	#[serde(default, skip_serializing_if = "Option::is_none")]
	aode: Option<u32>,

	#[serde(default, skip_serializing_if = "Option::is_none")]
	aodc: Option<u32>,

	#[serde(default, skip_serializing_if = "Option::is_none")]
	iod: Option<u16>,
	// IOD data:
	#[serde(default, skip_serializing_if = "Option::is_none")]
	af0: Option<i32>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	af1: Option<i32>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	af2: Option<u8>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	t0c: Option<u16>, // clock epoch

	#[serde(flatten, with = "sv::Position")]
	position: Option<Vec3>,

	// utc offset (all but Glonass): combined data
	#[serde(flatten, with = "sv::UtcOffset")]
	utc_offset: Option<ReferenceTimeOffset>,

	// GPS offset (only Galileo and BeiDou)
	#[serde(flatten, with = "sv::GpsOffset")]
	gpc_offset: Option<ReferenceTimeOffset>,

	#[serde(rename = "dtLS")]
	dt_ls: i8,

	#[serde(default, skip_serializing_if = "Option::is_none")]
	health: Option<String>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	healthissue: Option<u32>, // some codes?

	// Galileo only: Health flags for E1 (common) and E5 (uncommon) frequencies.
	#[serde(default, skip_serializing_if = "Option::is_none")]
	e1bhs: Option<u8>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	e1bdvs: Option<bool>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	e5bhs: Option<u8>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	e5bdvs: Option<bool>,

	#[serde(rename = "latest-disco", default, skip_serializing_if = "Option::is_none")]
	latest_disco: Option<f64>,
	#[serde(rename = "latest-disco-age", default, skip_serializing_if = "Option::is_none")]
	latest_disco_age: Option<f64>,

	#[serde(rename = "time-disco", default, skip_serializing_if = "Option::is_none")]
	time_disco: Option<f64>,

	#[serde(flatten, with = "sv::LastSeen")]
	last_seen: Instant,

	/// Number of seconds since we've last received from this SV. A satellite can be out of sight for a long time
	#[serde(rename = "last-seen-s")]
	last_seen_s: i64,

	#[serde(rename = "fullName")]
	full_name: String, // format!("{}@{}", self.name, self.sigid)
	name: String,

	perrecv: HashMap<u32, SatelliteVehiclePerReceiver>, // keys: Observer `id`
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SatelliteVehiclePerReceiver {
	#[serde(rename = "elev")]
	elevation: f64,
	#[serde(rename = "azi", default, skip_serializing_if = "Option::is_none")]
	azimuth: Option<f64>,
	db: i32,
	#[serde(rename = "last-seen-s")]
	last_seen_s: i64,
	prres: f64,
	delta_hz: Option<f64>,
	delta_hz_corr: Option<f64>,
}

pub type SatelliteVehicles = HashMap<String, SatelliteVehicle>;

impl<Message: 'static> APIService<Message> {
	pub fn api_satellite_vehicles<F>(&self, config: &Config, callback: F) -> Option<FetchTask>
	where
		F: FnOnce(Result<SatelliteVehicles, Error>) -> Message + 'static,
	{
		self.api_get(config, format_args!("/svs.json"), callback)
	}
}