// This file is part of the 64k demo project.
// It tests the ring buffer under jittered consumption (stress test).

#include <stdio.h>

#if !defined(STRIP_ALL)

#include "audio/audio.h"
#include "audio/jittered_audio_backend.h"
#include "audio/synth.h"
#include "audio/tracker.h"
#include <assert.h>
#include <chrono>
#include <thread>

void test_jittered_audio_basic() {
  printf("Test: Basic jittered audio consumption...\n");

  // Initialize audio system
  synth_init();
  tracker_init();

  // Set up jittered backend with realistic parameters
  // At 32kHz, 10ms = 320 samples = 160 frames (stereo)
  // Jitter of ±5ms means 5-15ms intervals, or 80-240 frames
  JitteredAudioBackend jittered_backend;
  jittered_backend.set_base_interval(10.0f);  // 10ms base interval
  jittered_backend.set_jitter_amount(5.0f);   // ±5ms jitter
  jittered_backend.set_chunk_size_range(80, 240);  // Realistic chunk sizes for 5-15ms

  audio_set_backend(&jittered_backend);
  audio_init();

  // Start audio thread
  audio_start();
  assert(jittered_backend.is_running());

  // Simulate main loop for 2 seconds
  const float total_time = 2.0f;
  const float dt = 1.0f / 60.0f;  // 60fps
  float music_time = 0.0f;

  for (float t = 0.0f; t < total_time; t += dt) {
    music_time += dt;  // Normal tempo

    // Update tracker and fill buffer
    tracker_update(music_time);
    audio_render_ahead(music_time, dt);

    // Sleep to simulate frame time
    std::this_thread::sleep_for(std::chrono::milliseconds(16));
  }

  // Stop audio
  audio_shutdown();

  // Check results
  const int frames_consumed = jittered_backend.get_total_frames_consumed();
  const int underruns = jittered_backend.get_underrun_count();

  printf("  Frames consumed: %d\n", frames_consumed);
  printf("  Underruns: %d\n", underruns);

  // Should have consumed roughly 2 seconds worth of audio
  // At 32kHz stereo: 2 seconds = 64000 samples = 32000 frames
  assert(frames_consumed > 24000);  // At least 1.5 seconds (48000 samples)
  assert(frames_consumed < 40000);  // At most 2.5 seconds (80000 samples)

  // Underruns are acceptable in this test, but shouldn't be excessive
  assert(underruns < 50);  // Less than 50 underruns in 2 seconds

  printf("  ✓ Basic jittered audio consumption PASSED\n");
}

void test_jittered_audio_with_acceleration() {
  printf("Test: Jittered audio with tempo acceleration...\n");

  // Initialize audio system
  synth_init();
  tracker_init();

  // Set up jittered backend with aggressive settings for stress test
  // At 32kHz, 15ms = 480 samples = 240 frames (stereo)
  // Jitter of ±10ms means 5-25ms intervals, or 80-400 frames
  JitteredAudioBackend jittered_backend;
  jittered_backend.set_base_interval(15.0f);  // Slower consumption
  jittered_backend.set_jitter_amount(10.0f);  // High jitter
  jittered_backend.set_chunk_size_range(80, 400);  // Realistic stress test range

  audio_set_backend(&jittered_backend);
  audio_init();

  // Start audio thread
  audio_start();

  // Simulate acceleration scenario (similar to real demo)
  const float total_time = 10.0f;
  const float dt = 1.0f / 60.0f;
  float music_time = 0.0f;
  float physical_time = 0.0f;

  for (int frame = 0; frame < 600; ++frame) {  // 10 seconds @ 60fps
    physical_time = frame * dt;

    // Variable tempo (accelerate from 5-10s)
    float tempo_scale = 1.0f;
    if (physical_time >= 5.0f && physical_time < 10.0f) {
      const float progress = (physical_time - 5.0f) / 5.0f;
      tempo_scale = 1.0f + progress * 1.0f;  // 1.0 → 2.0
    }

    music_time += dt * tempo_scale;

    // Update tracker and fill buffer
    tracker_update(music_time);
    audio_render_ahead(music_time, dt);

    // Sleep to simulate frame time
    std::this_thread::sleep_for(std::chrono::milliseconds(16));

    // Progress indicator
    if (frame % 60 == 0) {
      printf("  Frame %d: music_time=%.2fs, tempo=%.2fx, consumed=%d frames, underruns=%d\r",
             frame, music_time, tempo_scale,
             jittered_backend.get_total_frames_consumed(),
             jittered_backend.get_underrun_count());
      fflush(stdout);
    }
  }
  printf("\n");

  // Stop audio
  audio_shutdown();

  // Check results
  const int frames_consumed = jittered_backend.get_total_frames_consumed();
  const int underruns = jittered_backend.get_underrun_count();

  printf("  Total frames consumed: %d\n", frames_consumed);
  printf("  Total underruns: %d\n", underruns);

  // Should have consumed roughly 12.5 seconds worth of audio
  // (10 seconds physical time with acceleration 1.0x → 2.0x)
  // At 32kHz stereo: 12.5 seconds = 400000 samples = 200000 frames
  assert(frames_consumed > 120000);  // At least 7.5 seconds (240000 samples)
  assert(frames_consumed < 240000);  // At most 15 seconds (480000 samples)

  // During acceleration with jitter, some underruns are expected but not excessive
  assert(underruns < 200);  // Less than 200 underruns in 10 seconds

  printf("  ✓ Jittered audio with acceleration PASSED\n");
}

int main() {
  printf("Running Jittered Audio Backend tests...\n\n");
  test_jittered_audio_basic();
  test_jittered_audio_with_acceleration();
  printf("\n✅ All Jittered Audio Backend tests PASSED\n");
  return 0;
}

#else

int main() {
  printf("Jittered Audio Backend tests skipped (STRIP_ALL enabled)\n");
  return 0;
}

#endif /* !defined(STRIP_ALL) */