hail_core 0.3.0

#![allow(dead_code)]
use std::str::FromStr;
use std::time::Duration;

use hail_core::{types::TimeType, *};

const RUN_V5_STR: &str = r#"version 5
(
    game_title: "Test",
    category: "tseT",
    ingame_time: true,
    offset: -1200,
    segment_names: [
        "hello",
        "world",
        "foobar",
        "baz",
    ],
    rta_pb_splits: [
        1000,
        2000,
        3000,
        4000,
    ],
    igt_pb_splits: [
        500,
        1000,
        1500,
        2000,
    ],
    rta_gold_segments: [
        800,
        100,
        100,
        100,
    ],
    igt_gold_segments: [
        300,
        300,
        300,
        300,
    ],
    rta_sum_segments: [
        (2, 1800),
        (1, 1000),
        (0, None),
        (3, 4000),
    ],
    igt_sum_segments: [
        (2, 1000),
        (1, 3000),
        (0, None),
        (3, 2000),
    ],
)"#;

pub fn init() -> HailState {
    let r = Run::from_str(RUN_V5_STR).unwrap();
    HailState::new(r)
}

pub fn init_noofset() -> HailState {
    let mut r = Run::from_str(RUN_V5_STR).unwrap();
    r.offset = TimeType::None;
    HailState::new(r)
}

pub fn init_missinggolds() -> HailState {
    let mut r = Run::from_str(RUN_V5_STR).unwrap();
    r.rta_gold_segments = vec![
        TimeType::Time(800),
        TimeType::None,
        TimeType::Time(800),
        TimeType::Time(800),
    ];
    r.offset = TimeType::None;
    HailState::new(r)
}

pub fn init_skip() -> HailState {
    let mut r = Run::from_str(RUN_V5_STR).unwrap();
    r.rta_pb_splits[1] = TimeType::None;
    r.offset = TimeType::None;
    HailState::new(r)
}

pub fn init_igt() -> HailState {
    let mut r = Run::from_str(RUN_V5_STR).unwrap();
    r.ingame_time = true;
    r.rta_pb_splits[1] = TimeType::Time(2000);
    r.igt_pb_splits[1] = TimeType::Time(1000);
    HailState::new(r)
}

const RUN_V5_STR_EMPTY: &str = r#"version 5
(
    game_title: "Test",
    category: "tseT",
    ingame_time: true,
    offset: None,
    segment_names: [
        "hello",
        "world",
        "foobar",
        "baz",
    ],
    rta_pb_splits: [
        None,
        None,
        None,
        None,
    ],
    igt_pb_splits: [
        None,
        None,
        None,
        None,
    ],
    rta_gold_segments: [
        None,
        None,
        None,
        None,
    ],
    igt_gold_segments: [
        None,
        None,
        None,
        None,
    ],
    rta_sum_segments: [
        (0, None),
        (0, None),
        (0, None),
        (0, None),
    ],
    igt_sum_segments: [
        (0, None),
        (0, None),
        (0, None),
        (0, None),
    ],
)"#;

pub fn init_empty() -> HailState {
    let r = Run::from_str(RUN_V5_STR_EMPTY).unwrap();
    HailState::new(r)
}

#[macro_export]
macro_rules! same_time {
    ($a:expr,$b:expr) => {
        let d = i128::abs($a - $b);
        if d >= 16 {
            panic!("Unexpected time {}, expected {} (off by {}ms)", $a, $b, d);
        }
        println!("{d}");
    };
}

#[macro_export]
macro_rules! same_timer {
    ($a:expr,$b:expr) => {
        assert_eq!($a.active_time, $b.active_time, "active_time");
        assert_eq!($a.run_split_times, $b.run_split_times, "run_split_times");
        assert_eq!($a.run_seg_times, $b.run_seg_times, "run_seg_times");
        assert_eq!($a.run_pb_statuses, $b.run_pb_statuses, "run_pb_statuses");
        assert_eq!($a.active_pb_status, $b.active_pb_status, "active_pb_status");
        assert_eq!(
            $a.run_gold_statuses, $b.run_gold_statuses,
            "run_gold_statuses"
        );
        assert_eq!(
            $a.active_gold_status, $b.active_gold_status,
            "active_gold_status"
        );
        assert_eq!($a.run_avg_statuses, $b.run_avg_statuses, "run_avg_statuses");
        assert_eq!(
            $a.active_avg_status, $b.active_avg_status,
            "active_avg_status"
        );
        assert_eq!($a.run_pb_diffs, $b.run_pb_diffs, "run_pb_diffs");
        assert_eq!($a.run_pb_seg_diffs, $b.run_pb_seg_diffs, "run_pb_seg_diffs");
        assert_eq!($a.active_pb_diff, $b.active_pb_diff, "active_pb_diff");
        assert_eq!($a.run_gold_diffs, $b.run_gold_diffs, "run_gold_diffs");
        assert_eq!(
            $a.run_gold_seg_diffs, $b.run_gold_seg_diffs,
            "run_gold_seg_diffs"
        );
        assert_eq!($a.active_gold_diff, $b.active_gold_diff, "active_gold_diff");
        assert_eq!($a.run_avg_diffs, $b.run_avg_diffs, "run_avg_diffs");
        assert_eq!(
            $a.run_avg_seg_diffs, $b.run_avg_seg_diffs,
            "run_avg_seg_diffs"
        );
        assert_eq!($a.active_avg_diff, $b.active_avg_diff, "active_avg_diff");
        assert_eq!($a.pb_split_times, $b.pb_split_times, "pb_split_times");
        assert_eq!($a.gold_split_times, $b.gold_split_times, "gold_split_times");
        assert_eq!($a.avg_split_times, $b.avg_split_times, "avg_split_times");
    };
}

#[macro_export]
// checks public facing fields
macro_rules! same_state {
    ($a:expr,$b:expr) => {
        assert_eq!($a.run, $b.run);
        println!("rta");
        same_timer!($a.rta, $b.rta);
        println!("igt");
        same_timer!($a.igt, $b.igt);
        assert_eq!($a.current_seg, $b.current_seg, "current_seg");
    };
}

pub fn dur(m: u64) -> Duration {
    Duration::from_millis(m)
}

pub fn sleep(m: u64) {
    std::thread::sleep(dur(m));
}