<?php

namespace App\View;

use JumPHP\Gl\Mat4;

/**
 * The camera of the 3D view, pure math (no GL: tested without a window). The level is the plane z = 0 in 3D, x to
 * the right, level y downwards (3D y = -level y); the terrain is extruded from z = -DEPTH / 2 to +DEPTH / 2.
 *
 * At yaw 0 the plane z = 0 is seen exactly like the 2D view (camX, camY, zoom): the same level point under the same
 * view pixel. A yaw turns the camera around the vertical axis through the middle of the view, and tilts it down a
 * little (PITCH_PER_YAW) so that the tops of the ground show.
 */
final class Camera3d
{
    public const VIEW_W = 480;
    public const VIEW_H = 270;
    public const FOV = 30.0;
    public const DEPTH = 24.0;
    /** the camera looks down by this many degrees per degree of yaw */
    public const PITCH_PER_YAW = 0.3;

    /** @var float[] */
    public array $eye;
    /** @var float[] */
    public array $target;
    /** @var float[] unit vectors of the camera: right, up, forward (towards the target) */
    public array $right;
    public array $up;
    public array $forward;
    public float $distance;
    private float $tanHalf;
    /** @var float[]|null */
    private ?array $mvp = null;

    public function __construct(public readonly float $camX, public readonly float $camY, public readonly float $zoom, public readonly float $yaw,
                                float $shakeY = 0.0)
    {
        $this->tanHalf = tan(deg2rad(self::FOV) / 2);
        $tx = $camX + self::VIEW_W / 2 / $zoom;
        $ty = $camY + self::VIEW_H / 2 / $zoom + $shakeY;
        $this->distance = self::VIEW_H / 2 / $zoom / $this->tanHalf;
        $a = deg2rad($yaw);
        $p = deg2rad(abs($yaw) * self::PITCH_PER_YAW);
        $this->target = [$tx, -$ty, 0.0];
        $d = $this->distance;
        $this->eye = [$tx + $d * sin($a) * cos($p), -$ty + $d * sin($p), $d * cos($a) * cos($p)];
        $f = [-sin($a) * cos($p), -sin($p), -cos($a) * cos($p)];
        $r = [cos($a), 0.0, -sin($a)];
        $this->forward = $f;
        $this->right = $r;
        // up = right x forward
        $this->up = [$r[1] * $f[2] - $r[2] * $f[1], $r[2] * $f[0] - $r[0] * $f[2], $r[0] * $f[1] - $r[1] * $f[0]];
    }

    /** @return float[] projection x view, for the shaders */
    public function mvp(): array
    {
        return $this->mvp ??= Mat4::multiply(
            Mat4::perspective(self::FOV, self::VIEW_W / self::VIEW_H, $this->distance * 0.05, $this->distance * 30),
            Mat4::lookAt($this->eye, $this->target),
        );
    }

    /**
     * A level point to view pixels (0..480, 0..270). @return float[]|null [x, y] or null when behind the camera
     */
    public function project(float $x, float $y, float $z = 0.0): ?array
    {
        $p = Mat4::project($this->mvp(), [$x, -$y, $z], self::VIEW_W, self::VIEW_H);
        return $p === null ? null : [$p[0], $p[1]];
    }

    /**
     * The level point under a view pixel: the ray from the camera through it, cut by the plane z = $planeZ (0: the
     * middle of the level's depth, where the Lumikins walk). @return float[]|null [x, y] level coordinates
     */
    public function unproject(float $vx, float $vy, float $planeZ = 0.0): ?array
    {
        $dir = $this->ray($vx, $vy);
        if (abs($dir[2]) < 1e-6) {
            return null;
        }
        $t = ($planeZ - $this->eye[2]) / $dir[2];
        if ($t <= 0) {
            return null;
        }
        return [$this->eye[0] + $t * $dir[0], -($this->eye[1] + $t * $dir[1])];
    }

    /** The direction (not normalised) of the ray from the eye through a view pixel, in 3D. @return float[] */
    public function ray(float $vx, float $vy): array
    {
        $nx = $vx / (self::VIEW_W / 2) - 1;
        $ny = 1 - $vy / (self::VIEW_H / 2);
        $sx = $nx * $this->tanHalf * self::VIEW_W / self::VIEW_H;
        $sy = $ny * $this->tanHalf;
        $dir = [];
        for ($i = 0; $i < 3; $i++) {
            $dir[$i] = $this->forward[$i] + $this->right[$i] * $sx + $this->up[$i] * $sy;
        }
        return $dir;
    }

    /**
     * The level columns that can be seen (the corners of the level part of the view, on the front and back
     * planes), widened by $margin. @return float[] [x0, x1]
     */
    public function visibleX(float $levelViewH = 232, float $margin = 24): array
    {
        $x0 = INF;
        $x1 = -INF;
        foreach ([[0, 0], [self::VIEW_W, 0], [0, $levelViewH], [self::VIEW_W, $levelViewH], [0, $levelViewH / 2], [self::VIEW_W, $levelViewH / 2]] as [$vx, $vy]) {
            foreach ([-self::DEPTH / 2, self::DEPTH / 2] as $z) {
                $p = $this->unproject($vx, $vy, $z);
                if ($p === null) {
                    return [-INF, INF];
                }
                $x0 = min($x0, $p[0]);
                $x1 = max($x1, $p[0]);
            }
        }
        return [$x0 - $margin, $x1 + $margin];
    }

    /** Distance along the view direction (bigger = nearer the camera): back-to-front sorting. */
    public function nearness(float $x, float $y, float $z = 0.0): float
    {
        return -($x * $this->forward[0] - $y * $this->forward[1] + $z * $this->forward[2]);
    }
}