use rumqttc::{MqttOptions, Client, QoS, LastWill};
use bytes::Bytes;
use std::time::Duration;
use std::thread;
use std::collections::hash_map::HashMap;
use prost::Message;
use std::io::Cursor;
use serde::{Serialize, Deserialize};

//  MQTT Topics:
//   - division/{division_id}
//   - division/{division_id}/ranking
//   - arena/{arena_id}/score
//   - arena/{arena_id}/state
//   - arena/{arena_id}
//   - game/{division_id}/{game_id}/score
//   - team/{team_string}

pub mod tm {
    include!(concat!(env!("OUT_DIR"), "/tm.rs"));
}

pub fn deserialize_notice(buf: &[u8]) -> Result<tm::Notice, prost::DecodeError> {
    tm::Notice::decode(&mut Cursor::new(buf))
}

#[derive(Serialize, Deserialize, Debug)]
struct DivisionInfo {
    arena: String,
    game_id: String,
}

#[derive(Serialize, Deserialize, Debug)]
struct DivisionRankingInfo {
    rankings: Vec<String>,
}

#[derive(Serialize, Deserialize, Debug)]
enum GameSide {
    Red,
    Blue,
}

#[derive(Serialize, Deserialize, Debug)]
enum ElevationTier {
    A = 0,
    B = 1,
    C = 2,
    D = 3,
    E = 4,
    F = 5,
    G = 6,
    H = 7,
    I = 8,
    J = 9,
}

#[derive(Serialize, Deserialize, Debug)]
struct AllianceScore {
    team_goal: usize,
    team_zone: usize,
    green_goal: usize,
    green_zone: usize,
    elevation_tiers: [Option<ElevationTier>; 2],
}

#[derive(Serialize, Deserialize, Debug)]
struct GameScore {
    autonomous_winner: Option<GameSide>,
    red_score: AllianceScore,
    red_total: usize,
    blue_score: AllianceScore,
    blue_total: usize,
}

#[derive(Serialize, Deserialize, Debug)]
enum GameState {
    Scheduled,
    Timeout,
    Driver,
    Driverdone,
    Autonomous,
    AutonomousDone,
    Abandoned,
}

#[derive(Serialize, Deserialize, Debug)]
struct ArenaStateInfo {
    state: Option<GameState>,
    start_s: usize,
    start_ns: usize,
}

#[derive(Serialize, Deserialize, Debug)]
enum Round {
    None = 0,
    Practice = 1,
    Qualification = 2,
    QuarterFinals = 3,
    SemiFinals = 4,
    Finals = 5,
    RoundOf16 = 6,
    RoundOf32 = 7,
    RoundOf64 = 8,
    RoundOf128 = 9,
    TopN = 15,
    RoundRobin = 16,
    PreEliminations = 20,
    Eliminations = 21,
}

#[derive(Serialize, Deserialize, Debug)]
struct MatchTuple {
    division: String,
    round: Round,
    instance: usize,
    match_num: usize,
    session: usize,
}

#[derive(Serialize, Deserialize, Debug)]
struct ArenaInfo {
    red_teams: [String; 2],
    blue_teams: [String; 2],
    match_tuple: MatchTuple,
}

struct MQTTMessage {
    topic: String,
    payload: String,
}

fn get_game_score(scores: tm::MatchScore) -> Option<GameScore> {
    if scores.alliances.len() != 2 {
        return None;
    }

    let ref red_score = scores.alliances[0];
    let ref blue_score = scores.alliances[1];

    // 1) Get the autonomous winner
    // 2) Get score object and fill AllianceScore struct
    // 3) Compute total scores


    let out = GameScore{
        autonomous_winner: None,
        red_total: 0,
        blue_total: 0,
        blue_score: AllianceScore{
            team_goal: 0,
            team_zone: 0,
            green_goal: 0,
            green_zone: 0,
            elevation_tiers: [None, None],
        },
        red_score : AllianceScore{
            team_goal: 0,
            team_zone: 0,
            green_goal: 0,
            green_zone: 0,
            elevation_tiers: [None, None],
        },
    };

    return Some(out);
}

fn on_score_change(notice: tm::Notice, event: Event) -> (Vec<MQTTMessage>, Event) {
    match notice.match_score {
        None => return (Vec::new(), event),
        Some(game_scores) => {
            match get_game_score(game_scores) {
                Some(score_json) => {
                    let serialized = serde_json::to_string(&score_json).unwrap();
                    let arena_topic = String::from("arena/TEST/score");
                    let mut out = Vec::new();
                    out.push(MQTTMessage{
                        topic: arena_topic,
                        payload: serialized,
                    });
                    return (out, event);
                },
                None => return (Vec::new(), event),
            }
        },
    }
}

fn get_next_notice() -> tm::Notice {
    thread::sleep(Duration::from_millis(1000));
    return tm::Notice::default();
}

struct Event<'a> {
    name: String,
    divisions: Vec<Division<'a>>,
}

type NoticeCallback = fn(tm::Notice, Event) -> (Vec<MQTTMessage>, Event);

struct Division<'a> {
    name: String,
    matches: Vec<Match>,
    field_set: FieldSet<'a>,
}

struct FieldSet<'a> {
    fields: Vec<Field<'a>>,
}

struct Field<'a> {
    name: String,
    current_match: &'a Match,
}

struct Match {
    name: String,
}

fn main() {
    let mut event = Event{
        name: String::from(""),
        divisions: Vec::new(),
    };

    let mut callbacks: HashMap<tm::NoticeId, NoticeCallback> = HashMap::new();
    callbacks.insert(tm::NoticeId::NoticeRealtimeScoreChanged, on_score_change);

    let mut mqttoptions = MqttOptions::new("vex-bridge", "localhost", 1883);
    mqttoptions.set_keep_alive(Duration::from_secs(5));
    mqttoptions.set_last_will(LastWill{
        topic: String::from("bridge/status"),
        message: Bytes::from("{\"online\": false}"),
        qos: QoS::AtLeastOnce,
        retain: true,
    });

    let (mut client, mut connection) = Client::new(mqttoptions, 10);
    client.subscribe("bridge", QoS::AtLeastOnce).unwrap();
    client.publish("bridge/status", QoS::AtLeastOnce, true, "{\"online\": true}").unwrap();

    let mqtt_thread = thread::spawn(move ||
        for message in connection.iter() {
            println!("Message = {:?}", message);
        }
    );

    let running = true;
    while running {
        let notice = get_next_notice();
        let callback = callbacks.get(&notice.id());
        match callback {
            None => {
                match notice.id {
                    None => println!("Notice without NoticeId received"),
                    Some(notice_id) => println!("Unhandled NoticeId: {}", notice_id),
                }
            },
            Some(callback) => {
                let (messages, next_event) = callback(notice, event);
                event = next_event;
                for message in messages {
                    let result = client.publish(message.topic, QoS::AtMostOnce, true, message.payload);
                    match result {
                        Ok(_) => {},
                        Err(error) => println!("Publish error: {}", error),
                    }
                }
            },
        }
    }

    mqtt_thread.join().expect("Failed to join mqtt thread");
}