rFactor2_vk_hud/src/overlay/elements/leaderboard.rs

use std::{
    ffi::{c_char, CStr},
    sync::Arc,
};

use anyhow::Result;
use rfactor_sm_reader::{rF2VehicleTelemetry, VehicleScoringInfoV01};
use ui::prelude::*;
use utilities::prelude::Color;

use crate::overlay::{rfactor_data::DataReceiver, UiOverlay};

pub struct LeaderBoard {
    gui_handler: Arc<GuiHandler>,
    gui: Arc<GuiBuilder>,
    main_grid: Arc<Grid>,

    entries: Vec<LeaderBoardEntry>,

    entry_backgrounds: [Color; 2],
}

impl LeaderBoard {
    const GRID: &str = include_str!("ui_files/leaderboard_grid.xml");
    const ENTRY: &str = include_str!("ui_files/leaderboard_entry.xml");

    pub fn new(gui_handler: &Arc<GuiHandler>) -> Result<Self> {
        let gui = GuiBuilder::from_str(gui_handler, Self::GRID)?;

        let main_grid = gui.element("main_grid")?;

        Ok(Self {
            gui_handler: gui_handler.clone(),
            gui,
            main_grid,

            entries: Vec::new(),

            entry_backgrounds: [Color::try_from("#838383")?, Color::try_from("#545454")?],
        })
    }
}

impl UiOverlay for LeaderBoard {}

impl DataReceiver for LeaderBoard {
    fn scoring_update(&mut self, vehicle_scorings: &[VehicleScoringInfoV01]) -> Result<()> {
        for vehicle_scoring in vehicle_scorings {
            // check driver list
            match self
                .entries
                .iter_mut()
                .find(|entry| vehicle_scoring.mID == entry.id)
            {
                Some(entry) => {
                    entry.update_place(vehicle_scoring.mPlace)?;
                    entry.update_time_behind_leader(vehicle_scoring.mTimeBehindLeader)?;
                    entry.update_time_behind_next(vehicle_scoring.mTimeBehindNext)?;
                }
                None => {
                    let entry = LeaderBoardEntry::new(
                        &self.gui_handler,
                        vehicle_scoring.mID,
                        unsafe { CStr::from_ptr(&vehicle_scoring.mDriverName as *const c_char) }
                            .to_str()
                            .unwrap()
                            .to_string(),
                        vehicle_scoring.mPlace,
                        vehicle_scoring.mTimeBehindLeader,
                        vehicle_scoring.mTimeBehindNext,
                    )?;

                    self.entries.push(entry);
                }
            }
        }

        // check if entry count in grid is the same as the gathered entries
        let force_update = if self
            .main_grid
            .child_at(0, self.entries.len() - 1)?
            .is_none()
        {
            for i in 0..self.entries.len() {
                self.main_grid.detach(0, i)?;
            }

            true
        } else {
            false
        };

        // check if any entry needs resorting
        if force_update || self.entries.iter().any(|entry| entry.needs_resorting()) {
            self.entries
                .sort_by(|lhs, rhs| lhs.place().cmp(&rhs.place()));

            for (i, entry) in self.entries.iter_mut().enumerate() {
                entry.resorting_finished();
                entry.change_background_color(self.entry_backgrounds[i % 2])?;

                self.main_grid.attach(entry.snippet(), 0, i, 1, 1)?;
            }
        }

        if self.entries.is_empty() {
            self.gui.disable()?;
        } else {
            self.gui.enable()?;
        }

        Ok(())
    }

    fn telemetry_update(
        &mut self,
        _player_id: Option<i32>,
        _telemetries: &[rF2VehicleTelemetry],
    ) -> Result<()> {
        Ok(())
    }
}

struct LeaderBoardEntry {
    id: i32,

    name: String,
    place: u8,
    time_behind_leader: f64,
    time_behind_next: f64,

    snippet: Arc<GuiSnippet>,

    grid: Arc<Grid>,
    name_label: Arc<Label>,
    place_label: Arc<Label>,
    time_behind_label: Arc<Label>,

    place_updated: bool,
}

impl LeaderBoardEntry {
    pub fn new(
        gui_handler: &Arc<GuiHandler>,
        id: i32,
        name: String,
        place: u8,
        time_behind_leader: f64,
        time_behind_next: f64,
    ) -> Result<Self> {
        let snippet = GuiSnippet::from_str(gui_handler, LeaderBoard::ENTRY)?;

        let background = snippet.element("grid")?;
        let name_label: Arc<Label> = snippet.element("name")?;
        let place_label: Arc<Label> = snippet.element("place")?;
        let time_behind_label: Arc<Label> = snippet.element("time_behind")?;

        name_label.set_text(&name)?;
        place_label.set_text(place)?;
        time_behind_label.set_text(format!("{:.3}", time_behind_leader))?;

        Ok(Self {
            id,

            name,
            place,
            time_behind_leader,
            time_behind_next,

            snippet,

            grid: background,
            name_label,
            place_label,
            time_behind_label,

            place_updated: true,
        })
    }

    pub fn place(&self) -> u8 {
        self.place
    }

    pub fn snippet(&self) -> Arc<GuiSnippet> {
        self.snippet.clone()
    }

    pub fn change_background_color(&self, color: Color) -> Result<()> {
        self.grid.set_background(color)
    }

    pub fn update_place(&mut self, place: u8) -> Result<()> {
        if self.place != place {
            self.place_updated = true;
        }

        self.place = place;

        self.place_label.set_text(self.place)
    }

    pub fn update_time_behind_leader(&mut self, time: f64) -> Result<()> {
        self.time_behind_leader = time;

        self.time_behind_label
            .set_text(format!("{:.3}", self.time_behind_leader))
    }

    pub fn update_time_behind_next(&mut self, time: f64) -> Result<()> {
        self.time_behind_next = time;

        Ok(())
    }

    pub fn needs_resorting(&self) -> bool {
        self.place_updated
    }

    pub fn resorting_finished(&mut self) {
        self.place_updated = false;
    }
}