//
// Created by martin on 16.11.21.
//

#include "SyncTrack.h"
#include "catch.hpp"

TEST_CASE("Basic", "[SyncTrack]") {
  SyncTrack track_a;
  track_a.m_num_intervals = 2;
  track_a.m_duration = 2.0;
  track_a.m_interval_start_ratio[0] = 0.f;
  track_a.m_interval_duration_ratio[0] = 0.7;
  track_a.m_interval_start_ratio[1] = 0.7f;
  track_a.m_interval_duration_ratio[1] = 0.3;

  SyncTrack track_b;
  track_b.m_num_intervals = 2;
  track_b.m_duration = 1.5;
  track_b.m_interval_start_ratio[0] = 0.0f;
  track_b.m_interval_duration_ratio[0] = 0.6;
  track_b.m_interval_start_ratio[1] = 0.6f;
  track_b.m_interval_duration_ratio[1] = 0.4;

  WHEN("Calculating sync time of track_B at 0.5 duration") {
    float sync_time_at_0_75 =
        track_b.CalcSyncFromAbsTime(0.5 * track_b.m_duration);
    REQUIRE(sync_time_at_0_75 == Catch::Detail::Approx(0.83333));
  }

  WHEN("Calculating sync time of track_B at 0.6 duration") {
    float sync_time_at_0_6 =
        track_b.CalcSyncFromAbsTime(0.6 * track_b.m_duration);
    REQUIRE(sync_time_at_0_6 == Catch::Detail::Approx(1.0));
  }

  WHEN("Calculating sync time of track_B at 0.7 duration") {
    float sync_time_at_0_7 =
        track_b.CalcSyncFromAbsTime(0.7 * track_b.m_duration);
    REQUIRE(sync_time_at_0_7 == Catch::Detail::Approx(1.25));
  }

  WHEN("Calculating sync time of track_B at 0.0 duration") {
    float sync_time_at_1_0 =
        track_b.CalcSyncFromAbsTime(0.0 * track_b.m_duration);
    REQUIRE(sync_time_at_1_0 == Catch::Detail::Approx(0.0));
  }

  WHEN("Calculating sync time of track_B at 1.0 duration") {
    float sync_time_at_1_0 =
        track_b.CalcSyncFromAbsTime(0.9999 * track_b.m_duration);
    REQUIRE(sync_time_at_1_0 == Catch::Detail::Approx(2.0).epsilon(0.001f));
  }

  WHEN("Calculating ratio from sync time on track_A at 0.83333") {
    float ratio = track_a.CalcRatioFromSyncTime(0.83333333);
    REQUIRE(ratio == Catch::Detail::Approx(0.5833333));
  }

  WHEN("Calculating ratio from sync time on track_A at 0.83333") {
    float ratio = track_a.CalcRatioFromSyncTime(1.25);
    REQUIRE(ratio == Catch::Detail::Approx(0.775));
  }

  WHEN("Blending two synctracks with weight 0.") {
    SyncTrack blended = SyncTrack::Blend(0.f, track_a, track_b);

    THEN("Result must equal track_A") { REQUIRE(track_a == blended); }
  }

  WHEN("Blending two synctracks with weight 1.") {
    SyncTrack blended = SyncTrack::Blend(1.f, track_a, track_b);

    THEN("Result must equal track_B") { REQUIRE(track_b == blended); }
  }
}

TEST_CASE("Sync Track From Marker", "[SyncTrack]") {
  SyncTrack track = SyncTrack::CreateFromMarkers(2.0f, {0.9f, 0.2f});

  WHEN("Querying Ratios") {
    CHECK(track.m_interval_start_ratio[0] == Catch::Detail::Approx(0.45f));
    CHECK(track.m_interval_duration_ratio[0] == Catch::Detail::Approx(0.65f));

    CHECK(track.m_interval_start_ratio[1] == Catch::Detail::Approx(0.1f));
    CHECK(track.m_interval_duration_ratio[1] == Catch::Detail::Approx(0.35f));

    WHEN("Querying ratio at sync time at 0.001") {
      float ratio = track.CalcRatioFromSyncTime(0.0001f);
      CHECK(ratio == Catch::Detail::Approx(0.45).epsilon(0.001));
    }

    WHEN("Querying ratio at sync time at 0.9999") {
      float ratio = track.CalcRatioFromSyncTime(0.9999f);
      CHECK(ratio == Catch::Detail::Approx(0.1).epsilon(0.001));
    }

    WHEN("Querying ratio at sync time at 1.001") {
      float ratio = track.CalcRatioFromSyncTime(1.0001f);
      CHECK(ratio == Catch::Detail::Approx(0.1).epsilon(0.001));
    }

    WHEN("Querying ratio at sync time at 1.9999") {
      float ratio = track.CalcRatioFromSyncTime(1.9999f);
      CHECK(ratio == Catch::Detail::Approx(0.45).epsilon(0.001));
    }
  }

  WHEN("Querying SyncTime from Absolute Time") {
    WHEN("Querying absolute time at 0.9001s") {
      float sync_time = track.CalcSyncFromAbsTime(0.9001f);
      CHECK_THAT(sync_time, Catch::WithinAbs(0.0, 0.001));
    }

    WHEN("Querying absolute time at 0.2001s") {
      float sync_time = track.CalcSyncFromAbsTime(0.2001f);
      CHECK_THAT(sync_time, Catch::WithinAbs(1.0, 0.001));
    }

    WHEN("Querying absolute time at 0.8999s") {
      float sync_time = track.CalcSyncFromAbsTime(0.8999f);
      CHECK_THAT(sync_time, Catch::WithinAbs(1.999, 0.001));
    }

    WHEN("Querying absolute time at 1.9999s") {
      float sync_time = track.CalcSyncFromAbsTime(1.9999f);
      CHECK_THAT(sync_time, Catch::WithinAbs(0.84615384, 0.001));
    }
  }
}

TEST_CASE("Sync Track Blending", "[SyncTrack]") {
  SyncTrack track_a = SyncTrack::CreateFromMarkers(2.0, {0., 0.6, 1.8});
  SyncTrack track_b = SyncTrack::CreateFromMarkers(1.5f, {1.05, 1.35, 0.3});

  WHEN("Calculating A's durations") {
    CHECK(track_a.m_interval_duration_ratio[0] == Catch::Detail::Approx(0.3));
    CHECK(track_a.m_interval_duration_ratio[1] == Catch::Detail::Approx(0.6));
    CHECK(track_a.m_interval_duration_ratio[2] == Catch::Detail::Approx(0.1));
  }

  WHEN("Calculating B's durations") {
    CHECK(track_b.m_interval_duration_ratio[0] == Catch::Detail::Approx(0.2));
    CHECK(track_b.m_interval_duration_ratio[1] == Catch::Detail::Approx(0.3));
    CHECK(track_b.m_interval_duration_ratio[2] == Catch::Detail::Approx(0.5));
  }

  WHEN("Blending two synctracks with weight 0.") {
    SyncTrack blended = SyncTrack::Blend(0.f, track_a, track_b);

    THEN("Result must equal track_A") { REQUIRE(track_a == blended); }
  }

  WHEN("Blending two synctracks with weight 1.") {
    SyncTrack blended = SyncTrack::Blend(1.f, track_a, track_b);

    THEN("Result must equal track_B") { REQUIRE(track_b == blended); }
  }

  WHEN("Blending with weight 0.2") {
    float weight = 0.2f;
    SyncTrack blended = SyncTrack::Blend(weight, track_a, track_b);

    REQUIRE(
        blended.m_duration
        == (1.0f - weight) * track_a.m_duration + weight * track_b.m_duration);
    REQUIRE(
        blended.m_interval_start_ratio[0]
        == fmodf(
            (1.0f - weight) * (track_a.m_interval_start_ratio[0] + 1.0f)
                + weight * (track_b.m_interval_start_ratio[0]),
            1.0f));
    REQUIRE(
        blended.m_interval_duration_ratio[1]
        == (1.0f - weight) * (track_a.m_interval_duration_ratio[1])
               + weight * (track_b.m_interval_duration_ratio[1]));
    REQUIRE(
        blended.m_interval_duration_ratio[2]
        == (1.0f - weight) * (track_a.m_interval_duration_ratio[2])
               + weight * (track_b.m_interval_duration_ratio[2]));
  }

  WHEN("Inverted blending with weight 0.2") {
    float weight = 0.2f;
    SyncTrack blended = SyncTrack::Blend(weight, track_b, track_a);

    REQUIRE(
        blended.m_duration
        == (1.0f - weight) * track_b.m_duration + weight * track_a.m_duration);
    REQUIRE(
        blended.m_interval_start_ratio[0]
        == fmodf(
            (1.0f - weight) * (track_b.m_interval_start_ratio[0])
                + weight * (track_a.m_interval_start_ratio[0] + 1.0f),
            1.0f));
    REQUIRE(
        blended.m_interval_duration_ratio[1]
        == (1.0f - weight) * (track_b.m_interval_duration_ratio[1])
               + weight * (track_a.m_interval_duration_ratio[1]));
    REQUIRE(
        blended.m_interval_duration_ratio[2]
        == (1.0f - weight) * (track_b.m_interval_duration_ratio[2])
               + weight * (track_a.m_interval_duration_ratio[2]));
  }
}

TEST_CASE("Serialization", "[SyncTrack]") {
  SyncTrack track;
  track.m_num_intervals = 3;
  track.m_duration = 2.0;
  track.m_interval_start_ratio[0] = 0.f;
  track.m_interval_duration_ratio[0] = 0.7;
  track.m_interval_start_ratio[1] = 0.7f;
  track.m_interval_duration_ratio[1] = 0.3;
  track.m_interval_start_ratio[2] = 0.7f;
  track.m_interval_duration_ratio[2] = 0.3;

  nlohmann::json synctrack_json = track;

  const SyncTrack synctrack_deserialized = synctrack_json;

  CHECK(synctrack_deserialized.m_duration == track.m_duration);
  CHECK(synctrack_deserialized.m_num_intervals == track.m_num_intervals);

  for (int i = 0; i < track.m_num_intervals; i++) {
    CHECK(
        synctrack_deserialized.m_interval_start_ratio[i]
        == track.m_interval_start_ratio[i]);
    CHECK(
        synctrack_deserialized.m_interval_duration_ratio[i]
        == track.m_interval_duration_ratio[i]);
  }
}