wrb-timings/application/src/pages/groups.rs

use crate::components::{self, participant};
use crate::util::surrealdb::schemas;
use futures::stream::ForEach;
use leptos::*;

/// Renders the home page of your application.
#[component]
pub fn Groups() -> impl IntoView {
    let group_hour = create_rw_signal("A");
    let group_lane = create_rw_signal("1");

    let participants_context = use_context::<schemas::ParticipantsContext>().unwrap();

    let participants_filtered: Memo<Vec<schemas::ParticipantSignal>> = create_memo(move |_| {
        participants_context
            .get()
            .into_iter()
            .filter(|participant| {
                participant.value.get().group == group_hour.get().to_owned() + group_lane.get()
            })
            .collect()
    });

    let (participants_lifesaver, participants_hindernis, participants_popduiken) =
        sort_by_events(participants_filtered);

    let lifesaver_best = create_memo(move |_| match participants_lifesaver.get().get(0) {
        Some(p) => match p.value.get().events {
            Some(e) => e.lifesaver.unwrap_or(0),
            None => 6_000_000,
        },
        None => 6_000_000,
    });

    let hindernis_best = create_memo(move |_| match participants_hindernis.get().get(0) {
        Some(p) => match p.value.get().events {
            Some(e) => e.hindernis.unwrap_or(0),
            None => 6_000_000,
        },
        None => 6_000_000,
    });

    let popduiken_best = create_memo(move |_| match participants_popduiken.get().get(0) {
        Some(p) => match p.value.get().events {
            Some(e) => e.popduiken.unwrap_or(0),
            None => 6_000_000,
        },
        None => 6_000_000,
    });

    let total_score_participants = sort_by_total_score(
        participants_filtered,
        lifesaver_best,
        hindernis_best,
        popduiken_best,
    );

    view! {
        <h2>"Groups"</h2>
        <div class="groups-select-container">
            <div class="groups-select-row">
                <div on:click=move |_| group_hour.set("A") class:selected=move || group_hour.get() == "A">"A"</div>
                <div on:click=move |_| group_hour.set("B") class:selected=move || group_hour.get() == "B">"B"</div>
                <div on:click=move |_| group_hour.set("C") class:selected=move || group_hour.get() == "C">"C"</div>
                <div on:click=move |_| group_hour.set("D") class:selected=move || group_hour.get() == "D">"D"</div>
                <div on:click=move |_| group_hour.set("Z") class:selected=move || group_hour.get() == "Z">"Z"</div>
            </div>
            <div class="groups-select-row">
                <div on:click=move |_| group_lane.set("1") class:selected=move || group_lane.get() == "1">"1"</div>
                <div on:click=move |_| group_lane.set("2") class:selected=move || group_lane.get() == "2">"2"</div>
                <div on:click=move |_| group_lane.set("3") class:selected=move || group_lane.get() == "3">"3"</div>
                <div on:click=move |_| group_lane.set("4") class:selected=move || group_lane.get() == "4">"4"</div>
                <div on:click=move |_| group_lane.set("5") class:selected=move || group_lane.get() == "5">"5"</div>
                <div on:click=move |_| group_lane.set("6") class:selected=move || group_lane.get() == "6">"6"</div>
            </div>
        </div>
        <h3>"Algemene score"</h3>
        <components::participants::Participants participants=total_score_participants.into() show_group=false />
        <div class="events-container">
            <div>
                <h3>"Lifesaver"</h3>
                <components::participants::Participants participants=participants_lifesaver.into() show_group=false show_popduiken=false show_hindernis=false />
            </div>
            <div>
                <h3>"Hindernis"</h3>
                <components::participants::Participants participants=participants_hindernis.into() show_group=false show_popduiken=false show_lifesaver=false />
            </div>
            <div>
                <h3>"Popduiken"</h3>
                <components::participants::Participants participants=participants_popduiken.into() show_group=false show_hindernis=false show_lifesaver=false />
            </div>
        </div>
    }
}

fn sort_by_total_score(
    participants_filtered: Memo<Vec<schemas::ParticipantSignal>>,
    lifesaver_best: Memo<u32>,
    popduiken_best: Memo<u32>,
    hindernis_best: Memo<u32>,
) -> Memo<Vec<schemas::ParticipantSignal>> {
    let total_score_participants: Memo<Vec<schemas::ParticipantSignal>> = create_memo(move |_| {
        let mut all_participants: Vec<(usize, schemas::ParticipantSignal)> = participants_filtered
            .get()
            .into_iter()
            .enumerate()
            .collect();

        let lifesaver_best = lifesaver_best.get();
        let popduiken_best = popduiken_best.get();
        let hindernis_best = hindernis_best.get();

        all_participants.sort_by(|(_, a), (_, b)| {
            let part_a = match a.value.get().events {
                Some(events) => {
                    ((events.lifesaver.unwrap_or(6_000_000) * 100) / lifesaver_best)
                        + ((events.hindernis.unwrap_or(6_000_000) * 100) / hindernis_best)
                        + ((events.popduiken.unwrap_or(6_000_000) * 100) / popduiken_best)
                }
                None => 1000,
            };
            let part_b = match b.value.get().events {
                Some(events) => {
                    ((events.lifesaver.unwrap_or(6_000_000) * 100) / lifesaver_best)
                        + ((events.hindernis.unwrap_or(6_000_000) * 100) / hindernis_best)
                        + ((events.popduiken.unwrap_or(6_000_000) * 100) / popduiken_best)
                }
                None => 1000,
            };

            part_a.cmp(&part_b)
        });

        all_participants
            .into_iter()
            .map(|(_, value)| value)
            .collect()
    });
    total_score_participants
}

fn sort_by_events(
    participants_filtered: Memo<Vec<schemas::ParticipantSignal>>,
) -> (
    Memo<Vec<schemas::ParticipantSignal>>,
    Memo<Vec<schemas::ParticipantSignal>>,
    Memo<Vec<schemas::ParticipantSignal>>,
) {
    let lifesaver: Memo<Vec<schemas::ParticipantSignal>> = create_memo(move |_| {
        let mut participants: Vec<(usize, schemas::ParticipantSignal)> = participants_filtered
            .get()
            .into_iter()
            .enumerate()
            .collect();
        participants.sort_by(|(_, a), (_, b)| {
            let event_a = match a.value.get().events {
                Some(events) => events.lifesaver.unwrap_or(6_000_000),
                None => 6_000_000,
            };
            let event_b = match b.value.get().events {
                Some(events) => events.lifesaver.unwrap_or(5_999_100),
                None => 6_000_000,
            };

            event_a.cmp(&event_b)
        });

        participants.into_iter().map(|(_, value)| value).collect()
    });

    let hindernis: Memo<Vec<schemas::ParticipantSignal>> = create_memo(move |_| {
        let mut participants: Vec<(usize, schemas::ParticipantSignal)> = participants_filtered
            .get()
            .into_iter()
            .enumerate()
            .collect();
        participants.sort_by(|(_, a), (_, b)| {
            let event_a = match a.value.get().events {
                Some(events) => events.hindernis.unwrap_or(6_000_000),
                None => 6_000_000,
            };
            let event_b = match b.value.get().events {
                Some(events) => events.hindernis.unwrap_or(6_000_000),
                None => 6_000_000,
            };

            event_a.cmp(&event_b)
        });

        participants.into_iter().map(|(_, value)| value).collect()
    });

    let popduiken: Memo<Vec<schemas::ParticipantSignal>> = create_memo(move |_| {
        let mut participants: Vec<(usize, schemas::ParticipantSignal)> = participants_filtered
            .get()
            .into_iter()
            .enumerate()
            .collect();
        participants.sort_by(|(_, a), (_, b)| {
            let event_a = match a.value.get().events {
                Some(events) => events.popduiken.unwrap_or(6_000_000),
                None => 6_000_000,
            };
            let event_b = match b.value.get().events {
                Some(events) => events.popduiken.unwrap_or(6_000_000),
                None => 6_000_000,
            };

            event_a.cmp(&event_b)
        });

        participants.into_iter().map(|(_, value)| value).collect()
    });

    (lifesaver, hindernis, popduiken)
}