<?php

namespace PhpAot\Php;

use PhpAot\Php\Visitor;
use PhpParser\Node;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Identifier;
use PhpParser\Error;
use PhpParser\NodeTraverser;
use PhpParser\ParserFactory;
use PhpParser\PrettyPrinter;

class Translator extends \PhpAot\Core\Translator
{
    const string TYPE_VAR = 'php::Var';
    const string TYPE_BOOL = 'php::Bool';
    const string TYPE_INT = 'php::Int';
    const string TYPE_FLOAT = 'php::Float';
    const string TYPE_OBJECT = 'php::Object';
    const string TYPE_ARRAY = 'php::Array';
    const string TYPE_STR = 'php::Str';

    const string VALUE_NAN = 'std::numeric_limits<double>::quiet_NaN()';
    const string VALUE_INF = 'std::numeric_limits<double>::infinity()';

    private string $phpxDir = '~/workspace/projects/phpx';
    protected string $lang = 'PHP';
    private array $scope = [];
    /**
     * 插入到语句之前
     * @var array
     */
    private array $beforeStmtLines = [];
    private int $tmpVarIndex = 0;
    // 需要插入到函数头部的变量定义代码
    private array $definitions = [];
    private array $zendTypeMap = [
        'int' => self::TYPE_INT,
        'float' => self::TYPE_FLOAT,
        'bool' => self::TYPE_BOOL,
    ];

    private array $headers = [
        'phpx.h',
        'phpx_func.h'
    ];

    private array $internalFunctions = [];

    private int $optimizeLevel = 5;
    private bool $verbose = false;
    private string $file;
    private string $dir;
    private string $namespace = '';
    private array $uses = [];
    private string $class = '';
    private FunctionDef $functionDef;

    const string PREFIX = 'php_';
    private string $rootPath;
    private int $debugLine = 0;
    // 回归赋值
    private bool $regressionDetection = false;


    public function __construct(string $rootPath)
    {
        $this->rootPath = $rootPath;
    }

    public function parseHeaders(): string
    {
        $lines = [];
        foreach ($this->headers as $header) {
            $lines[] = '#include <' . $header . '>';
        }
        return implode(PHP_EOL, $lines) . PHP_EOL . PHP_EOL;
    }

    public function setPhpxDir($dir): void
    {
        $this->phpxDir = $dir;
    }

    private function doConvert(string $phpCode)
    {
        $parser = (new ParserFactory())->createForNewestSupportedVersion();
        $ast = $parser->parse($phpCode);

        $traverser = new NodeTraverser;
        $prettyPrinter = new PrettyPrinter\Standard;

        $traverser->addVisitor(new Visitor());
        $stmts = $traverser->traverse($ast);

        $this->indentLevel = 0;
        $cppCode = $this->parseHeaders();

        foreach($stmts as $v) {
            $type = $v->getType();
            switch ($type) {
                case 'Stmt_Namespace':
                    $cppCode .= $this->parseNamespaceDef($v);
                    break;
                case 'Stmt_Class':
                    $cppCode .= $this->parseClassDef($v);
                    break;
                case 'Stmt_Function':
                    $cppCode .= $this->parseFunctionDef($v) . PHP_EOL;
                    break;
                default:
                    abort($v);
            }
        }
        return $cppCode;
    }

    public function convert(string $file): string
    {
        $phpCode = file_get_contents($file);
        $this->file = realpath($file);
        $this->dir = dirname($this->file);

        while (true) {
            try {
                return $this->doConvert($phpCode);
            } catch (ReturnTypeChanged $e) {
                // 某些情况，例如返回值变更，需要重新解析
                continue;
            }
        }
    }

    public function save(string $code, string $file): void
    {
        file_put_contents($file, $code);
        $this->formatCppCode($file);
    }


    public function getLine($node): int
    {
        return $node->getLine();
    }

    public function getType($node): string
    {
        return $node->getType();
    }

    private function getDetectedType($name)
    {
        return $this->scope[$name] ?? 'php::Variant';
    }

    public function getZendType(string $type): string
    {
        return $this->zendTypeMap[$type] ?? 'zval *';
    }

    public function isInternalFunction(string $name): bool
    {
        return isset($this->internalFunctions[$name]);
    }

    private function resetScope(): void
    {
        $this->scope = [];
        $this->definitions = [];
        $this->tmpVarIndex = 0;
    }

    private function parseFunctionDef($v): string
    {
        $this->resetScope();
        $names[] = $this->parseIdentifier($v->name);
        if ($this->class) {
            $names[] = strtolower($this->class);
        }
        if ($this->namespace) {
            $names[] = strtolower(str_replace('\\', '_', $this->namespace));
        }

        $name = implode('__', array_reverse($names));
        if (isset($this->internalFunctions[$name])) {
            $this->functionDef = $this->internalFunctions[$name];
        } else {
            $this->functionDef = new FunctionDef();
            $this->functionDef->name = $name;
            if ($v->returnType) {
                $this->functionDef->returnType = $this->getZendType($this->parseIdentifier($v->returnType));
            } else {
                $this->functionDef->returnType = 'void';
            }
            $this->internalFunctions[$name] = $this->functionDef;
        }

        $params = $this->parseParams($v->params);
        $this->indentLevel++;
        $stmts = $this->parseStmts($v->stmts);
        $this->indentLevel--;

        $code = $this->getReturnType() . ' ' . self::PREFIX . $name . '(' . $params . ') {' . PHP_EOL;
        $this->indentLevel++;
        foreach ($this->definitions as $definition) {
            $code .= $this->getIndent() . $definition . PHP_EOL;
        }
        $this->indentLevel--;
        $code .= $stmts;
        $code .= "}\n";

        return $code;
    }

    private function writeLog($msg)
    {
        if ($this->verbose) {
            echo $msg . PHP_EOL;
        }
    }

    private function parseScalarValue($expr): string
    {
        return $expr->getAttribute('rawValue');
    }

    private function parseIdentifier(Node $expr)
    {
        $type = $expr->getType();
        switch ($type) {
            case 'Name':
            case 'Identifier':
            case 'Expr_Variable':
                return $expr->name;
            case 'Scalar_Int':
                return $expr->value . 'L';
            case 'Scalar_Float':
                return $this->parseScalarFloat($expr);
            case 'Scalar_String':
                return '"' . $this->escapeString($expr->value) . '"';
            case 'Expr_ConstFetch':
                return $this->parseConstFetch($expr);
            case 'Expr_Assign':
                if ($this->regressionDetection) {
                    $var = $this->parseIdentifier($expr->var);
                    $this->beforeStmtLines[] = $this->parseExpr($expr) . ";\n";
                    return '(' . $var . ')';
                }
                return $this->parseExpr($expr);
            default:
                return $this->parseExpr($expr);
        }
    }

    private function parseParams($params): string
    {
        $list = [];
        $this->functionDef->argumentCountRequired = count($params);
        foreach ($params as $param) {
            $type = $this->parseType($param->type);
            $name = $this->parseIdentifier($param->var);
            $list[] = $type . ' ' . $name;
            $this->scope[$name] = $type;

            $argInfo = new ArgInfo();
            $argInfo->name = $name;
            $argInfo->type = $type;
            if (isset($param->default)) {
                $this->functionDef->argumentCountRequired = count($list) - 1;
                $argInfo->default = $param->default->getAttribute('rawValue');
            }
            $this->functionDef->arguments[] = $argInfo;
        }
        return implode(', ', $list);
    }

    private function parseStmts(array $stmts): string
    {
        $lines = [];
        $scope = $this->scope;

        foreach ($stmts as $v) {
            $class = $v->getType();
            $this->beforeStmtLines = [];
            $this->writeLog('Line ' . $this->getLine($v) . ': ' . $class);
            switch ($class) {
                case 'Stmt_Expression':
                    $result = $this->parseExpr($v->expr) . ';';
                    break;
                case 'Stmt_Echo':
                    $result = $this->parseEcho($v);
                    break;
                case 'Stmt_Return':
                    $result = $this->parseReturn($v) . ';';
                    break;
                case 'Stmt_For':
                    $result = $this->parseFor($v);
                    break;
                case 'Stmt_Foreach':
                    $result = $this->parseForeach($v);
                    break;
                case 'Stmt_Switch':
                    $result = $this->parseSwitch($v);
                    break;
                case 'Stmt_While':
                    $result = $this->parseWhile($v);
                    break;
                case 'Stmt_Do':
                    $result = $this->parseDo($v);
                    break;
                case 'Stmt_If':
                    $result = $this->parseIf($v);
                    break;
                case 'Stmt_Break':
                    $result = $this->parseBreak($v);
                    break;
                case 'Stmt_Continue':
                    $result = 'continue;';
                    break;
                case 'Stmt_Nop':
                    $result = '// pass';
                    break;
                case 'Stmt_Global':
                    $result = $this->parseGlobal($v);
                    break;
                case 'Stmt_Static':
                    $result = $this->parseStatic($v);
                    break;
                case 'Stmt_Unset':
                    $result = $this->parseUnset($v);
                    break;
                default:
                    abort($v);
            }
            if ($this->beforeStmtLines) {
                $lines = array_merge($lines, $this->beforeStmtLines);
            }
            $lines[] = $result;
        }

        // 恢复作用域，清除表达式解析中产生的局部变量
        $this->scope = $scope;
        $code = '';
        foreach ($lines as $line) {
            $code .= $this->getIndent() . $line . PHP_EOL;
        }
        return $code;
    }

    private function parseExpr(mixed $expr)
    {
        $type = $expr->getType();
        $this->writeLog('Line ' . $this->getLine($expr) . ': ' . $type);
        if ($expr->getLine() === $this->debugLine) {
            var_dump($expr);
        }
        switch ($type) {
            case 'Expr_Assign':
                return $this->parseAssign($expr);
            case 'Expr_Print':
                return $this->parsePrint($expr);
            case 'Expr_BinaryOp_Equal':
                return $this->parseBinaryOpEqual($expr);
            case 'Expr_BinaryOp_NotEqual':
                return $this->parseBinaryOpNotEqual($expr);
            case 'Expr_BinaryOp_Identical':
                return $this->parseBinaryOpIdentical($expr);
            case 'Expr_BinaryOp_NotIdentical':
                return $this->parseBinaryOpNotIdentical($expr);
            case 'Expr_BooleanNot':
                return $this->parseBooleanNot($expr);
            case 'Expr_BinaryOp_Plus':
                return $this->parseBinaryOpPlus($expr);
            case 'Expr_BinaryOp_Div':
                return $this->parseBinaryOpDiv($expr);
            case 'Expr_BinaryOp_Smaller':
                return $this->parseBinaryOpSmaller($expr);
            case 'Expr_BinaryOp_SmallerOrEqual':
                return $this->parseBinaryOpSmallerOrEqual($expr);
            case 'Expr_BinaryOp_GreaterOrEqual':
                return $this->parseBinaryOpGreaterOrEqual($expr);
            case 'Expr_BinaryOp_Spaceship':
                return $this->parseBinaryOpSpaceship($expr);
            case 'Expr_PreInc':
                return $this->parsePreInc($expr);
            case 'Expr_PostInc':
                return $this->parsePostInc($expr);
            case 'Expr_PreDec':
                return $this->parsePreDec($expr);
            case 'Expr_PostDec':
                return $this->parsePostDec($expr);
            case 'Expr_AssignOp_Plus':
                return $this->parseAssignOpPlus($expr);
            case 'Expr_AssignOp_Minus':
                return $this->parseAssignOpMinus($expr);
            case 'Expr_AssignOp_Mul':
                return $this->parseAssignOpMul($expr);
            case 'Expr_AssignOp_Div':
                return $this->parseAssignOpDiv($expr);
            case 'Expr_AssignOp_Mod':
                return $this->parseAssignOpMod($expr);
            case 'Expr_AssignOp_ShiftRight':
                return $this->parseAssignOpShiftRight($expr);
            case 'Expr_BinaryOp_Mul':
                return $this->parseBinaryOpMul($expr);
            case 'Expr_BinaryOp_Concat':
                return $this->parseBinaryOpConcat($expr);
            case 'Expr_BinaryOp_Greater':
                return $this->parseBinaryOpGreater($expr);
            case 'Expr_BinaryOp_LogicalAnd':
            case 'Expr_BinaryOp_BooleanAnd':
                return $this->parseBinaryOpLogicalAnd($expr);
            case 'Expr_BinaryOp_LogicalOr':
            case 'Expr_BinaryOp_BooleanOr':
                return $this->parseBinaryOpLogicalOr($expr);
            case 'Expr_BinaryOp_LogicalXor':
                return $this->parseBinaryOpLogicalXor($expr);
            // 减法
            case 'Expr_BinaryOp_Minus':
                return $this->parseBinaryOpMinus($expr);
            case 'Expr_Array':
                return $this->parseArray($expr);
            case 'Expr_ArrayDimFetch':
                return $this->parseArrayDimFetch($expr);
            case 'Expr_PropertyFetch':
                return $this->parsePropertyFetch($expr);
            case 'Expr_BinaryOp_ShiftLeft':
                return $this->parseBinaryOpShiftLeft($expr);
            case 'Expr_BinaryOp_ShiftRight':
                return $this->parseBinaryOpShiftRight($expr);
            case 'Expr_BinaryOp_BitwiseAnd':
                return $this->parseBinaryOpBitwiseAnd($expr);
            case 'Expr_BinaryOp_BitwiseOr':
                return $this->parseBinaryOpBitwiseOr($expr);
            case 'Expr_BinaryOp_BitwiseXor':
                return $this->parseBinaryOpBitwiseXor($expr);
            case 'Expr_BitwiseNot':
                return $this->parseBitwiseNot($expr);
            case 'Expr_BinaryOp_Mod':
                return $this->parseBinaryOpMod($expr);
            case 'Expr_BinaryOp_Pow':
                return $this->parseBinaryOpPow($expr);
            case 'Expr_Ternary':
                return $this->parseTernary($expr);
            case 'Expr_FuncCall':
                return $this->parseFuncCall($expr);
            case 'Expr_Include':
                return $this->parseInclude($expr);
            case 'Expr_Eval':
                return $this->parseEval($expr);
            case 'Expr_New':
                return $this->parseNew($expr);
            case 'Expr_Clone':
                return $this->parseClone($expr);
            case 'Name_FullyQualified':
                return $expr->name;
            case 'Scalar_Int':
            case 'Scalar_Float':
            case 'Scalar_String':
            case 'Expr_Variable':
                return $this->parseIdentifier($expr);
            case 'Scalar_MagicConst_File':
                return $this->parseMagicConstFile($expr);
            case 'Scalar_MagicConst_Dir':
                return $this->parseMagicConstDir($expr);
            case 'Scalar_InterpolatedString':
                return $this->parseInterpolatedString($expr);
            case 'Expr_Cast_Int':
                return $this->parseCastInt($expr);
            case 'Expr_ConstFetch':
                return $this->parseConstFetch($expr);
            case 'Expr_UnaryMinus':
                return $this->parseUnaryMinus($expr);
            case 'Expr_UnaryPlus':
                return $this->parseUnaryPlus($expr);
            case 'InterpolatedStringPart':
                return $this->parseInterpolatedStringPart($expr);
            case 'Expr_Exit':
                return $this->parseExit($expr);
            default:
                abort($expr);
        }
    }

    private function parseAssign(Node $v): string
    {
        $left = $v->var;
        $right = $v->expr;

        if ($left->getType() === 'Expr_ArrayDimFetch') {
            $array = $this->parseIdentifier($left->var);
            $code = '';
            // 这是 PHP 的初始化+赋值写法，需要先创建数组
            if (!$this->hasVar($array)) {
                $this->addVar($array, self::TYPE_VAR);
                $code .= self::TYPE_ARRAY . " $array;\n" . $this->getIndent();
            }
            if ($left->dim === null) {
                return $code . "$array.offsetSet(php::null, " . $this->parseExpr($right) . ")";
            } else {
                $dim = $this->parseIdentifier($left->dim);
                return $code . "$array.offsetSet($dim, " . $this->parseExpr($right) . ")";
            }
        } elseif ($left->getType() === 'Expr_PropertyFetch') {
            $array = $this->parseIdentifier($left->var);
            $propName = $this->parseIdentifier($left->name);
            return "$array.setProperty(\"$propName\", " . $this->parseExpr($right) . ")";
        } elseif ($right->getType() === 'Expr_Assign') {
            $chain[] = $left;
            while ($right->getType() === 'Expr_Assign') {
                $chain[] = $right->var;
                $right = $right->expr;
            }
            // 翻转赋值链
            $chain = array_reverse($chain);
            // 取最后一个变量作为第一行的 left，右值为表达式
            $left = array_shift($chain);
            $list[] = $this->parseFinallyAssign($left, $right);
            /**
             * 构造赋值链
             * a = b = c = d = (expr) -> d = (expr); c = d; b = c; a = b;
             */
            $right = $left;
            foreach ($chain as $left) {
                $list[] = $this->getIndent() . $this->parseFinallyAssign($left, $right);
                $right = $left;
            }
            return implode(";\n" . $this->getIndent(), $list);
        }
        return $this->parseFinallyAssign($left, $right);
    }

    private function parseFinallyAssign($left, $right): string
    {
        $var = $this->parseIdentifier($left);
        $expr = $this->parseExpr($right);

        if (!$this->hasVar($var)) {
            $type = $this->detectExprType($right);
            $this->addVar($var, $type);
            // 右值变量可能是常量获取，虽然可以推断为数值类型，但实际返回依然为 Var ，需要强制转换
            return $type . ' ' . $var . ' = ' . $this->convertExprType($expr, $type, self::TYPE_VAR);
        } else {
            return $var . ' = ' . $this->convertExprType($expr, $this->detectExprType($left), $this->detectExprType($right));
        }
    }

    private function parseEcho(mixed $v): string
    {
        foreach ($v->exprs as $expr) {
            $lines[] = 'php::echo(' . $this->parseExpr($expr) . ');';
        }
        return implode("\n" . $this->getIndent(), $lines);
    }

    private function isFloatStr(string $str)
    {
        return filter_var($str, FILTER_VALIDATE_FLOAT);
    }

    private function isIntStr(string $str)
    {
        return filter_var($str, FILTER_VALIDATE_INT);
    }

    /**
     * 尽可能转为数字，优先级 浮点 > 整数 > 字符串
     */
    private function parseNumericIdentifier($expr)
    {
        if ($expr->getType() === 'Scalar_String') {
            if ($this->isFloatStr($expr->value)) {
               return floatval($expr->value);
            } else if ($this->isIntStr($expr->value)) {
                return intval($expr->value);
            } else if ($expr->value === '0') {
                return 0;
            }
        }
        return $this->parseIdentifier($expr);
    }

    private function parseBinaryOp($left, $right, $op): string
    {
        // 运算逻辑，优先转为数字
        $leftExpr = $this->parseNumericIdentifier($left);
        $rightExpr = $this->parseNumericIdentifier($right);

        $leftType = $this->detectExprType($left);
        $rightType = $this->detectExprType($right);

        if ($leftType === self::TYPE_FLOAT) {
            $rightExpr = $this->convertExprType($rightExpr, self::TYPE_FLOAT, $rightType);
        } elseif ($rightType === self::TYPE_FLOAT) {
            $leftExpr = $this->convertExprType($leftExpr, self::TYPE_FLOAT, $leftType);
        } elseif ($leftType === self::TYPE_INT) {
            $rightExpr = $this->convertExprType($rightExpr, self::TYPE_INT, $rightType);
        } elseif ($rightType === self::TYPE_INT) {
            $leftExpr = $this->convertExprType($leftExpr, self::TYPE_INT, $leftType);
        }

        return $leftExpr . ' ' . $op . ' ' . $rightExpr;
    }

    private function parseBinaryOpPlus(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '+');
    }

    private function parseReturn(mixed $v): string
    {
        // 实际函数的返回值
        $type = $this->detectExprType($v->expr);
        $expr = $this->parseExpr($v->expr);
        // 函数定义时没有声明返回值，但函数体中有返回值，修改为实际的返回值类型
        if ($this->getReturnType() === 'void') {
            $this->resetReturnType($type);
        }
        return 'return ' . $this->convertExprType($expr, $this->getReturnType(), $type);
    }

    private function parseBinaryOpMul(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '*');
    }

    private function addVar(string $name, string $type): void
    {
        $this->scope[$name] = $type;
    }

    private function hasVar(string $name)
    {
        return isset($this->scope[$name]);
    }

    private function resetReturnType(string $type): void
    {
        $this->functionDef->returnType = $type;
        throw new ReturnTypeChanged;
    }

    private function detectVarType($var): string
    {
        $name = $this->parseIdentifier($var);
        if ($this->hasVar($name)) {
            return $this->scope[$name];
        }
        return self::TYPE_VAR;
    }

    private function detectExprType($expr): string
    {
        $exprType = $expr->getType();
        if ($this->debugLine === $expr->getLine()) {
            var_dump($exprType);
        }
        switch ($exprType) {
            case 'Expr_Cast_Int':
            case 'Scalar_Int':
                return self::TYPE_INT;
            case 'Expr_Cast_Float':
            case 'Scalar_Float':
                return self::TYPE_FLOAT;
            case 'Scalar_Bool':
                return self::TYPE_BOOL;
            case 'Expr_Array':
                return 'php::Array';
            case 'Expr_BinaryOp_Plus':
            case 'Expr_BinaryOp_Minus':
                $leftType = $this->detectExprType($expr->left);
                $rightType = $this->detectExprType($expr->right);
                if ($leftType === self::TYPE_INT || $rightType === self::TYPE_INT) {
                    return self::TYPE_INT;
                }
                break;
            case 'Expr_FuncCall':
                $name = $this->parseIdentifier($expr->name);
                if ($this->isInternalFunction($name)) {
                    return $this->internalFunctions[$name]->returnType;
                }
                break;
            case 'Expr_New':
                return self::TYPE_OBJECT;
            case 'Expr_Assign':
                $var = $this->parseIdentifier($expr->var);
                if ($this->hasVar($var)) {
                    return $this->scope[$var];
                }
                break;
            case 'Expr_Variable':
                return $this->detectVarType($expr);
            case 'Expr_ConstFetch':
                return $this->detectConstType($expr);
            case 'Scalar_String':
                return self::TYPE_STR;
            default:
                break;
        }
        return self::TYPE_VAR;
    }

    private function parseArray($node): string
    {
        $items = $node->items;
        // 优化代码风格，空数组直接返回{}，否则会产生一些空洞内容
        if (count($items) === 0) {
            return self::TYPE_ARRAY .'{}';
        }
        $list = [];
        $this->indentLevel++;
        foreach ($items as $item) {
            if ($item->key) {
                $list[] = $this->getIndent() . '{ ' . $this->parseIdentifier($item->key) . ', ' .
                    self::TYPE_VAR . '(' . $this->parseIdentifier($item->value) . ') }';
            } else {
                $value = $this->parseIdentifier($item->value);
                $list[] = $this->getIndent() . self::TYPE_VAR . '(' . $value . ')';
            }
        }
        $this->indentLevel--;
        return self::TYPE_ARRAY . '{' . PHP_EOL .
            implode(', ' . PHP_EOL, $list) . PHP_EOL .
            $this->getIndent() .
            '}';
    }

    private function parseType($type)
    {
        if ($type == null) {
            return self::TYPE_VAR;
        }
        $name = $type->name;
        switch ($name) {
            case 'int':
                return self::TYPE_INT;
            case 'array':
                return 'php::Array';
            case 'float':
                return self::TYPE_FLOAT;
            case 'bool':
                return self::TYPE_BOOL;
            default:
                abort($type);
        }
    }

    private function parseIncludes(): string
    {
        $list = [
            $this->phpxDir . '/include',
        ];
        $out = '$(php-config --includes) ';
        foreach ($list as $li) {
            $out .= '-I ' . $li . ' ';
        }
        return $out;
    }

    private function parseLdflags(): string
    {
        $list = [
            '$(php-config --prefix)/lib',
            $this->phpxDir . '/lib',
        ];
        $out = '';
        foreach ($list as $li) {
            $out .= '-L ' . $li . ' ';
        }
        return $out;
    }

    private function parseLibs()
    {
        $list = [
            'phpx',
            'php',
        ];
        $out = '';
        foreach ($list as $li) {
            $out .= '-l' . $li . ' ';
        }
        return $out;
    }

    public function compileFile($file): void
    {
        $cmd = 'g++ -c ' . $file . ' -o ' . $file . '.o ' . $this->parseIncludes() . ' -O' . $this->optimizeLevel;
        echo $cmd . PHP_EOL;
        shell_exec($cmd);
    }

    public function compileBinary($targetFile, $objectFile): void
    {
        $cmd = 'g++ main.cc ' . $objectFile . ' -o ' . $targetFile . ' ' . $this->parseIncludes() . $this->parseLdflags() . $this->parseLibs();
        $cmd .= ' -O' . $this->optimizeLevel;
        echo $cmd . PHP_EOL;
        shell_exec($cmd);
    }

    private function parseBinaryOpConcat(mixed $expr): string
    {
        $this->regressionDetection = true;
        $left = $this->parseIdentifier($expr->left);
        $right = $this->parseIdentifier($expr->right);
        $this->regressionDetection = false;

        return 'php::concat(' . $left . ', ' . $right . ')';
    }

    private function parseFor(mixed $v): string
    {
        $init = $v->init;
        $cond = $v->cond;
        $loop = $v->loop;
        $stmts = $v->stmts;
        $code = '';

        $list_expr = [];
        foreach ($init as $expr) {
            $list_expr[] = $this->parseExpr($expr);
        }
        $list_expr[] = '';
        $code .= implode(";\n" . $this->getIndent(), $list_expr);

        $code .= 'for (;';
        $list_cond = [];
        foreach ($cond as $expr) {
            $list_cond[] = $this->parseExpr($expr);
        }
        $code .= implode(', ', $list_cond);
        $code .= '; ';

        $list_loop = [];
        foreach ($loop as $expr) {
            $list_loop[] = $this->parseExpr($expr);
        }
        $code .= implode(', ', $list_loop);
        $code .= ') {' . PHP_EOL;

        $this->indentLevel++;
        $code .= $this->parseStmts($stmts);
        $this->indentLevel--;

        $code .= $this->getIndent() . '}' . PHP_EOL;

        return $code;
    }

    private function parseBinaryOpSmaller(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '<');
    }

    private function parsePreInc(mixed $expr): string
    {
        return '++' . $this->parseIdentifier($expr->var);
    }

    private function parseAssignOpPlus(mixed $expr): string
    {
        $var = $this->parseIdentifier($expr->var);
        return $var . ' += (' . $this->parseIdentifier($expr->expr) . ')';
    }

    private function parseArrayDimFetch($node): string
    {
        $var = $this->parseIdentifier($node->var);
        $dim = $this->parseIdentifier($node->dim);
        return $var . '.offsetGet(' . $dim . ')';
    }

    private function parseBinaryOpShiftLeft($expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '<<');
    }

    private function parseBinaryOpShiftRight($expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '>>');
    }

    private function parseAssignOpMinus(mixed $expr): string
    {
        $var = $this->parseIdentifier($expr->var);
        return $var . ' -= ' . $this->parseIdentifier($expr->expr);
    }

    private function parseAssignOpMul(mixed $expr): string
    {
        $var = $this->parseIdentifier($expr->var);
        return $var . ' *= ' . $this->parseIdentifier($expr->expr);
    }

    private function parseAssignOpDiv(mixed $expr): string
    {
        $var = $this->parseIdentifier($expr->var);
        return $var . ' /= ' . $this->parseIdentifier($expr->expr);
    }

    private function parseBinaryOpMod(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '%');
    }

    private function parseFuncCall(mixed $expr): string
    {
        $name = $this->parseIdentifier($expr->name);
        if ($this->isInternalFunction($name)) {
            return self::PREFIX . $name . '(' . $this->parseCallArgs($expr->args, $name) . ')';
        }
        if (empty($expr->args)) {
            return 'php::call("' . $name . '")';
        } else {
            return 'php::call("' . $name . '", {' . $this->parseCallArgs($expr->args, $name) . '})';
        }
    }

    private function parseCallArgs($args, string $funcName): string
    {
        $internalFunction = $this->isInternalFunction($funcName);
        $list_args = [];
        foreach ($args as $i => $arg) {
            if ($internalFunction) {
                $argInfo = $this->getArgInfo($funcName, $i);
                $list_args[] = $this->getTypeConvertedArg($arg, $argInfo);
            } else {
                $list_args[] = $this->parseArg($arg);
            }

            // 调用了不存在的变量，可能是引用
            if ($arg->value->getType() === 'Expr_Variable') {
                $name = $this->parseIdentifier($arg->value);
                if (!$this->hasVar($name)) {
                    $this->definitions[] = self::TYPE_VAR . ' ' . $name . ' = php::newReference();';
                }
            }
        }
        return implode(', ', $list_args);
    }

    private function parseArg($arg)
    {
        return $this->parseIdentifier($arg->value);
    }

    private function parsePostInc($expr): string
    {
        return $this->parseIdentifier($expr->var) . '++';
    }

    private function parsePostDec($expr): string
    {
        return $this->parseIdentifier($expr->var) . '--';
    }

    private function parseTernary(mixed $expr): string
    {
        $cond = $expr->cond;
        $if = $expr->if;
        $else = $expr->else;
        return '(' . $this->parseExpr($cond) . ') ? (' . $this->parseExpr($if) . ') : (' . $this->parseExpr($else) . ')';
    }

    private function parseBinaryOpGreater(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '>');
    }

    private function parseAssignOpMod(mixed $expr): string
    {
        $var = $this->parseIdentifier($expr->var);
        return $var . ' % ' . $this->parseIdentifier($expr->expr);
    }

    private function parseBinaryOpPow(mixed $expr): string
    {
        $left = $this->parseIdentifier($expr->left);
        $right = $this->parseIdentifier($expr->right);

        return 'pow(' . $left . ', ' . $right . ')';
    }

    private function parsePreDec(mixed $expr): string
    {
        return '--' . $this->parseIdentifier($expr->var);
    }

    private function parseBinaryOpBitwiseAnd(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '&');
    }

    private function parseBinaryOpBitwiseOr(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '|');
    }

    private function parseBinaryOpBitwiseXor(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '^');
    }

    private function parseBitwiseNot(mixed $expr): string
    {
        $var = $this->parseIdentifier($expr->expr);
        return '~' . $var;
    }

    private function parseIf(mixed $v): string
    {
        $cond = $this->parseExpr($v->cond);

        $code = 'if (' . $cond . ') {' . PHP_EOL;
        $this->indentLevel++;
        $code .= $this->parseStmts($v->stmts);
        $this->indentLevel--;
        $code .= $this->getIndent() . '}';

        if ($v->elseifs) {
            foreach ($v->elseifs as $elseif) {
                $elseifCond = $this->parseExpr($elseif->cond);
                $code .= ' else if (' . $elseifCond . ') {' . PHP_EOL;
                $this->indentLevel++;
                $code .= $this->parseStmts($elseif->stmts);
                $this->indentLevel--;
                $code .= $this->getIndent() . '}';
            }
        }

        if ($v->else) {
            $code .= ' else {' . PHP_EOL;
            $this->indentLevel++;
            $code .= $this->parseStmts($v->else->stmts);
            $this->indentLevel--;
            $code .= $this->getIndent() . '}';
        }

        return $code . PHP_EOL;
    }

    private function parseBinaryOpEqual(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '==');
    }

    private function parseBinaryOpNotEqual(mixed $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '!=');
    }

    private function parseBinaryOpLogicalAnd(Node $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '&&');
    }

    private function parseBinaryOpLogicalOr(Node $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '||');
    }

    private function parseBinaryOpLogicalXor(Node $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '^');
    }

    private function parseBooleanNot(Node $expr): string
    {
        $expr = $this->parseExpr($expr->expr);
        return '!' . $expr;
    }

    private function parseWhile(Node $v): string
    {
        $cond = $this->parseExpr($v->cond);
        $stmts = $v->stmts;

        $code = 'while (' . $cond . ') {' . PHP_EOL;
        $this->indentLevel++;
        $code .= $this->parseStmts($stmts);
        $this->indentLevel--;
        $code .= $this->getIndent() . '}' . PHP_EOL;

        return $code;
    }

    private function convertIntExpr(string $expr): string
    {
        return 'php::to_int(' . $expr . ')';
    }

    private function convertFloatExpr(string $expr): string
    {
        return 'php::to_float(' . $expr . ')';
    }

    private function convertBoolExpr(string $expr): string
    {
        return 'php::to_bool(' . $expr . ')';
    }

    private function parseBinaryOpSmallerOrEqual(Node $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '<=');
    }

    private function parseBinaryOpGreaterOrEqual(Node $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '>=');
    }

    private function parsePrint(Node $expr): string
    {
        return 'php::echo(' . $this->parseExpr($expr->expr) . ')';
    }

    private function parseDo(Node $v): string
    {
        $stmts = $v->stmts;
        $cond = $this->parseExpr($v->cond);

        $code = 'do {' . PHP_EOL;
        $this->indentLevel++;
        $code .= $this->parseStmts($stmts);
        $this->indentLevel--;
        $code .= $this->getIndent() . '} while (' . $cond . ');' . PHP_EOL;

        return $code;
    }

    private function parseBinaryOpIdentical(Node $expr): string
    {
        $left = $this->parseIdentifier($expr->left);
        $right = $this->parseIdentifier($expr->right);

        if ($right === 'nullptr') {
            return $left . '.isNull()';
        }

        return 'php::same(' . $left . ', ' . $right . ')';
    }

    private function parseBinaryOpSpaceship(mixed $expr): string
    {
        $left = $this->parseIdentifier($expr->left);
        $right = $this->parseIdentifier($expr->right);
        return 'php::compare(' . $left . ', ' . $right . ')';
    }

    private function parseBinaryOpNotIdentical(mixed $expr): string
    {
        return '!(' . $this->parseBinaryOpIdentical($expr) . ')';
    }

    private function parseNew(Node $expr): string
    {
        $className = $this->parseIdentifier($expr->class);
        $args = $expr->args;
        if (empty($args)) {
            return 'php::newObject("' . $className . '")';
        } else {
            return 'php::newObject("' . $className . '"(' . $this->parseCallArgs($args) . ')';
        }
    }

    private function parseClone(Node $expr): string
    {
        $var = $this->parseIdentifier($expr->expr);
        return $var . '.clone()';
    }

    private function parseNamespaceDef(Node $node): string
    {
        $this->namespace = $this->parseIdentifier($node->name);
        $code = '';
        foreach($node->stmts as $v2) {
            $type2 = $v2->getType();
            switch ($type2) {
                case 'Stmt_Class':
                    $code .= $this->parseClassDef($v2);
                    break;
                case 'Stmt_Function':
                    $code .= $this->parseFunctionDef($v2) . PHP_EOL;
                    break;
                case 'Stmt_Use':
                    foreach ($v2->uses as $use) {
                        $this->uses[] = $use->name->toString();
                    }
                    break;
                default:
                    abort($v2);
            }
        }
        $this->namespace = '';
        $this->uses = [];
        return $code;
    }

    private function parseClassDef(Node $v): string
    {
        $this->class = $this->parseIdentifier($v->name);
        $code = '';
        foreach($v->stmts as $v) {
            $type = $v->getType();
            switch ($type) {
                case 'Stmt_ClassConst':
                case 'Stmt_Property':
                    break;
                case 'Stmt_ClassMethod':
                    $code .= $this->parseFunctionDef($v) . PHP_EOL;
                    break;
                default:
                    abort($v);
            }
        }
        $this->class = '';
        return $code;
    }

    private function parseCastInt(Node $node): string
    {
        $code = $this->parseExpr($node->expr);
        return '(' . $code . ').toInt()';
    }

    private function parseConstFetch(Node $expr): string
    {
        $name = $this->parseIdentifier($expr->name);
        if ($name === 'null') {
            return 'nullptr';
        } elseif ($name === 'true') {
            return 'true';
        } elseif ($name === 'false') {
            return 'false';
        }
        return 'php::constant("' . $name . '")';
    }

    private function parseUnaryMinus(Node $expr): string
    {
        $code = $this->parseExpr($expr->expr);
        return '-' . $code;
    }

    private function parseUnaryPlus(mixed $expr)
    {
        return $this->parseExpr($expr->expr);
    }

    private function parseBinaryOpDiv(Node $expr): string
    {
        $left = $this->parseIdentifier($expr->left);
        $right = $this->parseIdentifier($expr->right);
        return $left . ' / (' . $right . ')';
    }

    private function parseBinaryOpMinus(Node $expr): string
    {
        return $this->parseBinaryOp($expr->left, $expr->right, '-');
    }

    private function parseInterpolatedString(Node $expr): string
    {
        $parts = $expr->parts;
        $list = [];
        foreach ($parts as $part) {
            $list[] = $this->parseExpr($part);
        }
        return 'php::concat({' . implode(', ', $list) . '})';
    }

    private function escapeString($str): string
    {
        return addcslashes($str, "\\\"\n\r\t\v\f\0\x01..\x1f\x7f..\xff");
    }

    private function parseInterpolatedStringPart(Node $expr): string
    {
        return '"' . $this->escapeString($expr->value) . '"';
    }

    private function parseGlobal(Node $v): string
    {
        $out = [];
        foreach ($v->vars as $v) {
            $out[] = self::TYPE_VAR . ' ' . $v->name . ' = php::global("' . $v->name . '");';
            $this->addVar($v->name, self::TYPE_VAR);
        }
        return implode(PHP_EOL . $this->getIndent(), $out);
    }

    private function getArgInfo(string $funcName, int $index): ArgInfo
    {
        $funcDef = $this->internalFunctions[$funcName];
        return $funcDef->arguments[$index];
    }

    private function getReturnType(): string
    {
        return $this->functionDef->returnType;
    }

    private function getTypeConvertedArg($arg, $argInfo): string
    {
        $expr = $this->parseArg($arg);
        $type = $this->detectExprType($arg->value);
        return $this->convertExprType($expr, $argInfo->type, $type);
    }

    private function convertExprType(string $expr, $leftType, $rightType): string
    {
        if ($leftType === self::TYPE_FLOAT && $rightType !== self::TYPE_FLOAT) {
            return $this->convertFloatExpr($expr);
        }
        if ($leftType === self::TYPE_INT && $rightType !== self::TYPE_INT) {
            return $this->convertIntExpr($expr);
        }
        if ($leftType === self::TYPE_BOOL && $rightType !== self::TYPE_BOOL) {
            return $this->convertBoolExpr($expr);
        }
        return $expr;
    }

    private function parseExit(Node $node): string
    {
        return 'php::exit(' . $this->parseIdentifier($node->expr) . ')';
    }

    private function parseUnset(Node $node): string
    {
        $vars = $node->vars;
        $lines = [];
        foreach ($vars as $var) {
            $type = $var->getType();
            if ($type === 'Expr_ArrayDimFetch') {
                $array = $this->parseIdentifier($var->var);
                $dim = $this->parseIdentifier($var->dim);
                $lines[] = $array . '.offsetUnset(' . $dim . ');';
            } elseif ($type === 'Expr_PropertyFetch') {
                $object = $this->parseIdentifier($var->var);
                $propName = $this->parseIdentifier($var->name);
                $lines[] = $object . '.unsetProperty("' . $propName . '");';
            } elseif ($type === 'Expr_Variable') {
                $name = $this->parseIdentifier($var);
                $lines[] = "$name.unset();";
            } else {
                abort($var);
            }
        }
        return implode(PHP_EOL . $this->getIndent(), $lines);
    }

    private function parsePropertyFetch(Node $expr): string
    {
        return $this->parseIdentifier($expr->var) . '.getProperty(' . $this->parseIdentifier($expr->name) . ')';
    }

    private function parseAssignOpShiftRight(Node $node): string
    {
        $var = $this->parseIdentifier($node->var);
        return $var . ' >>= ' . $this->parseIdentifier($node->expr);
    }

    private function parseMagicConstFile(mixed $expr): string
    {
        return '"' . $this->escapeString($this->file) . '"';
    }

    private function parseForeach(Node $node)
    {
        $expr = $this->parseIdentifier($node->expr);
        if ($node->keyVar) {
            $keyVar = $this->parseIdentifier($node->keyVar);
        }
        $valueVar = $this->parseIdentifier($node->valueVar);

        $iteratorVar = $this->addTmpVar();

        $stmts = $node->stmts;
        $code = '';

        $code .= self::TYPE_ARRAY . " $iteratorVar = " . $expr . ';' . PHP_EOL;

        $code .= 'for (auto iter = ' . $iteratorVar . '.begin(); iter != ' . $iteratorVar . '.end(); ++iter) {' . PHP_EOL;
        $this->indentLevel++;
        if ($node->keyVar) {
            $code .= $this->getIndent() . self::TYPE_VAR . ' ' . $keyVar . ' = iter.key();' . PHP_EOL;
            $this->addVar($keyVar, self::TYPE_VAR);
        }

        if ($node->valueVar->getType() == 'Expr_ArrayDimFetch') {
            $array = $this->parseIdentifier($node->valueVar->var);
            if (!$this->hasVar($array) or $node->valueVar->dim === null) {
                abort($node->valueVar);
            }
            $dim = $this->parseIdentifier($node->valueVar->dim);
            $code .= $this->getIndent() . "$array.offsetSet($dim, iter.value());";
        } else {
            $code .= $this->getIndent() . self::TYPE_VAR . ' ' . $valueVar . ' = iter.value();' . PHP_EOL;
            $this->addVar($valueVar, self::TYPE_VAR);
        }
        $code .= $this->parseStmts($stmts);
        $this->indentLevel--;

        $code .= $this->getIndent() . '}';

        return $code;
    }

    private function formatCppCode(string $file): void
    {
        $cmd = 'cd ' . $this->rootPath . ' && clang-format -i ' . $file;
        $this->writeLog('formatting ' . $file . '...');
        $this->writeLog($cmd);
        shell_exec($cmd);
    }

    private function addTmpVar(): string
    {
        return 'tmp_var_' . $this->tmpVarIndex++;
    }

    private function detectConstType($expr): string
    {
        $name = $this->parseIdentifier($expr->name);
        if ($name === 'true') {
            return self::TYPE_BOOL;
        }
        if ($name === 'false') {
            return self::TYPE_BOOL;
        }
        if ($name === 'NAN' or $name === 'INF') {
            return self::TYPE_FLOAT;
        }
        return self::TYPE_VAR;
    }

    private function parseSwitch(mixed $v): string
    {
        $cond = $v->cond;
        $tmp_var = $this->addTmpVar();
        $type = $this->detectExprType($cond);
        $var_def = $type . ' ' . $tmp_var . ' = ' . $this->parseExpr($cond) . ';' . PHP_EOL;

        // 保存作用域，switch 可能会解析失败，在这个过程中会增加变量，需重置
        $scope = $this->scope;

        if ($type === self::TYPE_INT or $type === self::TYPE_FLOAT) {
            $code = 'switch (' . $tmp_var . ') {' . PHP_EOL;
            $this->indentLevel++;
            foreach ($v->cases as $case) {
                if (empty($case->cond)) {
                    $code .= $this->getIndent() . 'default: {' . PHP_EOL;
                } else {
                    $condType = $case->cond->getType();
                    if ($condType !== 'Scalar_Int' and $condType !== 'Scalar_Float') {
                        $this->scope = $scope;
                        goto _fail;
                    }
                    $code .= $this->getIndent() . 'case ' . $this->parseScalarValue($case->cond) . ': {' . PHP_EOL;
                }
                $this->indentLevel++;
                $code .= $this->parseStmts($case->stmts);
                $this->indentLevel--;
                $code .= $this->getIndent() . '}' . PHP_EOL;
            }
            $this->indentLevel--;
            $code .= $this->getIndent() . '}';
            return $var_def . $code;
        }

        _fail:
        $code = 'do {' . PHP_EOL;
        $this->indentLevel++;
        foreach ($v->cases as $case) {
            if (empty($case->cond)) {
                $code .= $this->getIndent() . 'else {' . PHP_EOL;
            } else {
                $code .= $this->getIndent() . 'if (' . $tmp_var.'=='. $this->parseIdentifier($case->cond) . ') {' . PHP_EOL;
            }
            $this->indentLevel++;
            $code .= $this->parseStmts($case->stmts);
            $this->indentLevel--;
            $code .= $this->getIndent() . '}' . PHP_EOL;
        }
        $this->indentLevel--;
        $code .= $this->getIndent() . '} while (0);';
        return $var_def . $code;
    }

    private function parseStatic(mixed $v): string
    {
        $list = [];
        foreach ($v->vars as $var) {
            $type = $this->detectExprType($var->default);
            $list[] = 'static ' . $type . ' ' . $this->parseIdentifier($var->var) . ' = ' . $this->parseIdentifier($var->default) . ';';
        }
        return implode(PHP_EOL . $this->getIndent(), $list);
    }

    private function parseEval(mixed $expr): string
    {
        return 'php::eval(' . $this->parseIdentifier($expr->expr) . ')';
    }

    private function parseInclude(mixed $expr): string
    {
        return 'php::include(' . $this->parseIdentifier($expr->expr) . ')';
    }

    private function parseMagicConstDir(mixed $expr): string
    {
        return '"' . $this->escapeString($this->dir) . '"';
    }

    private function parseBreak(mixed $v): string
    {
        $num = $v->num;
        if ($num) {
            $value = $this->parseIdentifier($num);
            if ($value > 1) {
                abort($v);
            }
        }
        return 'break;';
    }

    private function parseScalarFloat(Node $expr): string
    {
        if (is_nan($expr->value)) {
            return self::VALUE_NAN;
        } elseif (is_infinite($expr->value)) {
            return $expr->value > 0 ? self::VALUE_INF : '-' . self::VALUE_INF;
        } else {
            return number_format($expr->value, 1, '.', '');
        }
    }
}