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};

// TODO:
//   1) Represent state of division/fieldset/field/match(maybe save/load)
//   2) Create functions to update the states and publish to MQTT based on incoming 'notifications'
//   2) Create functions to update the state that map to NOTICE_IDs and take in the notice struct
// Notifications parsed last year:
//  - NOTICE_REALTIME_SCORE_CHANGED
//  - NOTICE_FIELD_TIMER_STARTED
//  - NOTICE_FIELD_TIMER_STOPPED
//  - NOTICE_FIELD_RESET_TIMER
//  - NOTICE_FIELD_MATCH_ASSIGNED
//  - NOTICE_ACTIVE_FIELD_CHANGED
//  - NOTICE_RANKINGS_UPDATED
//  - NOTICE_EVENT_STATUS_UPDATED
//  - NOTICE_ELIM_ALLIANCE_UPDATED
//  - NOTICE_ELIM_UNAVAIL_TEAMS_UPDATED
//  - NOTICE_MATCH_LIST_UPDATED
//
//  Notice protobuf:
//  message Notice {
//    optional tm.NoticeId id = 1;
//    optional tm.MatchTuple affectedMatch = 2;
//    optional tm.ElimAlliance elimAlliance = 3;
//    optional tm.SideChallengeScore sideChallengeScore = 4;
//    optional tm.EventConfig eventConfig = 5;
//    optional tm.FieldHwState fieldState = 6;
//    optional tm.FieldTime fieldTime = 7;
//    optional tm.Field field = 8;
//    optional tm.MatchTimeSchedList matchTimeSchedList = 9;
//    optional tm.MatchTimeSchedList matchTimeSched = 10;
//    optional tm.FieldSetList fieldSetList = 11;
//    optional tm.PitDisplayList pitDisplayList = 12;
//    optional tm.DisplayState displayState = 13;
//    optional tm.AssignedObjectType.AssignedObjectEnum assignedType = 15;
//    optional tm.PublishOptions publishOptions = 16;
//    optional tm.Division division = 17;
//    optional tm.MatchScore matchScore = 18;
//    optional tm.Rankings rankings = 19;
//    optional tm.MatchRound affectedRound = 20;
//    optional tm.Award award = 21;
//    optional tm.FieldSet fieldSet = 22;
//    optional tm.TeamInfo teamInfo = 23;
//    optional double obsolete_serverTime = 24;
//    optional tm.TeamInspection teamInspection = 25;
//    optional int32 obsolete_serverTimeZoneInSecs = 27;
//    optional tm.ElimQueueList elimQueueList = 28;
//    optional tm.TextMessageNotice textMessage = 29;
//    optional string originatingClient = 30;
//    optional bool isLocal = 31;
//    optional tm.DisplaySlide displaySlide = 32;
//    optional tm.AssignedMatchList assignedMatchList = 33;
//    optional tm.MobileDeviceMatchLockList mobileMatchLocks = 34;
//    optional tm.ElimWinsToAdvanceList elimWinsToAdvanceList = 35;
//    optional string temporaryCode = 36;
//    optional tm.MatchScoreList matchScoreLog = 37;
//    optional tm.PublishStatus publishStatus = 38;
//    optional tm.MatchInfo matchInfo = 39;
//    optional tm.AwardList awardList = 40;
//    optional string eventName = 41;
//    optional tm.FieldControlStatus fieldControlStatus = 42;
//  }
//
//  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) -> Vec<MQTTMessage> {
    match notice.match_score {
        None => return Vec::new(),
        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;
                },
                None => return Vec::new(),
            }
        },
    }
}

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

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

fn main() {
    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 = callback(notice);
                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");
}