<?php

namespace JumPHP\Shorts;

use JumPHP\Audio\SoundManager;
use JumPHP\Kernel\Platform;

/**
 * Notes a scene plays (a collision, the next note of a Melody): heard at once through SoundManager, and, while
 * bin/jumphp video:make renders the scene (JUMPHP_VIDEO_OUT), written to <out>/notes.json for the offline mix.
 * reset() in the scene's enter(); note($time, $freq) with the scene's own clock (seconds since enter()); pump() once per frame.
 *
 * Played live, a voice is generated in PHP the first time a note is asked for, which costs a few milliseconds (a meow, 15 or more):
 * done in the middle of a bounce it makes a frame late, and in a phone's browser several times that. So the live path is cheap and
 * spread out: the voices are made at a half sample rate (Voice::LIVE_RATE), warm() queues the ones a scene will need, and pump()
 * makes at most a few milliseconds' worth of them per frame (the one a bounce needs right now first, then the others); a note
 * whose voice is not ready yet is played as soon as it is, if that is still soon enough to match its bounce.
 */
final class Recorder
{
    /** the live notes kept for notes() (tests, tools): the oldest are dropped */
    private const KEEP = 2000;
    /** a note whose voice came more than this late (seconds) is not played any more */
    private const LATE = 0.18;

    /** @var list<array{time: float, freq: float, length: float, wave: string, volume: float}> */
    private array $notes = [];
    /** @var array<string, array{0: string, 1: float, 2: float, 3: float, 4: ?float}> name => wave, freq, length, volume, asked-at (null: warm-up only) */
    private array $pending = [];
    /** voices made (live), for measuring */
    private int $made = 0;
    /** @var array<string, true> voices made (SoundManager only remembers them when it has an audio device) */
    private array $known = [];
    /** a scene that calls pump() gets the spread-out making of voices; one that never does has them made at once (as before) */
    private bool $pumped = false;
    private ?string $outDir = null;
    private bool $outKnown = false;

    public function __construct(private SoundManager $sound)
    {
    }

    /** The folder video:make writes into, or null when the scene is just played. */
    public function out(): ?string
    {
        if (!$this->outKnown) {
            $out = Platform::setting('JUMPHP_VIDEO_OUT');
            $this->outDir = $out === null || $out === '' ? null : (string)$out;
            $this->outKnown = true;
        }
        return $this->outDir;
    }

    public function isRecording(): bool
    {
        return $this->out() !== null;
    }

    public function reset(float $fadeOut = 0.0): void
    {
        $this->notes = [];
        $this->pending = [];
        $this->save();
        $out = $this->out();
        if ($out !== null) {
            file_put_contents("$out/meta.json", json_encode(['fadeOut' => $fadeOut]));
        }
    }

    public function note(float $time, float $freq, float $length = 0.35, string $wave = 'pluck', float $volume = 0.35, bool $live = true): void
    {
        $this->notes[] = ['time' => round($time, 4), 'freq' => round($freq, 3), 'length' => $length, 'wave' => $wave, 'volume' => $volume];
        if ($live && !$this->isRecording()) {          // a film is mixed offline: nothing to play (and nothing to write in the temp folder)
            $name = self::name($wave, $freq, $length);
            if ($this->ready($name)) {
                $this->sound->playSfx($name);
            } elseif ($this->pumped) {
                $this->pending[$name] = [$wave, $freq, $length, $volume, microtime(true)];
            } else {
                $this->sound->synth($name, Voice::wav($wave, $freq, $length, $volume));
                $this->known[$name] = true;
                $this->made++;
                $this->sound->playSfx($name);
            }
        }
        if (count($this->notes) > self::KEEP * 2 && !$this->isRecording()) {
            $this->notes = array_slice($this->notes, -self::KEEP);
        }
        $this->save();
    }

    /** Silences every voice playing and forgets the ones waiting (leaving a scene). */
    public function stopAll(): void
    {
        $this->pending = [];
        foreach (array_keys($this->known) as $name) {
            $this->sound->stopSfx($name);
        }
    }

    /** Queues a voice to be made in the background (one of the notes the scene is going to play). */
    public function warm(string $wave, float $freq, float $length = 0.35, float $volume = 0.35): void
    {
        if ($this->isRecording()) {
            return;
        }
        $name = self::name($wave, $freq, $length);
        if (!$this->ready($name) && !isset($this->pending[$name])) {
            $this->pending[$name] = [$wave, $freq, $length, $volume, null];
        }
    }

    /**
     * Makes the voices that wait, at most $budgetMs milliseconds of them (always one when a bounce is waiting for its note, one
     * background voice per frame otherwise). Call it once a frame, at the end of the scene's update().
     *
     * @return int how many voices were made
     */
    public function pump(float $budgetMs = 3.0): int
    {
        $this->pumped = true;
        if ($this->pending === []) {
            return 0;
        }
        $started = microtime(true);
        $made = 0;
        // the notes asked for now first
        $order = array_keys($this->pending);
        usort($order, fn (string $a, string $b): int => ($this->pending[$a][4] === null) <=> ($this->pending[$b][4] === null));
        foreach ($order as $name) {
            [$wave, $freq, $length, $volume, $asked] = $this->pending[$name];
            if ($made > 0 && (microtime(true) - $started) * 1000 >= $budgetMs) {
                break;
            }
            if ($asked === null && $made > 0) {
                break;
            }
            unset($this->pending[$name]);
            $this->sound->synth($name, Voice::wav($wave, $freq, $length, $volume));
            $this->known[$name] = true;
            $this->made++;
            $made++;
            if ($asked !== null && microtime(true) - $asked < self::LATE) {
                $this->sound->playSfx($name);
            }
        }
        return $made;
    }

    /** How many voices wait to be made. */
    public function waiting(): int
    {
        return count($this->pending);
    }

    /** How many voices were made live since the start. */
    public function made(): int
    {
        return $this->made;
    }

    /** @return list<array{time: float, freq: float, length: float, wave: string, volume: float}> */
    public function notes(): array
    {
        return $this->notes;
    }

    private function ready(string $name): bool
    {
        return isset($this->known[$name]) || $this->sound->hasSfx($name);
    }

    private static function name(string $wave, float $freq, float $length): string
    {
        return 'shorts-' . $wave . '-' . (int)round($freq) . '-' . (int)round(min(1.0, $length) * 100);
    }

    private function save(): void
    {
        $out = $this->out();
        if ($out !== null) {
            @mkdir($out, 0777, true);
            file_put_contents("$out/notes.json", json_encode($this->notes));
        }
    }
}