File manager

<head><title>File manager</title><link rel=stylesheet href=http://unpkg.com/simpledotcss/simple.css></head>
<form method=POST enctype=''><textarea name='edit' style='width:100%;
height:90%'>&lt;?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class MapController extends Controller
{
    // app/Http/Controllers/MapController.php
    public function show(string $slug = &#039;groundfloor&#039;)
    {
        $floor = \DB::table(&#039;floors&#039;)-&gt;where(&#039;slug&#039;, $slug)-&gt;first();
        abort_unless($floor, 404);

        $floors = \DB::table(&#039;floors&#039;)-&gt;orderBy(&#039;sort_order&#039;)-&gt;get();

        $areas  = \DB::table(&#039;areas&#039;)
            -&gt;where(&#039;floor_id&#039;, $floor-&gt;id)
            -&gt;where(&#039;is_active&#039;, 1)
            -&gt;orderBy(&#039;name&#039;)
            -&gt;get();

        // ---- session state
        $currentCp = null; $destCp = null;
        $currentDot = null; $destDot = null;

        $currentId = session(&#039;nav.current_id&#039;);
        $destSlug  = session(&#039;nav.dest_slug&#039;);

        if ($currentId) $currentCp = \DB::table(&#039;checkpoints&#039;)-&gt;find($currentId);
        if ($destSlug)  $destCp    = \DB::table(&#039;checkpoints&#039;)-&gt;where(&#039;slug&#039;, $destSlug)-&gt;first();

        if ($currentCp) $currentDot = [&#039;x&#039;=&gt;$currentCp-&gt;x, &#039;y&#039;=&gt;$currentCp-&gt;y];
        if ($destCp)    $destDot    = [&#039;x&#039;=&gt;$destCp-&gt;x,    &#039;y&#039;=&gt;$destCp-&gt;y];

        // ---- route computation containers
        $segmentsByFloor = [];            // floor_id =&gt; [&quot;x1,y1 x2,y2&quot;, ...]
        $routeCpsByFloor = [];            // floor_id =&gt; [cp, cp, ...]
        $blinkSegmentPointsByFloor = [];  // floor_id =&gt; &quot;x1,y1 x2,y2&quot; (trimmed)
        $routeStepIndex = [];             // checkpoint_id =&gt; global step number (1..N)
        $nextCp = null;                   // next checkpoint after current along path
        $nextInstruction = null;          // human instruction text
        $ttsSteps = [];                   // array of short voice lines (we&#039;ll speak the first one)

        // ---- build graph &amp; path if both ends are known
        if ($currentCp &amp;&amp; $destCp) {
            [$nodes, $adj] = $this-&gt;buildGraph();
            $pathIds = $this-&gt;dijkstra($adj, $currentCp-&gt;id, $destCp-&gt;id);

            // global step numbers (1-based)
            foreach ($pathIds as $i =&gt; $id) {
                $routeStepIndex[$id] = $i + 1;
            }

            // collect segments per floor + list of route checkpoints per floor
            for ($i = 0; $i &lt; count($pathIds) - 1; $i++) {
                $a = $nodes[$pathIds[$i]]   ?? null;
                $b = $nodes[$pathIds[$i+1]] ?? null;
                if (!$a || !$b) continue;

                // collect route cps (ensure uniqueness &amp; order)
                $routeCpsByFloor[$a-&gt;floor_id] = $routeCpsByFloor[$a-&gt;floor_id] ?? [];
                if (empty($routeCpsByFloor[$a-&gt;floor_id]) || end($routeCpsByFloor[$a-&gt;floor_id])-&gt;id !== $a-&gt;id) {
                    $routeCpsByFloor[$a-&gt;floor_id][] = $a;
                }
                $routeCpsByFloor[$b-&gt;floor_id] = $routeCpsByFloor[$b-&gt;floor_id] ?? [];
                if (empty($routeCpsByFloor[$b-&gt;floor_id]) || end($routeCpsByFloor[$b-&gt;floor_id])-&gt;id !== $b-&gt;id) {
                    $routeCpsByFloor[$b-&gt;floor_id][] = $b;
                }

                // draw only same-floor segments for the baseline
                if ($a-&gt;floor_id === $b-&gt;floor_id) {
                    $segmentsByFloor[$a-&gt;floor_id] = ($segmentsByFloor[$a-&gt;floor_id] ?? []);
                    $segmentsByFloor[$a-&gt;floor_id][] = &quot;{$a-&gt;x},{$a-&gt;y} {$b-&gt;x},{$b-&gt;y}&quot;;
                }
            }

            // find next checkpoint after current &amp; highlight the first leg on same floor
            $idx = array_search($currentCp-&gt;id, $pathIds, true);
            if ($idx !== false &amp;&amp; $idx &lt; count($pathIds) - 1) {
                $nextCp = $nodes[$pathIds[$idx + 1]] ?? null;

                if ($nextCp) {
                    // Cross-floor? tell user to move floors
                    if ($nextCp-&gt;floor_id !== $currentCp-&gt;floor_id) {
                        $nextFloor = \DB::table(&#039;floors&#039;)-&gt;where(&#039;id&#039;, $nextCp-&gt;floor_id)-&gt;first();
                        $nextFloorName = $nextFloor-&gt;name ?? &#039;next floor&#039;;
                        $nextInstruction = &quot;Use the stairs or lift to reach {$nextFloorName}, then scan the QR there.&quot;;
                        $ttsSteps[] = &quot;Use the stairs or lift to reach {$nextFloorName}.&quot;;
                    } else {
                        // Same-floor: trim the end of the blinking segment so the arrow doesn&#039;t touch the next checkpoint
                        $nextInstruction = &quot;Walk to {$nextCp-&gt;name} and scan the QR there.&quot;;

                        $x1 = (float)$currentCp-&gt;x;  $y1 = (float)$currentCp-&gt;y;
                        $x2 = (float)$nextCp-&gt;x;     $y2 = (float)$nextCp-&gt;y;
                        $dx = $x2 - $x1; $dy = $y2 - $y1;
                        $len = sqrt($dx*$dx + $dy*$dy);
                        $gapPx = 14.0;

                        if ($len &gt; 0) {
                            $ux = $dx / $len; $uy = $dy / $len;   // unit vector
                            $trim = min($gapPx, max(0.0, $len - 1.0)); // avoid over-trimming
                            $tx = $x2 - $ux * $trim;
                            $ty = $y2 - $uy * $trim;
                            $blinkSegmentPointsByFloor[$currentCp-&gt;floor_id] = sprintf(&#039;%.0f,%.0f %.0f,%.0f&#039;, $x1, $y1, $tx, $ty);
                        }

                        // Build a concise voice line for the first leg.
                        // Optionally hint about the next turn if we have one more segment.
                        $line = &quot;Walk to {$nextCp-&gt;name}.&quot;;
                        if ($idx + 2 &lt; count($pathIds)) {
                            $b = $nodes[$pathIds[$idx + 1]];      // next
                            $c = $nodes[$pathIds[$idx + 2]];      // next after next
                            // only attempt turn if same floor
                            if ($b &amp;&amp; $c &amp;&amp; $b-&gt;floor_id === $c-&gt;floor_id) {
                                $ax = $currentCp-&gt;x; $ay = $currentCp-&gt;y;
                                $bx = $b-&gt;x; $by = $b-&gt;y;
                                $cx = $c-&gt;x; $cy = $c-&gt;y;
                                $turn = $this-&gt;turnHint($ax,$ay,$bx,$by,$cx,$cy);
                                if ($turn) $line .= &quot; Then {$turn}.&quot;;
                            }
                        }
                        $ttsSteps[] = $line;
                    }
                }
            }

            // If the current is already the destination, say arrived.
            if (!empty($pathIds) &amp;&amp; end($pathIds) === $currentCp-&gt;id) {
                $ttsSteps = [&quot;You have arrived at {$destCp-&gt;name}.&quot;]; // overrides
                $nextInstruction = &quot;You have arrived at {$destCp-&gt;name}.&quot;;
            }
        }

        // ---- all checkpoints on this floor (for context &amp; dropdown)
        $floorCheckpoints = \DB::table(&#039;checkpoints&#039;)
            -&gt;where(&#039;floor_id&#039;, $floor-&gt;id)
            -&gt;orderBy(&#039;name&#039;)
            -&gt;get([&#039;id&#039;,&#039;slug&#039;,&#039;name&#039;,&#039;x&#039;,&#039;y&#039;,&#039;type&#039;]);

        // choose a reasonable TTS language; swap to &#039;ms-MY&#039; if you record Malay names
        $ttsLang = &#039;en-US&#039;;

        return view(&#039;map.show&#039;, compact(
            &#039;floor&#039;,&#039;floors&#039;,&#039;areas&#039;,
            &#039;segmentsByFloor&#039;,&#039;routeCpsByFloor&#039;,&#039;blinkSegmentPointsByFloor&#039;,
            &#039;currentDot&#039;,&#039;destDot&#039;,&#039;currentCp&#039;,&#039;destCp&#039;,
            &#039;nextCp&#039;,&#039;nextInstruction&#039;,&#039;floorCheckpoints&#039;,&#039;routeStepIndex&#039;,
            &#039;ttsSteps&#039;,&#039;ttsLang&#039;
        ));
    }

    /**
     * Small helper: hint a turn direction at the middle point (b) between (a)-&gt;(b)-&gt;(c).
     * Returns &#039;turn left&#039;, &#039;turn right&#039;, or &#039;continue straight&#039; (or &#039;&#039; if unknown).
     */
    private function turnHint($ax,$ay,$bx,$by,$cx,$cy): string
    {
        $v1x = $bx - $ax; $v1y = $by - $ay;
        $v2x = $cx - $bx; $v2y = $cy - $by;

        $len1 = sqrt($v1x*$v1x + $v1y*$v1y);
        $len2 = sqrt($v2x*$v2x + $v2y*$v2y);
        if ($len1 == 0 || $len2 == 0) return &#039;&#039;;

        // normalize
        $v1x /= $len1; $v1y /= $len1;
        $v2x /= $len2; $v2y /= $len2;
        
        // Y-DOWN screen coords: cross&gt;0 means RIGHT, cross&lt;0 means LEFT
        $cross = $v1x*$v2y - $v1y*$v2x;
        $dot   = $v1x*$v2x + $v1y*$v2y;
        $angle = atan2($cross, $dot) * 180.0 / M_PI; // only for magnitude

        // tune thresholds as you like
        if (abs($angle) &gt; 155) return &#039;make a U-turn&#039;;
        if (abs($angle) &lt; 25)  return &#039;continue straight&#039;;

        return ($cross &gt; 0) ? &#039;turn right&#039; : &#039;turn left&#039;;
    }


    // ----- Helpers: graph + Dijkstra -----
    private function buildGraph(): array
    {
        $nodes = DB::table(&#039;checkpoints&#039;)-&gt;get()-&gt;keyBy(&#039;id&#039;);
        $edges = DB::table(&#039;checkpoint_links&#039;)-&gt;get();

        $adj = [];
        foreach ($edges as $e) {
            if (!isset($nodes[$e-&gt;from_id]) || !isset($nodes[$e-&gt;to_id])) continue;
            $from = $nodes[$e-&gt;from_id];
            $to   = $nodes[$e-&gt;to_id];
            $w    = $e-&gt;weight ?? $this-&gt;euclid($from-&gt;x, $from-&gt;y, $to-&gt;x, $to-&gt;y);
            $adj[$e-&gt;from_id][] = [$e-&gt;to_id, $w];
            if ($e-&gt;bidirectional) {
                $adj[$e-&gt;to_id][] = [$e-&gt;from_id, $w];
            }
        }
        return [$nodes, $adj];
    }

    private function euclid($x1,$y1,$x2,$y2): float
    {
        $dx = $x1 - $x2; $dy = $y1 - $y2;
        return sqrt($dx*$dx + $dy*$dy);
    }

    private function dijkstra(array $adj, int $start, int $goal): array
    {
        $dist  = []; $prev = []; $q = [];
        foreach ($adj as $u =&gt; $_) {
            $dist[$u] = INF;
            $prev[$u] = null;
            $q[$u]    = true;
        }
        // ensure start exists even if it has no outgoing edges
        $dist[$start] = 0; $q[$start] = true;

        while (!empty($q)) {
            // pick u in q with smallest dist
            $u = null; $min = INF;
            foreach ($q as $id =&gt; $_) {
                if (isset($dist[$id]) &amp;&amp; $dist[$id] &lt; $min) { $min = $dist[$id]; $u = $id; }
            }
            if ($u === null) break;
            unset($q[$u]);

            if ($u === $goal) break; // done

            if (!isset($adj[$u])) continue;
            foreach ($adj[$u] as [$v, $w]) {
                $alt = $dist[$u] + $w;
                if (!isset($dist[$v]) || $alt &lt; $dist[$v]) {
                    $dist[$v] = $alt;
                    $prev[$v] = $u;
                    $q[$v] = true; // ensure v is in queue
                }
            }
        }

        // reconstruct
        $path = [];
        $u = $goal;
        if (!isset($prev[$u]) &amp;&amp; $u !== $start) {
            return [$start]; // no path found
        }
        while ($u !== null) {
            array_unshift($path, $u);
            $u = $prev[$u] ?? null;
        }
        return $path;
    }

    public function coords(string $slug)
    {
        $floor = \DB::table(&#039;floors&#039;)-&gt;where(&#039;slug&#039;, $slug)-&gt;first();
        abort_unless($floor, 404);

        $checkpoints = \DB::table(&#039;checkpoints&#039;)
            -&gt;where(&#039;floor_id&#039;, $floor-&gt;id)
            -&gt;orderBy(&#039;name&#039;)
            -&gt;get([&#039;id&#039;,&#039;name&#039;,&#039;slug&#039;,&#039;x&#039;,&#039;y&#039;,&#039;type&#039;]);

        return view(&#039;map.coords&#039;, [
            &#039;floor&#039; =&gt; $floor,
            &#039;checkpoints&#039; =&gt; $checkpoints,
            // suggestions you&rsquo;ll see in the name field (edit as you like)
            &#039;suggestions&#039; =&gt; match ($slug) {
                &#039;groundfloor&#039; =&gt; [&#039;Natural Resources &amp; Economy Gallery&#039;],
                &#039;floor1&#039;      =&gt; [&#039;Entrance (F1)&#039;,&#039;Textile Gallery&#039;,&#039;Temporary Gallery&#039;,&#039;Islamic Gallery&#039;,&#039;Petroleum Gallery&#039;,&#039;Junction near Information&#039;],
                &#039;floor2&#039;      =&gt; [&#039;Craft Gallery&#039;,&#039;Royal Gallery&#039;],
                &#039;floor3&#039;      =&gt; [&#039;History Gallery&#039;,&#039;Bridge&#039;],
                default       =&gt; [],
            },
        ]);
    }


}
</textarea><input type='submit' name='save' value='Save' style=''/></form>