extern crate csv;
extern crate serde;
#[macro_use]
extern crate structopt;
#[macro_use]
extern crate serde_derive;
extern crate fnv;
extern crate humantime;
use fnv::{FnvHashMap, FnvHashSet};
use humantime::format_duration;
use rstar::{PointDistance, RTree, RTreeObject, AABB};
use std::collections::VecDeque;
use std::hash::{Hash, Hasher};
use std::io::Write;
use std::path::PathBuf;
use std::time::Instant;
use structopt::StructOpt;

#[derive(Debug, Deserialize)]
struct Record {
    id: i64,
    star_type: String,
    name: String,
    mult: f32,
    x: f32,
    y: f32,
    z: f32,
}
#[derive(Debug, Clone)]
struct System {
    id: i64,
    star_type: String,
    name: String,
    mult: f32,
}

#[derive(Debug, Clone, Copy)]
struct Point {
    id: i64,
    x: f32,
    y: f32,
    z: f32,
}
#[derive(Debug, StructOpt)]
#[structopt(name = "ed_lrr", about = "Elite: Dangerous Long-Range Router")]
/// Plots a route through multiple systems using breadth-first search (Currently needs a lot of RAM (8+GB), sorry)
struct Opt {
    #[structopt(short = "r", long = "range")]
    /// Jump Range
    range: f32,
    #[structopt(
        parse(from_os_str),
        short = "p",
        long = "path",
        default_value = "./stars.csv"
    )]
    /// Path to stars.csv
    file_path: PathBuf,
    /// Systems to route through
    systems: Vec<String>,
}
fn dist(p1: &[f32; 3], p2: &[f32; 3]) -> f32 {
    let dx = p1[0] - p2[0];
    let dy = p1[1] - p2[1];
    let dz = p1[2] - p2[2];

    return (dx * dx + dy * dy + dz * dz).sqrt();
}

impl Point {
    pub fn dist2(&self, p: &[f32; 3]) -> f32 {
        let dx = self.x - p[0];
        let dy = self.y - p[1];
        let dz = self.z - p[2];

        return dx * dx + dy * dy + dz * dz;
    }
    pub fn distp(&self, p: &Point) -> f32 {
        return self.distp2(p).sqrt();
    }
    pub fn distp2(&self, p: &Point) -> f32 {
        return self.dist2(&[p.x, p.y, p.z]);
    }
}
impl PartialEq for Point {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl Eq for Point {}

impl Hash for Point {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

impl RTreeObject for Point {
    type Envelope = AABB<[f32; 3]>;

    fn envelope(&self) -> Self::Envelope {
        return AABB::from_point([self.x, self.y, self.z]);
    }
}

impl PointDistance for Point {
    fn distance_2(&self, point: &[f32; 3]) -> f32 {
        return self.dist2(&point);
    }
}

struct Router {
    tree: RTree<Point>,
    systems: FnvHashMap<i64, System>,
    scoopable: FnvHashSet<i64>,
}

impl Router {
    pub fn new(path: &PathBuf) -> Self {
        let mut scoopable = FnvHashSet::default();
        let mut systems: FnvHashMap<i64, System> = FnvHashMap::default();
        let mut reader = csv::ReaderBuilder::new()
            .has_headers(false)
            .from_path(path)
            .unwrap_or_else(|e| {
                println!("Error loading {}: {}", path.to_str().unwrap(), e);
                std::process::exit(1);
            });
        println!("Loading {}...", path.to_str().unwrap());
        let points = reader
            .deserialize()
            .map(|res: Result<Record, _>| {
                let sys = res.unwrap();
                systems.insert(
                    sys.id,
                    System {
                        id: sys.id,
                        star_type: sys.star_type.clone(),
                        name: sys.name,
                        mult: sys.mult,
                    },
                );
                if sys.mult > 1.0f32 {
                    scoopable.insert(sys.id);
                } else {
                    for c in "KGBFOAM".chars() {
                        if sys.star_type.starts_with(c) {
                            scoopable.insert(sys.id);
                            break;
                        }
                    }
                }
                return Point {
                    x: sys.x,
                    y: sys.y,
                    z: sys.z,
                    id: sys.id,
                };
            })
            .collect();
        return Self {
            tree: RTree::<Point>::bulk_load(points),
            systems,
            scoopable,
        };
    }

    fn preload_points(&self) -> FnvHashMap<i64, &Point> {
        let mut ret = FnvHashMap::default();
        for point in &self.tree {
            ret.insert(point.id, point);
        }
        return ret;
    }

    fn closest(&self, point: &[f32; 3]) -> &Point {
        return self.tree.nearest_neighbor(point).unwrap();
    }
    fn points_in_sphere(&self, center: &[f32; 3], radius: f32) -> impl Iterator<Item = &Point> {
        let center: [f32; 3] = *center;
        return self
            .tree
            .locate_in_envelope(&AABB::from_corners(
                [
                    center[0] - radius * 1f32,
                    center[1] - radius * 1f32,
                    center[2] - radius * 1f32,
                ],
                [
                    center[0] + radius * 1f32,
                    center[1] + radius * 1f32,
                    center[2] + radius * 1f32,
                ],
            ))
            .filter(move |p| (p.dist2(&center) < (radius * radius)));
    }

    fn mult(&self, id: i64) -> f32 {
        if let Some(sys) = self.systems.get(&id) {
            return sys.mult;
        };
        return 1.0;
    }
    fn neighbours(&self, sys: &Point, r: f32) -> impl Iterator<Item = &Point> {
        return self.points_in_sphere(&[sys.x, sys.y, sys.z], self.mult(sys.id) * r);
    }

    fn valid(&self, sys: &Point) -> bool {
        return self.scoopable.contains(&sys.id);
    }

    pub fn name_multiroute(&self, waypoints: &Vec<String>, range: f32) -> Vec<(&System, &Point)> {
        let mut coords = Vec::new();
        for p in waypoints {
            let p = self.name_to_point(p);
            let s = [p.x, p.y, p.z];
            coords.push(s);
        }
        return self.multiroute(coords.as_slice(), range);
    }
    pub fn multiroute(&self, waypoints: &[[f32; 3]], range: f32) -> Vec<(&System, &Point)> {
        let mut route = Vec::new();
        for pair in waypoints.windows(2) {
            match pair {
                &[src, dst] => {
                    let block = self.route(&src, &dst, range);
                    if route.is_empty() {
                        route.extend(block.iter());
                    } else {
                        route.extend(block.iter().skip(1));
                    }
                }
                _ => panic!("Invalid routing parameters!"),
            }
        }
        return route;
    }

    fn sys_to_point(&self, id: i64) -> Option<&Point> {
        for p in &self.tree {
            if p.id == id {
                return Some(p);
            }
        }
        return None;
    }

    fn name_to_point(&self, name: &str) -> &Point {
        for sys in self.systems.values() {
            if sys.name == name {
                return self.sys_to_point(sys.id).unwrap();
            }
        }
        eprintln!("Sytem not found: \"{}\"", name);
        std::process::exit(1);
    }

    pub fn route(&self, src: &[f32; 3], dst: &[f32; 3], range: f32) -> Vec<(&System, &Point)> {
        let start_sys = self.closest(src);
        let goal_sys = self.closest(dst);
        {
            let d = dist(src, dst);
            let start_sys_name = self.systems.get(&start_sys.id).unwrap().name.clone();
            let goal_sys_name = self.systems.get(&goal_sys.id).unwrap().name.clone();
            println!(
                "Plotting route from {} to {}...",
                start_sys_name, goal_sys_name
            );
            println!(
                "Jump Range: {} Ly, Distance: {} Ly, Theoretical Jumps: {}",
                range,
                d,
                d / range
            );
        }
        let total = self.tree.size() as f32;
        let mut prev = FnvHashMap::default();
        let mut seen = FnvHashSet::default();
        let t_start = Instant::now();
        let mut depth = 0;
        let mut found = false;
        let mut queue: VecDeque<(usize, &Point)> = VecDeque::new();
        let mut queue_next: VecDeque<(usize, &Point)> = VecDeque::new();
        queue.push_front((0, &start_sys));
        seen.insert(start_sys.id);
        while !(queue.is_empty() || found) {
            print!(
                "[{}] Depth: {}, Queue: {}, Seen: {} ({:.02}%)     \r",
                format_duration(t_start.elapsed()),
                depth,
                queue.len(),
                seen.len(),
                ((seen.len() * 100) as f32) / total
            );
            std::io::stdout().flush().unwrap();
            while let Some((d, sys)) = queue.pop_front() {
                if sys.id == goal_sys.id {
                    found = true;
                    break;
                }
                queue_next.extend(
                    self.neighbours(&sys, range)
                        .filter(|&nb| (self.valid(nb) || (nb.id == goal_sys.id)))
                        .filter(|&nb| seen.insert(nb.id))
                        .map(|nb| {
                            prev.insert(nb.id, sys.id);
                            return (d + 1, nb);
                        }),
                );
            }
            std::mem::swap(&mut queue, &mut queue_next);
            depth += 1;
        }
        println!();
        if !found {
            return Vec::new();
        }
        let points = self.preload_points();
        let mut v: Vec<(&System, &Point)> = Vec::new();
        let mut prev_sys_id = goal_sys.id;
        loop {
            if let Some(sys) = self.systems.get(&prev_sys_id) {
                v.push((sys, points[&sys.id]));
            } else {
                break;
            };
            match prev.get(&prev_sys_id) {
                Some(sys_id) => prev_sys_id = *sys_id,
                None => {
                    break;
                }
            }
        }
        v.reverse();
        return v;
    }
}

fn main() {
    let opts = Opt::from_args();
    let path = opts.file_path;
    let t_load = Instant::now();
    let router: Router = Router::new(&path);
    println!("Done in {}!", format_duration(t_load.elapsed()));
    let t_route = Instant::now();
    let route = router.name_multiroute(&opts.systems, opts.range);
    println!(
        "Done in {} ({} Jumps)!\n",
        format_duration(t_route.elapsed()),
        route.len(),
    );
    let mut total: f32 = 0.0;
    for ((sys1, p1), (_, p2)) in route.iter().zip(route.iter().skip(1)) {
        let dist = p1.distp(p2);
        total += dist;
        println!(
            "{} [{}] ({},{},{}): {:.2} Ly",
            sys1.name, sys1.star_type, p1.x, p1.y, p1.z, dist
        );
    }
    let (sys, p) = route.iter().last().unwrap();
    println!(
        "{} [{}] ({},{},{}): {:.2} Ly",
        sys.name, sys.star_type, p.x, p.y, p.z, 0.0
    );
    println!("Total: {:.2} Ly", total);
}