<?php

namespace App\View;

use App\Sim\Terrain;
use JumPHP\Renderer\Renderer;
use JumPHP\Renderer\Sdl;

/**
 * The picture of a Terrain: a GD image painted from its mask (earth texture, grass on top, dark edges, steel
 * plates), cut into chunk textures. What the Lumikins dig or build (Terrain::$changes) is replayed on the image and
 * only the chunks touched are sent again, a few per frame.
 */
final class TerrainView
{
    public const CW = 64;
    public const CH = 58;
    private \GdImage $image;
    private int $cols;
    private int $rows;
    /** @var array<int, true> chunk index => must be sent again */
    private array $dirty = [];
    /** @var array<int, bool> chunk index => has a texture */
    private array $has = [];
    private int $clear;
    /** @var int[] */
    private array $brick;
    /** @var array<int, true> chunk index => changed since the 3D view (World3d) last looked */
    public array $touched = [];

    public function __construct(private Sdl $sdl, private Terrain $terrain, string $earthFile, string $steelFile, array $theme, private int $k = 1)
    {
        $w = $terrain->width;
        $h = $terrain->height;
        $this->cols = (int)ceil($w / self::CW);
        $this->rows = (int)ceil($h / self::CH);
        $k = $this->k;
        $img = imagecreatetruecolor($w * $k, $h * $k);
        imagealphablending($img, false);
        imagesavealpha($img, true);
        $this->clear = imagecolorallocatealpha($img, 0, 0, 0, 127);
        imagefill($img, 0, 0, $this->clear);
        $this->brick = [imagecolorallocate($img, 244, 200, 130), imagecolorallocate($img, 190, 132, 70), imagecolorallocate($img, 120, 76, 40)];
        $earth = imagecreatefrompng($earthFile);
        $steel = imagecreatefrompng($steelFile);
        $tiles = [Terrain::EARTH => [$earth, imagesx($earth), imagesy($earth)], Terrain::STEEL => [$steel, imagesx($steel), imagesy($steel)]];
        $tiles[Terrain::BRICK] = $tiles[Terrain::EARTH];

        for ($y = 0; $y < $h; $y++) {
            $row = substr($terrain->mask, $y * $w, $w);
            if (trim($row, "\0") === '') {
                continue;
            }
            for ($x = 0; $x < $w;) {
                $c = $row[$x];
                $n = strspn($row, $c, $x);
                if ($c !== "\0") {
                    [$tile, $tw, $th] = $tiles[ord($c)];
                    for ($px = $x * $k; $px < ($x + $n) * $k;) {
                        $len = min($tw - $px % $tw, ($x + $n) * $k - $px);
                        for ($sy = $y * $k; $sy < ($y + 1) * $k; $sy++) {
                            imagecopy($img, $tile, $px, $sy, $px % $tw, $sy % $th, $len, 1);
                        }
                        $px += $len;
                    }
                }
                $x += $n;
            }
        }

        // surfaces: grass on what faces the sky, a shadow under it, a dark line under overhangs
        $grass = array_map(fn (string $c) => self::color($img, $c), $theme['grass']);
        $edge = self::color($img, $theme['edge']);
        imagealphablending($img, true);
        $shade = imagecolorallocatealpha($img, 0, 0, 0, 96);
        $light = imagecolorallocatealpha($img, 255, 255, 255, 104);
        $mask = $terrain->mask;
        $depth = [];
        for ($i = 0; $i < 8; $i++) {
            $depth[] = imagecolorallocatealpha($img, 0, 0, 0, 70 + $i * 7);
        }
        $dot = static function (int $x, int $y, int $color) use ($img, $k): void {
            $k === 1 ? imagesetpixel($img, $x, $y, $color) : imagefilledrectangle($img, $x * $k, $y * $k, $x * $k + $k - 1, $y * $k + $k - 1, $color);
        };
        for ($x = 0; $x < $w; $x++) {
            $prev = "\0";
            for ($y = 0; $y < $h; $y++) {
                $c = $mask[$y * $w + $x];
                if ($c !== "\0" && $prev === "\0") {
                    if ($c === "\1") {
                        $tuft = 2 + (($x * 7 + ($x >> 2) * 13) % 3);
                        if ($k === 1) {
                            for ($d = 0; $d < 7 && $y + $tuft + 2 + $d < $h && $mask[($y + $tuft + 2 + $d) * $w + $x] === "\1"; $d++) {
                                $dot($x, $y + $tuft + 2 + $d, $shade);
                            }
                        } else {
                            // HD: the soil gets darker little by little under the grass, a line of light just below it
                            for ($d = 0; $d < 16 && $y + $tuft + 1 + $d < $h && $mask[($y + $tuft + 1 + $d) * $w + $x] === "\1"; $d++) {
                                $dot($x, $y + $tuft + 1 + $d, $depth[min(7, $d >> 1)]);
                            }
                        }
                        if ($k === 1) {
                            for ($d = 0; $d < $tuft + 2 && $y + $d < $h && $mask[($y + $d) * $w + $x] === "\1"; $d++) {
                                imagesetpixel($img, $x, $y + $d, $d < 1 ? $grass[0] : ($d < $tuft ? $grass[1] : $grass[2]));
                            }
                        } else {
                            // HD: thin blades, one per real pixel column, of uneven lengths, a bright tip
                            for ($sx = $x * $k; $sx < ($x + 1) * $k; $sx++) {
                                $len = ($tuft + 1) * $k + (($sx * 5 + ($sx >> 1) * 3) % 5) - 2;
                                $top = $y * $k - (($sx * 3 + ($sx >> 2)) % 3);
                                imageline($img, $sx, $top, $sx, $top + 2, $grass[0]);
                                imageline($img, $sx, $top + 3, $sx, $top + (int)($len * 0.6), $grass[1]);
                                imageline($img, $sx, $top + (int)($len * 0.6) + 1, $sx, $top + $len, $grass[2]);
                            }
                        }
                    } else {
                        $dot($x, $y, $light);
                    }
                } elseif ($c === "\0" && $prev !== "\0" && $y >= 2) {
                    $dot($x, $y - 1, $edge);
                    $dot($x, $y - 2, $shade);
                }
                $prev = $c;
            }
        }
        for ($y = 0; $y < $h; $y++) {   // left / right faces
            $row = substr($mask, $y * $w, $w);
            for ($x = 0; $x < $w;) {
                $c = $row[$x];
                $n = strspn($row, $c, $x);
                if ($c !== "\0") {
                    if ($x > 0) {
                        imagefilledrectangle($img, $x * $k, $y * $k, $x * $k, $y * $k + $k - 1, $edge);
                        if ($k > 1 && $n > 2) {   // HD: a lit bevel on faces turned to the left, shade on the others
                            imagefilledrectangle($img, $x * $k + 1, $y * $k, $x * $k + $k + 1, $y * $k + $k - 1, $light);
                        }
                    }
                    if ($k > 1 && $x + $n < $w && $n > 2) {
                        imagefilledrectangle($img, ($x + $n - 2) * $k, $y * $k, ($x + $n) * $k - 2, $y * $k + $k - 1, $shade);
                    }
                    if ($x + $n < $w) {
                        imagefilledrectangle($img, ($x + $n) * $k - 1, $y * $k, ($x + $n) * $k - 1, $y * $k + $k - 1, $edge);
                    }
                }
                $x += $n;
            }
        }
        imagealphablending($img, false);
        $this->image = $img;
        for ($i = 0; $i < $this->cols * $this->rows; $i++) {
            $this->dirty[$i] = true;
        }
        $this->refresh(9999);
    }

    private static function color(\GdImage $img, string $hex): int
    {
        $c = \JumPHP\Util\Color::of($hex);
        return imagecolorallocate($img, $c->r, $c->g, $c->b);
    }

    /** Replays the terrain's changes on the picture and sends up to $max chunks again. */
    public function refresh(int $max = 3): void
    {
        $k = $this->k;
        foreach ($this->terrain->changes as [$y, $x0, $x1, $material]) {
            if ($material === Terrain::EMPTY) {
                imagefilledrectangle($this->image, $x0 * $k, $y * $k, $x1 * $k + $k - 1, $y * $k + $k - 1, $this->clear);
            } else {
                for ($x = $x0; $x <= $x1; $x++) {
                    imagefilledrectangle($this->image, $x * $k, $y * $k, $x * $k + $k - 1, $y * $k + $k - 1, $this->brick[($y & 1) ? (($x + ($y >> 1)) % 6 === 0 ? 2 : 1) : 0]);
                }
            }
            $row = intdiv($y, self::CH) * $this->cols;
            for ($c = intdiv($x0, self::CW); $c <= intdiv($x1, self::CW); $c++) {
                $this->dirty[$row + $c] = true;
            }
            // the 3D faces of a pixel depend on its neighbours: the chunks around a change may change too
            for ($ty = intdiv(max(0, $y - 1), self::CH); $ty <= intdiv(min($this->terrain->height - 1, $y + 1), self::CH); $ty++) {
                for ($c = intdiv(max(0, $x0 - 1), self::CW); $c <= intdiv(min($this->terrain->width - 1, $x1 + 1), self::CW); $c++) {
                    $this->touched[$ty * $this->cols + $c] = true;
                }
            }
        }
        $this->terrain->changes = [];
        foreach (array_keys($this->dirty) as $i) {
            if ($max-- <= 0) {
                break;
            }
            unset($this->dirty[$i]);
            $cx = ($i % $this->cols) * self::CW;
            $cy = intdiv($i, $this->cols) * self::CH;
            $name = "terrain-$i";
            if (!$this->terrain->anySolid($cx, $cy, self::CW, self::CH)) {
                if ($this->has[$i] ?? false) {
                    $this->sdl->releaseTexture($name);
                }
                $this->has[$i] = false;
                continue;
            }
            $w = min(self::CW, $this->terrain->width - $cx);
            $h = min(self::CH, $this->terrain->height - $cy);
            // one more level pixel on the right and below (the neighbour's): no seam between chunks when scaled smoothly
            $pw = min($w + 1, $this->terrain->width - $cx) * $k;
            $ph = min($h + 1, $this->terrain->height - $cy) * $k;
            $part = imagecreatetruecolor($pw, $ph);
            imagealphablending($part, false);
            imagecopy($part, $this->image, 0, 0, $cx * $k, $cy * $k, $pw, $ph);
            \SDL_SetHint(\SDL_HINT_RENDER_SCALE_QUALITY, $k > 1 ? '1' : '0');   // HD ground: smooth when the window is not 3x
            $this->sdl->createTextureFromGd($name, $part);
            \SDL_SetHint(\SDL_HINT_RENDER_SCALE_QUALITY, '0');
            $this->has[$i] = true;
        }
    }

    public function cols(): int
    {
        return $this->cols;
    }

    public function rows(): int
    {
        return $this->rows;
    }

    public function scale(): int
    {
        return $this->k;
    }

    /**
     * The picture of one chunk for a GL texture: its width and height (pixels of the picture) and its pixels. With
     * $argb (imagegd() exists) the bytes are GD's own A R G B (alpha 0 = opaque .. 127 = clear), decoded by the shader:
     * no loop over the pixels in PHP. @return array{0: int, 1: int, 2: string}
     */
    public function chunkPixels(int $i, bool $argb): array
    {
        $cx = ($i % $this->cols) * self::CW;
        $cy = intdiv($i, $this->cols) * self::CH;
        $k = $this->k;
        $pw = min(self::CW, $this->terrain->width - $cx) * $k;
        $ph = min(self::CH, $this->terrain->height - $cy) * $k;
        $part = imagecreatetruecolor($pw, $ph);
        imagealphablending($part, false);
        imagesavealpha($part, true);
        imagecopy($part, $this->image, 0, 0, $cx * $k, $cy * $k, $pw, $ph);
        if (!$argb) {
            return [$pw, $ph, \JumPHP\Gl\WebGl::rgbaFromGd($part)];
        }
        ob_start();
        imagegd($part);
        $bytes = (string)ob_get_clean();
        return [$pw, $ph, substr($bytes, strlen($bytes) - $pw * $ph * 4)];
    }

    public function render(Renderer $r, float $camX, float $camY = 0): void
    {
        $first = max(0, intdiv((int)$camX, self::CW));
        $last = min($this->cols - 1, intdiv((int)$camX + $r->getWidth(), self::CW));
        for ($row = 0; $row < $this->rows; $row++) {
            for ($c = $first; $c <= $last; $c++) {
                $i = $row * $this->cols + $c;
                if ($this->has[$i] ?? false) {
                    $t = $this->sdl->getTexture("terrain-$i");
                    // the texture holds one more level pixel on the right and below: chunks overlap, no gap at any zoom
                    $r->copy($t['texture'], null, $c * self::CW - $camX, $row * self::CH - $camY, $t['width'] / $this->k, $t['height'] / $this->k);
                }
            }
        }
    }

    public function release(): void
    {
        foreach ($this->has as $i => $has) {
            if ($has) {
                $this->sdl->releaseTexture("terrain-$i");
            }
        }
        $this->has = [];
    }
}