<?php

namespace NoccyLabs\FakeTerm;

use NoccyLabs\TermBuf\Renderer\GdRenderer;
use NoccyLabs\TermBuf\Renderer\TerminalRenderer;
use NoccyLabs\TermBuf\TerminalBuffer;

class FakeTerminal
{
    /** @var TerminalBuffer */
    private $term;

    /** @var GdRenderer */
    private $renderer;

    private $subs = [];

    private $funcs = [];

    private $execMode = null;

    private $execTarget = null;

    private $typeDelay = 100;

    private $typeJitter = 0;

    private $elapsedMs = 0;

    private $fps = 0;

    private $frame = 0;

    private $frameDuration = 0;

    private $startTime;

    private $nextStat;

    private $lastFrames;

    private $output;

    private $bookmarks = [];

    private $outputVideo = null;

    private $writtenFiles = [];

    private $cursorBlinkRate = 0;

    private $cursorStyle = GdRenderer::CURSOR_BLOCK;

    public function __construct()
    {
        $this->renderer = new GdRenderer();
        $this->dumper = new TerminalRenderer();
        
    }

    private function showStats()
    {
        if ($this->nextStat === null) {
            $this->nextStat = microtime(true) + 2;
            return;
        } elseif ($this->nextStat > microtime(true)) {
            return;
        }
        $this->nextStat = microtime(true) + 2;
        $fps = ($this->frame - $this->lastFrames) / 2;
        $this->lastFrames = $this->frame;
        fprintf(STDERR, "rendering: f=%d fps=%.1f t=%.1d\n", $this->frame, $fps, microtime(true) - $this->startTime);
    }

    public function setOutput(string $output)
    {
        $this->output = $output;
    }

    public function setOutputVideo(string $outputVideo)
    {
        $this->outputVideo = $outputVideo;
    }

    public function loadModule(string $filename)
    {
        $funcs = include $filename;
        foreach ($funcs as $name=>$func) {
            $this->funcs[$name] = $func;
        }
    }

    public function executeFile(string $filename)
    {
        $this->startTime = microtime(true);

        $this->includeFile($filename);

        echo "\r\e[K";
        if ($this->outputVideo) {
            fprintf(STDERR, "Converting %s → %s\n", $this->output, $this->outputVideo);
            passthru(sprintf("ffmpeg -v error -r %d -i %s -y %s", $this->fps, $this->output, $this->outputVideo));
            fprintf(STDERR, "Cleaning up %d files...\n", count($this->writtenFiles));
            foreach ($this->writtenFiles as $fn) {
                unlink($fn);
            }
        }

    }

    public function includeFile(string $filename)
    {
        $fp = fopen($filename, "r");
        if (!$fp) return;
        $lc = 0;
        while (!feof($fp)) {
            $lc++;
            $ln = trim(fgets($fp));
            if ("" == $ln || $ln[0] == "#") continue;
            $lb = str_getcsv($ln, " ");
            try {
                $this->evaluate($lb);
            }
            catch (\Throwable $t) {
                fprintf(STDERR, "Error executing %s line %d: %s\n", $filename, $lc, $t->getMessage());
            }
        }
        fclose($fp);
    }

    public function evaluate(array $data)
    {
        if ($this->execMode == "sub") {
            if ($data[0] == "endsub") {
                $this->execMode = null;
                $this->execTarget = null;
                return;
            }
            $this->subs[$this->execTarget]->sub[] = $data;
            return;
        }

        $args = $data;
        $cmd = array_shift($args);

        switch ($cmd) {
            case 'set':
                $prop = array_shift($args);
                $value = array_shift($args);
                $this->setProp($prop, $value);
                break;

            case 'include':
                $file = array_shift($args);
                $this->includeFile($file);
                break;

            case 'load':
                $file = array_shift($args);
                $this->loadModule($file);
                break;

            case 'sub':
                $subname = array_shift($args);
                $subargs = $args;
                $this->subs[$subname] = (object)[
                    'sub' => [],
                    'args' => $subargs
                ];
                $this->execMode = "sub";
                $this->execTarget = $subname;
                break;

            case 'log':
                echo "log: ";
                echo join("", $args);
                echo "\n";
                break;

            case 'write':
                $this->writeTerm($args);
                break;

            case 'type':
                $this->writeTerm($args, true);
                break;

            case 'writefile':
                $file = file(array_shift($args));
                $delay = intval(array_shift($args)??30);
                foreach ($file as $line) {
                    $this->writeTerm([ $line ]);
                    $this->delayMs($delay);
                }
                break;

            case 'delay':
                $delay = intval(array_shift($args));
                $this->delayMs($delay);
                break;

            case 'savepng':
                $name = array_shift($args);
                $this->writeFrame($name);
                break;

            case 'mark':
                $id = array_shift($args);
                $this->bookmarks[$id] = $this->term->getCursorPosition();
                break;

            case 'moveto':
                $id = array_shift($args);
                if (ctype_digit($id)) {
                    $line = $id;
                    $column = array_shift($args);
                } else {
                    if (!array_key_exists($id, $this->bookmarks)) break;
                    [$line, $column] = $this->bookmarks[$id];
                }
                $this->term->setCursor($line, $column);
                break;

            case 'annotate':
                $id = array_shift($args);
                if ($id[0] != "@") {
                    $text = $id;
                    $id = uniqid();
                } else {
                    $text = array_shift($args);
                }
                $line = array_shift($args);
                $column = array_shift($args);
                if ($line == "here" || $line == null) {
                    [$line,$column] = $this->term->getCursorPosition();
                } elseif ($line == "at") {
                    $bmid = $column;
                    [$line,$column] = array_key_exists($bmid, $this->bookmarks) ? $this->bookmarks[$bmid] : [0,0];
                }
                $this->renderer->addAnnotation($id, $line, $column, $text);
                break;

            case 'unannotate':
                $id = array_shift($args);
                $this->renderer->removeAnnotation($id);
                break;

            case 'clearannotate':
                $this->renderer->clearAnnotations();
                break;

            case 'annotatelength':
                $id = array_shift($args);
                $this->renderer->updateAnnotation($id, [ 'length' => intval(array_shift($args))]);
                break;

            case 'showkeys':
                $this->renderer->setKeyOverlay($args);
                break;

            case 'cursor':
                $op = array_shift($args);
                switch ($op) {
                    case 'push':
                        // push cursor position
                        break;
                    case 'pop':
                        // pop cursor position
                        break;
                    case 'blink':
                        // set cursorBlinkRate
                        $this->cursorBlinkRate = intval(array_shift($args));
                        break;
                    case 'style':
                        $style = array_shift($args);
                        switch ($style) {
                            case 'none':  $this->cursorStyle = GdRenderer::CURSOR_NONE; break;
                            case 'block': $this->cursorStyle = GdRenderer::CURSOR_BLOCK; break;
                            case 'solid': $this->cursorStyle = GdRenderer::CURSOR_SOLID; break;
                        }
                        break;
                }
                break;

            case 'clear':
                $what = array_shift($args);
                $tw = $this->term->getColumns();
                $th = $this->term->getLines();
                [$cl,$cc] = $this->term->getCursorPosition();
                $sa = $this->term->getAttributes();
                switch ($what) {
                    case 'screen':
                        for ($l = 0; $l < $th; $l++) {
                            for ($c = 0; $c < $tw; $c++) {
                                $this->term->bufferSetRaw($l, $c, [ ' ', $sa ]);
                            }
                        }
                        break;
                    case 'line':
                        for ($c = 0; $c < $tw; $c++) {
                            $this->term->bufferSetRaw($cl, $c, [ ' ', $sa ]);
                        }
                        break;
                    case 'to-eol':
                        for ($c = $cc; $c < $tw; $c++) {
                            $this->term->bufferSetRaw($cl, $c, [ ' ', $sa ]);
                        }
                        break;
                    case 'to-bol':
                        for ($c = 0; $c <= $cc; $c++) {
                            $this->term->bufferSetRaw($cl, $c, [ ' ', $sa ]);
                        }
                        break;
                    case 'above':
                        for ($l = 0; $l < $cl; $l++) {
                            for ($c = 0; $c < $tw; $c++) {
                                $this->term->bufferSetRaw($l, $c, [ ' ', $sa ]);
                            }
                        }
                        break;
                    case 'to-top':
                        for ($l = 0; $l <= $cl; $l++) {
                            for ($c = 0; $c < $tw; $c++) {
                                $this->term->bufferSetRaw($l, $c, [ ' ', $sa ]);
                            }
                        }
                        break;
                    case 'below':
                        for ($l = $cl + 1; $l < $th; $l++) {
                            for ($c = 0; $c < $tw; $c++) {
                                $this->term->bufferSetRaw($l, $c, [ ' ', $sa ]);
                            }
                        }
                        break;
                    case 'to-bottom':
                        for ($l = $cl; $l < $th; $l++) {
                            for ($c = 0; $c < $tw; $c++) {
                                $this->term->bufferSetRaw($l, $c, [ ' ', $sa ]);
                            }
                        }
                        break;
                    default:
                        fprintf(STDERR, "error: Can't clear '%s'\n", $what);
                    }
                    break;

            default:
                if (array_key_exists($cmd, $this->subs)) {
                    $this->callSub($cmd, $args);
                    return;
                }
                if (array_key_exists($cmd, $this->funcs)) {
                    $this->callFunc($cmd, $args);
                    return;
                }
                throw new \LogicException("No such command ${cmd}");
        }

    }

    public function writeFrame($name=null)
    {
        $ft = ($this->frame * $this->frameDuration);

        if ($this->cursorBlinkRate > 0) {
            //printf("\nft=%.1f r=%.1f\n", $ft, $this->cursorBlinkRate);
            $visible = (floor($ft / $this->cursorBlinkRate) % 2) == 0;
            if ($visible) {
                $this->renderer->setCursorStyle($this->cursorStyle);
            } else {
                $this->renderer->setCursorStyle(GdRenderer::CURSOR_NONE);
            }
        } else {
            $this->renderer->setCursorStyle($this->cursorStyle);
        }

        $this->renderer->render($this->term);

        if ($name) {
            $this->renderer->writePng($name);
            return;
        }

        $file = sprintf($this->output, $this->frame++);
        $this->renderer->writePng($file);

        $this->showStats();
        $this->writtenFiles[] = $file;
    }

    public function setFps(float $fps)
    {
        $this->fps = $fps;
        if ($fps > 0) {
            $this->frameDuration = 1000 / $fps;
        }
    }

    public function delayMs(int $ms)
    {
        if ($this->fps == 0) return;

        $this->elapsedMs += $ms;

        $lastFrameMs = $this->frame * $this->frameDuration;
        $nextFrameMs = $lastFrameMs + $this->frameDuration;
        while ($this->elapsedMs >= $nextFrameMs) {
            $this->writeFrame();
            $nextFrameMs += $this->frameDuration;
        }
    }

    public function writeTerm(array $args, bool $type=false)
    {
        //printf("write: %s\n", json_encode($args));
        $buf = null;
        $lastArg = null;
        while (count($args)) {
            $arg = array_shift($args);
            if ($arg && $arg[0] == "<" && strlen($arg) > 1) {
                if (substr($arg, -1, 1) == ">") {
                    $this->setupTerm(substr($arg, 1, -1));
                    continue;
                }
                $buf = [ $arg ];
                while ($tail = array_shift($args)) {
                    $buf[] = $tail;
                    if (substr($tail, -1, 1) == ">") {
                        break;
                    }
                }
                $buf = join(" ", $buf);
                $this->setupTerm(substr($buf, 1, -1));
                $buf = null;

            } elseif (preg_match('/u\{([0-9a-f]+)\}/', $arg, $match)) {

                $arg = mb_chr(hexdec($match[1]));
                $lastArg = $arg;
                //printf("write: '%s'\n", $arg);
                if (!$type) {
                    $this->term->write($arg);
                } else {
                    for ($c = 0; $c < mb_strlen($arg); $c++) {
                        $this->term->write(mb_substr($arg, $c, 1));
                        $this->delayMs($this->typeDelay + rand(-$this->typeJitter,$this->typeJitter));
                    }
                }

            } elseif (preg_match('/\*([0-9]+)/', $arg, $match)) {

                $repeat = intval($match[1]) - 1;
                
                //printf("repeat: '%s' * %d\n", $lastArg, $repeat);
                for ($n = 0; $n < $repeat; $n++) {
                    if (!$type) {
                        $this->term->write((string)$lastArg);
                    } else {
                        for ($c = 0; $c < mb_strlen($lastArg); $c++) {
                            $this->term->write(mb_substr($lastArg, $c, 1));
                            $this->delayMs($this->typeDelay + rand(-$this->typeJitter,$this->typeJitter));
                        }
                    }
                }
                
            } else {
                //printf("write: '%s'\n", $arg);
                $lastArg = $arg;
                if (!$type) {
                    $this->term->write($arg);
                } else {
                    for ($c = 0; $c < mb_strlen($arg); $c++) {
                        $this->term->write(mb_substr($arg, $c, 1));
                        $this->delayMs($this->typeDelay + rand(-$this->typeJitter,$this->typeJitter));
                    }
                }
            }
        }


    }

    public function setupTerm(string $prop) {
        $props = explode(" ", $prop);
        $mode = array_shift($props);
        switch ($mode) {

            case 'home':
                $this->term->setCursor($this->term->getCursorPosition()[0], 0);
                break;

            case 'br':
            case 'return':
                $this->term->setCursor($this->term->getCursorPosition()[0] + 1, 0);
                break;

            case 'move':
                // move [steps] <dir>
                // dir = { up, down, left, right }

            case 'erase':
                // erase <to>
                // to = { screen, to-eol, to-bol, to-top, to-bottom }
                break;

            case 'sgr':
                $sgr = [ 0 ];
                while ($k = array_shift($props)) {
                    if (strpos($k, ":")!==false) {
                        [$k,$v] = explode(":", $k, 2);
                    } else {
                        $v = true;
                    }
                    switch ($k) {
                        case 'bold':
                            $sgr[] = 1;
                            break;
                        case 'fg':
                            $sgr[] = 30 + $this->colorToIndex($v);
                            break;
                        case 'bg':
                            $sgr[] = 40 + $this->colorToIndex($v);
                            break;
                        default:
                            fprintf(STDERR, "Unknown attribute: %s\n", $k);                                
                    }
                }
                // printf("sgr: %s\n", json_encode($sgr));
                $this->term->setAttributes($sgr);
                break;

        }
    }

    private function colorToIndex(string $color):int {
        switch ($color) {
            case 'black': return 0;
            case 'red': return 1;
            case 'green': return 2;
            case 'yellow': return 3;
            case 'blue': return 4;
            case 'magenta': return 5;
            case 'cyan': return 6;
            case 'white': return 7;
        }
    }

    public function callSub(string $sub, array $args=[])
    {
        foreach ($this->subs[$sub]->sub as $data) {
            foreach ($data as $k=>$v) {
                if ($v[0] == '$' && strlen($v) > 1) {
                    $i = intval(substr($v, 1)) - 1;
                    $data[$k] = array_key_exists($i, $args)?$args[$i]:$v;
                }
            }
            $this->evaluate($data);
        }
    }

    public function callFunc(string $func, array $args=[])
    {
        call_user_func($this->funcs[$func], $this->term, ...$args);
    }

    public function setProp(string $prop, $value)
    {
        switch ($prop) {
            case 'terminal':
                [ $columns, $lines ] = explode("x", $value, 2);
                $this->setTerminalSize(intval($columns), intval($lines));
                break;
            case 'colors':
                $this->colors = intval($value);
                break;
            case 'typedelay':
                $this->typeDelay = intval($value);
                break;
            case 'typejitter':
                $this->typeJitter = intval($value);
                break;
            case 'fps':
                $this->setFps(floatval($value));
                break;
            case 'annotationsize':
                $this->annotationFontSize = intval($value);
                break;
            case 'video':
                $this->outputVideo = $value;
                break;
            default:
                throw new \LogicException("Bad property for set: ${prop}");
        }
    }

    public function setTerminalSize(int $columns, int $rows)
    {
        $this->term = new TerminalBuffer($columns, $rows);
    }

}