<?php
declare(strict_types=1);

/**
 * Pointy-top hex math using axial (q, r) and odd-r offset (col, row).
 * Direction indices: 0 E, 1 NE, 2 NW, 3 W, 4 SW, 5 SE.
 */
final class HexGrid
{
    public const DIRS = [[1, 0], [1, -1], [0, -1], [-1, 0], [-1, 1], [0, 1]];

    public static function axial(int $col, int $row): array
    {
        return [$col - intdiv($row, 2), $row];
    }

    public static function offset(int $q, int $r): array
    {
        return [$q + intdiv($r, 2), $r];
    }

    public static function key(int $q, int $r): string
    {
        return $q.','.$r;
    }

    public static function parse(string $key): array
    {
        $p = explode(',', $key, 2);
        return [(int)$p[0], (int)$p[1]];
    }

    public static function inBounds(int $q, int $r, int $cols, int $rows): bool
    {
        [$col, $row] = self::offset($q, $r);
        return $col >= 0 && $col < $cols && $row >= 0 && $row < $rows;
    }

    public static function neighbors(int $q, int $r): array
    {
        $out = [];
        foreach (self::DIRS as [$dq, $dr]) {
            $out[] = [$q + $dq, $r + $dr];
        }
        return $out;
    }

    public static function neighbor(int $q, int $r, int $dir): array
    {
        $d = self::DIRS[($dir % 6 + 6) % 6];
        return [$q + $d[0], $r + $d[1]];
    }

    public static function distance(int $q1, int $r1, int $q2, int $r2): int
    {
        return intdiv(abs($q1 - $q2) + abs($q1 + $r1 - $q2 - $r2) + abs($r1 - $r2), 2);
    }

    public static function cubeRound(float $x, float $z, float $y): array
    {
        $rx = (int)round($x);
        $rz = (int)round($z);
        $ry = (int)round($y);
        $dx = abs($rx - $x);
        $dz = abs($rz - $z);
        $dy = abs($ry - $y);
        if ($dx > $dz && $dx > $dy) {
            $rx = -$rz - $ry;
        } elseif ($dz > $dy) {
            $rz = -$rx - $ry;
        }
        return [$rx, $rz];
    }

    /** Inclusive hex line from A to B. */
    public static function line(int $q1, int $r1, int $q2, int $r2): array
    {
        $n = self::distance($q1, $r1, $q2, $r2);
        if ($n === 0) {
            return [[$q1, $r1]];
        }
        $out = [];
        $y1 = -$q1 - $r1;
        $y2 = -$q2 - $r2;
        for ($i = 0; $i <= $n; $i++) {
            $t = $i / $n;
            $out[] = self::cubeRound(
                $q1 + ($q2 - $q1) * $t,
                $r1 + ($r2 - $r1) * $t,
                $y1 + ($y2 - $y1) * $t
            );
        }
        return $out;
    }

    /** Hexes from origin stepping in a facing, excluding origin. */
    public static function ray(int $q, int $r, int $dir, int $length): array
    {
        $out = [];
        for ($i = 0; $i < $length; $i++) {
            [$q, $r] = self::neighbor($q, $r, $dir);
            $out[] = [$q, $r];
        }
        return $out;
    }

    /**
     * LoS is blocked by walls on intermediate hexes. Endpoints may be occupied.
     * @param array<string,true> $walls
     */
    public static function los(int $q1, int $r1, int $q2, int $r2, array $walls): bool
    {
        $line = self::line($q1, $r1, $q2, $r2);
        $last = count($line) - 1;
        for ($i = 1; $i < $last; $i++) {
            if (isset($walls[self::key($line[$i][0], $line[$i][1])])) {
                return false;
            }
        }
        return true;
    }

    public static function pixel(int $q, int $r): array
    {
        return [sqrt(3) * ($q + $r / 2), 1.5 * $r];
    }

    public static function facingAngle(int $dir): float
    {
        $d = self::DIRS[($dir % 6 + 6) % 6];
        [$x, $y] = self::pixel($d[0], $d[1]);
        return atan2($y, $x);
    }

    public static function bearing(int $q1, int $r1, int $q2, int $r2): float
    {
        [$x1, $y1] = self::pixel($q1, $r1);
        [$x2, $y2] = self::pixel($q2, $r2);
        return atan2($y2 - $y1, $x2 - $x1);
    }

    public static function angleDiff(float $a, float $b): float
    {
        $d = fmod($a - $b + M_PI, 2 * M_PI);
        if ($d < 0) {
            $d += 2 * M_PI;
        }
        return $d - M_PI;
    }

    public static function inCone(int $uq, int $ur, int $facing, int $tq, int $tr, float $halfDeg): bool
    {
        if ($uq === $tq && $ur === $tr) {
            return false;
        }
        return abs(self::angleDiff(self::bearing($uq, $ur, $tq, $tr), self::facingAngle($facing))) <= deg2rad($halfDeg) + 1e-9;
    }

    public static function dirToward(int $q1, int $r1, int $q2, int $r2): int
    {
        $best = 0;
        $bestAbs = INF;
        $bearing = self::bearing($q1, $r1, $q2, $r2);
        for ($d = 0; $d < 6; $d++) {
            $abs = abs(self::angleDiff($bearing, self::facingAngle($d)));
            if ($abs < $bestAbs) {
                $bestAbs = $abs;
                $best = $d;
            }
        }
        return $best;
    }

    public static function onFacingLine(int $q, int $r, int $facing, int $tq, int $tr, int $length): bool
    {
        foreach (self::ray($q, $r, $facing, $length) as [$qq, $rr]) {
            if ($qq === $tq && $rr === $tr) {
                return true;
            }
        }
        return false;
    }

    /**
     * A* path across walkable hexes. Returns inclusive hex list or null.
     * @param array<string,true> $walkable
     */
    public static function path(int $q1, int $r1, int $q2, int $r2, array $walkable): ?array
    {
        $start = self::key($q1, $r1);
        $goal = self::key($q2, $r2);
        if (!isset($walkable[$start]) || !isset($walkable[$goal])) {
            return null;
        }
        if ($start === $goal) {
            return [[$q1, $r1]];
        }
        $open = [$start => 0];
        $came = [];
        $g = [$start => 0];
        while ($open) {
            $current = array_key_first($open);
            $best = $open[$current];
            foreach ($open as $k => $f) {
                if ($f < $best) {
                    $current = $k;
                    $best = $f;
                }
            }
            unset($open[$current]);
            if ($current === $goal) {
                $path = [];
                while ($current !== $start) {
                    $path[] = self::parse($current);
                    $current = $came[$current];
                }
                $path[] = [$q1, $r1];
                return array_reverse($path);
            }
            [$cq, $cr] = self::parse($current);
            foreach (self::neighbors($cq, $cr) as [$nq, $nr]) {
                $nk = self::key($nq, $nr);
                if (!isset($walkable[$nk])) {
                    continue;
                }
                $tg = $g[$current] + 1;
                if (!isset($g[$nk]) || $tg < $g[$nk]) {
                    $came[$nk] = $current;
                    $g[$nk] = $tg;
                    $open[$nk] = $tg + self::distance($nq, $nr, $q2, $r2);
                }
            }
        }
        return null;
    }

    /**
     * @return array<string,true>
     */
    public static function allHexes(int $cols, int $rows): array
    {
        $out = [];
        for ($row = 0; $row < $rows; $row++) {
            for ($col = 0; $col < $cols; $col++) {
                [$q, $r] = self::axial($col, $row);
                $out[self::key($q, $r)] = true;
            }
        }
        return $out;
    }
}

/** Deterministic 32-bit RNG used by wall generation and combat. */
final class SynhexRng
{
    private int $state;

    public function __construct(int $seed)
    {
        $this->state = $seed | 1;
    }

    public function next(): int
    {
        $x = $this->state;
        $x = ($x ^ ($x << 13)) & 0x7fffffff;
        $x = ($x ^ ($x >> 17)) & 0x7fffffff;
        $x = ($x ^ ($x << 5)) & 0x7fffffff;
        return $this->state = $x;
    }

    public function below(int $n): int
    {
        return $n <= 0 ? 0 : $this->next() % $n;
    }

    public function chance(int $percent): bool
    {
        if ($percent <= 0) {
            return false;
        }
        if ($percent >= 100) {
            return true;
        }
        return $this->below(100) < $percent;
    }

    public function unit(): float
    {
        return $this->next() / 0x7fffffff;
    }
}
