#[macro_use]
extern crate rocket;
use rand::Rng;
use rocket::{
    fs::{relative, FileServer},
    response::stream::{Event, EventStream},
    serde::{json::Json, Deserialize, Serialize},
    tokio::{
        self, select,
        time::{self, sleep, Duration, Instant},
    },
    Shutdown, State,
};
use rocket_dyn_templates::{context, Template};
use std::{
    collections::{HashMap, VecDeque},
    sync::{Arc, RwLock},
};

#[derive(Serialize, Deserialize, Clone)]
#[serde(crate = "rocket::serde")]
enum TrackedState {
    Conscrit {
        invisible: bool,
        blurred: bool,
        captured: bool,
        mallette: bool,
        invisibility_codes: u32,
        blur_codes: u32,
    },
    Vieux {
        color: u8,
        invisible: bool,
    },
}

use TrackedState::{Conscrit, Vieux};

const BLURRED_MOVE: (f32, f32) = (0.0005, 0.0005);
const BONUS_TIMEOUT: Duration = Duration::from_millis(5000);
const EVENT_TIMEOUT: Duration = Duration::from_millis(100);

impl TrackedState {
    fn invisible(&self) -> bool {
        match self {
            Conscrit { invisible, .. } => *invisible,
            Vieux { invisible, .. } => *invisible,
        }
    }
    fn blurred(&self) -> bool {
        match self {
            Conscrit { blurred, .. } => *blurred,
            Vieux { .. } => false,
        }
    }
    fn global_viewed(&self) -> bool {
        match self {
            Conscrit {
                captured,
                mallette,
                invisible,
                ..
            } => (*captured || *mallette) && !*invisible,
            Vieux { invisible, .. } => !*invisible,
        }
    }
    fn color(&self) -> u8 {
        match self {
            Vieux { color, .. } => *color,
            Conscrit { captured, .. } => {
                if *captured {
                    1
                } else {
                    0
                }
            }
        }
    }
    fn admin_color(&self) -> u8 {
        match self {
            Vieux { color, invisible } => {
                if *invisible {
                    2
                } else {
                    *color
                }
            }
            Conscrit {
                invisible,
                captured,
                ..
            } => {
                if *invisible {
                    2
                } else if *captured {
                    1
                } else {
                    0
                }
            }
        }
    }
}

struct Tracked {
    id: String,
    name: String,
    pos: (f32, f32),
    state: TrackedState,
}

fn build_conscrit(id: String, name: String) -> Tracked {
    Tracked {
        id: id,
        name: name,
        pos: (0.0, 0.0),
        state: TrackedState::Conscrit {
            invisible: false,
            blurred: false,
            captured: false,
            mallette: false,
            invisibility_codes: 0,
            blur_codes: 0,
        },
    }
}

fn build_vieux(id: String, name: String) -> Tracked {
    Tracked {
        id: id,
        name: name,
        pos: (0.0, 0.0),
        state: TrackedState::Vieux {
            invisible: true,
            color: 1,
        },
    }
}

struct QueuedEvent {
    date: Instant,
    evt: Event,
}

impl QueuedEvent {
    fn expired(&self) -> bool {
        self.date.elapsed() >= EVENT_TIMEOUT
    }
}
impl From<Event> for QueuedEvent {
    fn from(evt: Event) -> QueuedEvent {
        QueuedEvent {
            date: Instant::now(),
            evt,
        }
    }
}
impl From<QueuedEvent> for Event {
    fn from(queued_evt: QueuedEvent) -> Event {
        queued_evt.evt
    }
}

type Tracking = Arc<RwLock<HashMap<String, RwLock<Tracked>>>>;
type TrackingEventQueue = Arc<RwLock<HashMap<String, RwLock<VecDeque<QueuedEvent>>>>>;
type AdminEventQueue = Arc<RwLock<VecDeque<QueuedEvent>>>;
type AdminKey = String;

#[derive(Serialize)]
#[serde(crate = "rocket::serde")]
struct TrackedInfo {
    name: String,
    pos: (f32, f32),
    color: u8,
}

#[derive(Serialize)]
#[serde(crate = "rocket::serde")]
struct AdminTrackedInfo {
    name: String,
    id: String,
    pos: (f32, f32),
    color: u8,
    state: TrackedState,
}

impl From<AdminTrackedInfo> for TrackedInfo {
    fn from(admin_info: AdminTrackedInfo) -> TrackedInfo {
        TrackedInfo {
            name: admin_info.name,
            pos: admin_info.pos,
            color: admin_info.color,
        }
    }
}

fn base_view(team: &Tracked) -> TrackedInfo {
    TrackedInfo {
        name: team.name.clone(),
        pos: team.pos,
        color: team.state.color(),
    }
}

fn admin_view(team: &Tracked) -> AdminTrackedInfo {
    AdminTrackedInfo {
        name: team.name.clone(),
        id: team.id.clone(),
        pos: team.pos,
        color: team.state.admin_color(),
        state: team.state.clone(),
    }
}

fn apparent_info(watcher: &Tracked, team: &Tracked) -> Option<TrackedInfo> {
    if watcher.id == team.id {
        None
    } else if let Conscrit {
        captured, mallette, ..
    } = watcher.state
    {
        if captured {
            if team.state.invisible() {
                None
            } else if team.state.blurred() {
                let mut rng = rand::thread_rng();
                let (lat, lon) = team.pos;
                Some(TrackedInfo {
                    pos: (
                        lat + BLURRED_MOVE.0 * (rng.gen::<f32>() * 2.0 - 1.0),
                        lon + BLURRED_MOVE.1 * (rng.gen::<f32>() * 2.0 - 1.0),
                    ),
                    ..base_view(team)
                })
            } else {
                Some(base_view(team))
            }
        } else {
            if mallette || team.state.global_viewed() {
                Some(base_view(team))
            } else {
                None
            }
        }
    } else {
        Some(admin_view(team).into())
    }
}

#[get("/track/<id>?<gpslog>&<dbg>")]
fn tracked_view(
    id: &str,
    gpslog: Option<bool>,
    dbg: Option<bool>,
    tracking: &State<Tracking>,
) -> Option<Template> {
    if let Some(tracked) = tracking.read().unwrap().get(&id.to_string()) {
        Some(Template::render(
            match tracked.read().unwrap().state {
                Vieux { .. } => "vieux",
                Conscrit { .. } => "conscrit",
            },
            context! {
                name: &tracked.read().unwrap().name,
                id: &id,
                gpslog: gpslog.unwrap_or(true),
                dbg: dbg.unwrap_or(false),
            },
        ))
    } else {
        None
    }
}

fn evts_to_send(evt_queue: &RwLock<VecDeque<QueuedEvent>>) -> Vec<Event> {
    evt_queue
        .read()
        .unwrap()
        .iter()
        .filter(|qevt| !qevt.expired())
        .map(|qevt| qevt.evt.clone())
        .collect()
}

fn evts_for(id: &str, evt_queues: &TrackingEventQueue) -> Vec<Event> {
    evts_to_send(evt_queues.read().unwrap().get(&id.to_string()).unwrap())
}

#[get("/track/<id>/events")]
fn tracked_events<'a>(
    id: &'a str,
    evt_queue: &'a State<TrackingEventQueue>,
    mut shutdown: Shutdown,
) -> Option<EventStream![Event + 'a]> {
    if evt_queue.read().unwrap().contains_key(&id.to_string()) {
        Some(EventStream! {
            let mut interval = time::interval(EVENT_TIMEOUT);
            loop {
                select!{
                    _ = interval.tick() =>{
                        for evt in evts_for(id, evt_queue){
                            //println!("{:?}", evt);
                            yield evt;
                        }
                    },
                    _ = &mut shutdown => break
                }
            }
        })
    } else {
        None
    }
}

#[get("/admin?<tok>&<dbg>")]
fn admin_page(
    tok: Option<AdminKey>,
    dbg: Option<bool>,
    admin_key: &State<AdminKey>,
) -> Option<Template> {
    if tok == Some(admin_key.to_string()) {
        Some(Template::render(
            "admin",
            context! { tok: tok.unwrap(), dbg: dbg.unwrap_or(false) },
        ))
    } else {
        None
    }
}

#[patch("/admin/<id>?<tok>", data = "<nstate>")]
fn admin_set_state(
    tok: Option<AdminKey>,
    id: &str,
    admin_key: &State<AdminKey>,
    nstate: Json<TrackedState>,
    tracking: &State<Tracking>,
    evt_queue: &State<TrackingEventQueue>,
    admin_queue: &State<AdminEventQueue>,
) -> Option<()> {
    if tok == Some(admin_key.to_string()) {
        let tracking_lock = tracking.read().unwrap();
        let tracked = tracking_lock.get(&id.to_string()).unwrap();
        tracked.write().unwrap().state = nstate.into_inner();
        state_update(&tracked.read().unwrap(), &evt_queue, &admin_queue);
        Some(())
    } else {
        None
    }
}

#[get("/admin/events?<tok>")]
fn admin_events<'a>(
    tok: Option<AdminKey>,
    admin_key: &State<AdminKey>,
    admin_queue: &'a State<AdminEventQueue>,
    tracking: &State<Tracking>,
    mut shutdown: Shutdown,
) -> Option<EventStream![Event + 'a]> {
    if tok == Some(admin_key.to_string()) {
        let full_info: Vec<AdminTrackedInfo> = tracking
            .read()
            .unwrap()
            .iter()
            .map(|(_, tracked)| admin_view(&tracked.read().unwrap()))
            .collect();
        Some(EventStream! {
            yield Event::json(&full_info).event("full_update");
            let mut interval = time::interval(EVENT_TIMEOUT);
            loop {
                select!{
                    _ = interval.tick() =>{
                        for evt in evts_to_send(admin_queue){
                            //println!("{:?}", evt);
                            yield evt;
                        }
                    },
                    _ = &mut shutdown => break
                }
            }
        })
    } else {
        None
    }
}

fn state_update(tracked: &Tracked, evt_queues: &TrackingEventQueue, admin_queue: &AdminEventQueue) {
    evt_queues
        .read()
        .unwrap()
        .get(&tracked.id)
        .unwrap()
        .write()
        .unwrap()
        .push_back(Event::json(&admin_view(tracked)).event("self_info").into());
    admin_queue
        .write()
        .unwrap()
        .push_back(Event::json(&admin_view(tracked)).event("update").into());
}

#[put("/track/<id>/pos?<lat>&<long>")]
fn store_pos(
    id: &str,
    lat: f32,
    long: f32,
    tracking: &State<Tracking>,
    evt_queues: &State<TrackingEventQueue>,
    admin_queue: &State<AdminEventQueue>,
) {
    if let Some(tracked) = tracking.read().unwrap().get(&id.to_string()) {
        tracked.write().unwrap().pos = (lat, long);
        state_update(&tracked.read().unwrap(), &evt_queues, &admin_queue);
    }
}

#[put("/track/<id>/state?<inv>&<col>")]
fn set_state(
    id: &str,
    inv: bool,
    col: u8,
    tracking: &State<Tracking>,
    evt_queues: &State<TrackingEventQueue>,
    admin_queue: &State<AdminEventQueue>,
) -> Option<()> {
    let tracking_lock = tracking.read().unwrap();
    let tracked = &mut tracking_lock.get(&id.to_string()).unwrap().write().unwrap();
    if let Vieux {
        ref mut invisible,
        ref mut color,
    } = tracked.state
    {
        *invisible = inv;
        *color = col;
        state_update(&tracked, &evt_queues, &admin_queue);
        Some(())
    } else {
        None
    }
}

#[put("/track/<id>/vanish")]
async fn activate_invisibility(
    id: &str,
    tracking: &State<Tracking>,
    evt_queues: &State<TrackingEventQueue>,
    admin_queue: &State<AdminEventQueue>,
) -> Option<()> {
    let tracking_lock = tracking.read().unwrap();
    let tracked = &mut tracking_lock.get(&id.to_string()).unwrap().write().unwrap();
    if let Conscrit {
        ref mut invisible,
        ref mut invisibility_codes,
        ..
    } = tracked.state
    {
        if *invisibility_codes > 0 {
            *invisibility_codes -= 1;
            *invisible = true;
            state_update(&tracked, &evt_queues, &admin_queue);
            let track_clone = (*tracking).clone();
            let queue_clone = (*evt_queues).clone();
            let admin_clone = (*admin_queue).clone();
            let id_str = id.to_string();
            tokio::spawn(async move {
                sleep(BONUS_TIMEOUT).await;
                if let Conscrit {
                    ref mut invisible, ..
                } = track_clone
                    .read()
                    .unwrap()
                    .get(&id_str)
                    .unwrap()
                    .write()
                    .unwrap()
                    .state
                {
                    *invisible = false;
                }
                state_update(
                    &track_clone
                        .read()
                        .unwrap()
                        .get(&id_str)
                        .unwrap()
                        .read()
                        .unwrap(),
                    &queue_clone,
                    &admin_clone,
                );
            });
            Some(())
        } else {
            None
        }
    } else {
        None
    }
}

#[put("/track/<id>/blur")]
async fn activate_blur(
    id: &str,
    tracking: &State<Tracking>,
    evt_queues: &State<TrackingEventQueue>,
    admin_queue: &State<AdminEventQueue>,
) -> Option<()> {
    let tracking_lock = tracking.read().unwrap();
    let tracked = &mut tracking_lock.get(&id.to_string()).unwrap().write().unwrap();
    if let Conscrit {
        ref mut blurred,
        ref mut blur_codes,
        ..
    } = tracked.state
    {
        if *blur_codes > 0 {
            *blur_codes -= 1;
            *blurred = true;
            state_update(&tracked, &evt_queues, &admin_queue);
            let track_clone = (*tracking).clone();
            let queue_clone = (*evt_queues).clone();
            let admin_clone = (*admin_queue).clone();
            let id_str = id.to_string();
            tokio::spawn(async move {
                sleep(BONUS_TIMEOUT).await;
                if let Conscrit {
                    ref mut blurred, ..
                } = track_clone
                    .read()
                    .unwrap()
                    .get(&id_str)
                    .unwrap()
                    .write()
                    .unwrap()
                    .state
                {
                    *blurred = false;
                }
                state_update(
                    &track_clone
                        .read()
                        .unwrap()
                        .get(&id_str)
                        .unwrap()
                        .read()
                        .unwrap(),
                    &queue_clone,
                    &admin_clone,
                );
            });
            Some(())
        } else {
            None
        }
    } else {
        None
    }
}

#[get("/")]
fn index() -> &'static str {
    "Hello, world!"
}

fn send_coords(tracking: &Tracking, evt_queue: &TrackingEventQueue) {
    let tracking_lock = tracking.read().unwrap();
    for (id, queue) in evt_queue.read().unwrap().iter() {
        let watcher = tracking_lock.get(id).unwrap().read().unwrap();
        let mut infos: Vec<TrackedInfo> = Vec::new();
        for (_, tracked) in tracking_lock.iter() {
            if let Some(info) = apparent_info(&watcher, &tracked.read().unwrap()) {
                infos.push(info);
            }
        }
        queue
            .write()
            .unwrap()
            .push_back(Event::json(&infos).event("coords").into());
    }
}

fn clean_expired_evt(evt_queues: &TrackingEventQueue, admin_queue: &AdminEventQueue) {
    for (_, queue) in evt_queues.read().unwrap().iter() {
        let queue = &mut queue.write().unwrap();
        while let Some(queued_evt) = queue.front() {
            if queued_evt.expired() {
                queue.pop_front();
            } else {
                break;
            }
        }
    }
    let queue = &mut admin_queue.write().unwrap();
    while let Some(queued_evt) = queue.front() {
        if queued_evt.expired() {
            queue.pop_front();
        } else {
            break;
        }
    }
}

#[launch]
async fn rocket() -> _ {
    //TODO: read a config file on release
    let tracking: Tracking = Arc::new(RwLock::new(HashMap::from([
        (
            "team00".to_string(),
            RwLock::new(build_conscrit("team00".to_string(), "Équipe 0".to_string())),
        ),
        (
            "team01".to_string(),
            RwLock::new(build_conscrit("team01".to_string(), "Équipe 1".to_string())),
        ),
        (
            "npc0".to_string(),
            RwLock::new(build_vieux("npc0".to_string(), "PNJ 0".to_string())),
        ),
        (
            "npc1".to_string(),
            RwLock::new(build_vieux("npc1".to_string(), "PNJ 1".to_string())),
        ),
    ])));
    let evt_queue: TrackingEventQueue = Arc::new(RwLock::new(
        tracking
            .read()
            .unwrap()
            .iter()
            .map(|(id, _)| (id.clone(), RwLock::new(VecDeque::new())))
            .collect(),
    ));
    let admin_evt_queue: AdminEventQueue = Arc::new(RwLock::new(VecDeque::new()));
    let key: AdminKey = "root".to_string(); //TODO : random on release
    println!("Admin token: {}", key);
    let rocket = rocket::build()
        .attach(Template::fairing())
        .manage(tracking.clone())
        .manage(evt_queue.clone())
        .manage(admin_evt_queue.clone())
        .manage(key)
        .mount(
            "/",
            routes![
                index,
                store_pos,
                tracked_view,
                tracked_events,
                set_state,
                admin_page,
                admin_events,
                admin_set_state,
                activate_invisibility,
                activate_blur,
            ],
        )
        .mount("/", FileServer::from(relative!("static")));
    tokio::spawn(async move {
        let mut clean_interval = time::interval(5 * EVENT_TIMEOUT);
        let mut coord_interval = time::interval(Duration::from_millis(3000));
        loop {
            select! {
                _ = coord_interval.tick() => send_coords(&tracking, &evt_queue),
                _ = clean_interval.tick() => clean_expired_evt(&evt_queue, &admin_evt_queue),
            }
        }
    });
    rocket
}