unit Myc.Ast.Persistence;

interface

uses
    System.SysUtils,
    System.Json,
    System.Generics.Collections,
    Myc.Data.Scalar,
    Myc.Ast.Nodes,
    Myc.Ast.ViewModel;

type
    // Manages the serialization and deserialization of the entire editor state.
    TAstProjectPersistence = class
    private
        type
            // This helper visitor acts as a "Builder".
            // It builds the JSON result internally on a stack instead of using the return value.
            TAstToJsonVisitor = class(TInterfacedObject, IAstVisitor)
            private
                FIdMap: TDictionary<IAstNode, Integer>;
                // Tracks nodes that have already been fully serialized to prevent infinite recursion on cycles.
                FSerializedNodes: TDictionary<IAstNode, Boolean>;
                FNextId: Integer;
                FResultStack: TStack<TJSONObject>;
                function GetOrCreateNodeId(const Node: IAstNode): Integer;
                function ScalarToJson(const AValue: TScalar): TJSONObject;
            public
                constructor Create(AIdMap: TDictionary<IAstNode, Integer>);
                destructor Destroy; override;

                function GetResult: TJSONObject;

                { IAstVisitor }
                function VisitConstant(const Node: IConstantNode): TAstValue;
                function VisitIdentifier(const Node: IIdentifierNode): TAstValue;
                function VisitBinaryExpression(const Node: IBinaryExpressionNode): TAstValue;
                function VisitUnaryExpression(const Node: IUnaryExpressionNode): TAstValue;
                function VisitIfExpression(const Node: IIfExpressionNode): TAstValue;
                function VisitTernaryExpression(const Node: ITernaryExpressionNode): TAstValue;
                function VisitLambdaExpression(const Node: ILambdaExpressionNode): TAstValue;
                function VisitFunctionCall(const Node: IFunctionCallNode): TAstValue;
                function VisitBlockExpression(const Node: IBlockExpressionNode): TAstValue;
                function VisitVariableDeclaration(const Node: IVariableDeclarationNode): TAstValue;
                function VisitAssignment(const Node: IAssignmentNode): TAstValue;
                function VisitIndexer(const Node: IIndexerNode): TAstValue;
                function VisitMemberAccess(const Node: IMemberAccessNode): TAstValue;
                function VisitCreateSeries(const Node: ICreateSeriesNode): TAstValue;
                function VisitAddSeriesItem(const Node: IAddSeriesItemNode): TAstValue;
                function VisitSeriesLength(const Node: ISeriesLengthNode): TAstValue;
            end;

        function ScalarFromJson(AObject: TJSONObject): TScalar;
        function DeserializeNode(AObject: TJSONObject; ANodeIdMap: TDictionary<Integer, IAstNode>): IAstNode;

    public
        // Saves the complete state to a JSON file.
        procedure SaveToFile(
            const AFileName: string;
            const ARootNode: IAstNode;
            const ALogicalMetadata: TDictionary<IAstNode, TLogicalMetadata>;
            const AInstanceMetadata: TDictionary<TViewModelID, TVisualInstanceMetadata>
        );

        // Loads the complete state from a JSON file.
        procedure LoadFromFile(
            const AFileName: string;
            out ARootNode: IAstNode;
            out ALogicalMetadata: TDictionary<IAstNode, TLogicalMetadata>;
            out AInstanceMetadata: TDictionary<TViewModelID, TVisualInstanceMetadata>
        );

        class function AstNodeToJsonString(const ANode: IAstNode): string; static;
        class function JsonStringToAstNode(const AJsonString: string): IAstNode; static;
    end;

implementation

uses
    System.Classes,
    System.Types,
    System.Variants,
    System.Rtti,
    System.TypInfo,
    System.IOUtils,
    System.DateUtils,
    System.StrUtils,
    Myc.Data.Decimal,
    Myc.Ast;

{ TAstProjectPersistence }

procedure TAstProjectPersistence.SaveToFile(
    const AFileName: string;
    const ARootNode: IAstNode;
    const ALogicalMetadata: TDictionary<IAstNode, TLogicalMetadata>;
    const AInstanceMetadata: TDictionary<TViewModelID, TVisualInstanceMetadata>
);
var
    rootJson, astJson, logicalMetaJson, instanceMetaJson: TJSONObject;
    idMap: TDictionary<IAstNode, Integer>;
    visitor: TAstToJsonVisitor;
    pair: TPair<IAstNode, TLogicalMetadata>;
    metaPair: TPair<TViewModelID, TVisualInstanceMetadata>;
    metaValueJson: TJSONObject;
begin
    rootJson := TJSONObject.Create;
    try
        idMap := TDictionary<IAstNode, Integer>.Create;
        visitor := TAstToJsonVisitor.Create(idMap);
        try
            ARootNode.Accept(visitor);
            astJson := visitor.GetResult;
            rootJson.AddPair('ast', astJson);
        finally
            idMap.Free;
            visitor.Free;
        end;

        logicalMetaJson := TJSONObject.Create;
        for pair in ALogicalMetadata do
        begin
            var nodeIdStr := idMap[pair.Key].ToString;
            metaValueJson := TJSONObject.Create;
            metaValueJson.AddPair('NodeType', TJSONString.Create(GetEnumName(TypeInfo(TAstNodeType), Ord(pair.Value.NodeType))));
            metaValueJson.AddPair('Description', TJSONString.Create(pair.Value.Description));
            logicalMetaJson.AddPair(nodeIdStr, metaValueJson);
        end;
        rootJson.AddPair('logicalMetadata', logicalMetaJson);

        instanceMetaJson := TJSONObject.Create;
        for metaPair in AInstanceMetadata do
        begin
            var idStr := metaPair.Key.ToString;
            metaValueJson := TJSONObject.Create;
            metaValueJson.AddPair('PositionX', TJSONNumber.Create(metaPair.Value.PositionOverride.X));
            metaValueJson.AddPair('PositionY', TJSONNumber.Create(metaPair.Value.PositionOverride.Y));
            metaValueJson.AddPair('IsCollapsed', TJSONBool.Create(metaPair.Value.IsCollapsed));
            var modeStr := GetEnumName(TypeInfo(TVisualizationMode), Ord(metaPair.Value.VisualizationMode));
            metaValueJson.AddPair('VisualizationMode', TJSONString.Create(modeStr));
            instanceMetaJson.AddPair(idStr, metaValueJson);
        end;
        rootJson.AddPair('instanceMetadata', instanceMetaJson);

        TFile.WriteAllText(AFileName, rootJson.ToJSON);
    finally
        rootJson.Free;
    end;
end;

procedure TAstProjectPersistence.LoadFromFile(
    const AFileName: string;
    out ARootNode: IAstNode;
    out ALogicalMetadata: TDictionary<IAstNode, TLogicalMetadata>;
    out AInstanceMetadata: TDictionary<TViewModelID, TVisualInstanceMetadata>
);
var
    rootJson, astJson, logicalMetaJson, instanceMetaJson: TJSONObject;
    jsonValue: TJSONValue;
    nodeIdMap: TDictionary<Integer, IAstNode>;
    pair: TJSONPair;
    metaPair: TJSONPair;
    metaData: TVisualInstanceMetadata;
begin
    ARootNode := nil;
    ALogicalMetadata := TDictionary<IAstNode, TLogicalMetadata>.Create;
    AInstanceMetadata := TDictionary<TViewModelID, TVisualInstanceMetadata>.Create;

    jsonValue := TJSONObject.ParseJSONValue(TFile.ReadAllText(AFileName));
    if (not Assigned(jsonValue)) or (not (jsonValue is TJSONObject)) then
    begin
        exit;
    end;

    rootJson := jsonValue as TJSONObject;
    try
        astJson := rootJson.GetValue<TJSONObject>('ast');
        if Assigned(astJson) then
        begin
            nodeIdMap := TDictionary<Integer, IAstNode>.Create;
            try
                ARootNode := DeserializeNode(astJson, nodeIdMap);
                if not Assigned(ARootNode) then
                begin
                    exit;
                end;

                logicalMetaJson := rootJson.GetValue<TJSONObject>('logicalMetadata');
                if Assigned(logicalMetaJson) then
                begin
                    for pair in logicalMetaJson do
                    begin
                        var tempId := StrToInt(pair.JsonString.Value);
                        if nodeIdMap.ContainsKey(tempId) then
                        begin
                            var node := nodeIdMap[tempId];
                            var meta: TLogicalMetadata;
                            var metaJson := pair.JSONValue as TJSONObject;
                            meta.NodeType := TAstNodeType(GetEnumValue(TypeInfo(TAstNodeType), metaJson.GetValue<string>('NodeType')));
                            meta.Description := metaJson.GetValue<string>('Description');
                            ALogicalMetadata.Add(node, meta);
                        end;
                    end;
                end;
            finally
                nodeIdMap.Free;
            end;
        end;

        instanceMetaJson := rootJson.GetValue<TJSONObject>('instanceMetadata');
        if Assigned(instanceMetaJson) then
        begin
            for metaPair in instanceMetaJson do
            begin
                var vmId := StrToInt64(metaPair.JsonString.Value);
                var metaJson := metaPair.JsonValue as TJSONObject;

                metaData.PositionOverride.X := metaJson.GetValue<Double>('PositionX');
                metaData.PositionOverride.Y := metaJson.GetValue<Double>('PositionY');
                metaData.IsCollapsed := metaJson.GetValue<Boolean>('IsCollapsed');
                var modeStr := metaJson.GetValue<string>('VisualizationMode');
                var modeInt := GetEnumValue(TypeInfo(TVisualizationMode), modeStr);
                metaData.VisualizationMode := TVisualizationMode(modeInt);
                AInstanceMetadata.Add(vmId, metaData);
            end;
        end;

    finally
        rootJson.Free;
    end;
end;

function TAstProjectPersistence.DeserializeNode(AObject: TJSONObject; ANodeIdMap: TDictionary<Integer, IAstNode>): IAstNode;
var
    nodeTypeStr: string;
    tempId: Integer;
    i: Integer;
begin
    Result := nil;
    if not Assigned(AObject) then
    begin
        exit;
    end;

    // Handle reference nodes to break cycles during deserialization
    if AObject.GetValue('ref') <> nil then
    begin
        var refId := AObject.GetValue<Integer>('ref');
        if not ANodeIdMap.TryGetValue(refId, Result) then
            // A forward reference indicates a cycle that cannot be resolved with the current immutable AST node creation.
            // The referenced node has not been fully constructed yet.
            raise ENotImplemented.CreateFmt(
                'Forward reference to node ID %d encountered. This is not supported by the current deserialization logic.',
                [refId]);
        exit;
    end;

    nodeTypeStr := AObject.GetValue<string>('type');
    tempId := AObject.GetValue<Integer>('id');

    var nodeType := TAstNodeType(GetEnumValue(TypeInfo(TAstNodeType), 'ant' + nodeTypeStr));
    case nodeType of
        antConstant: Result := TAst.Constant(ScalarFromJson(AObject.GetValue<TJSONObject>('value')));
        antIdentifier: Result := TAst.Identifier(AObject.GetValue<string>('name'));
        antBinaryExpression:
            Result :=
                TAst.BinaryExpr(
                    DeserializeNode(AObject.GetValue<TJSONObject>('left'), ANodeIdMap),
                    TBinaryOperator(GetEnumValue(TypeInfo(TBinaryOperator), 'bo' + AObject.GetValue<string>('operator'))),
                    DeserializeNode(AObject.GetValue<TJSONObject>('right'), ANodeIdMap)
                );
        antUnaryExpression:
            Result :=
                TAst.UnaryExpr(
                    TUnaryOperator(GetEnumValue(TypeInfo(TUnaryOperator), 'uo' + AObject.GetValue<string>('operator'))),
                    DeserializeNode(AObject.GetValue<TJSONObject>('right'), ANodeIdMap)
                );
        antIfExpression:
        begin
            var elseBranch: IAstNode := nil;
            if AObject.GetValue('elseBranch') <> nil then
            begin
                elseBranch := DeserializeNode(AObject.GetValue<TJSONObject>('elseBranch'), ANodeIdMap);
            end;
            Result :=
                TAst.IfExpr(
                    DeserializeNode(AObject.GetValue<TJSONObject>('condition'), ANodeIdMap),
                    DeserializeNode(AObject.GetValue<TJSONObject>('thenBranch'), ANodeIdMap),
                    elseBranch
                );
        end;
        antTernaryExpression:
            Result :=
                TAst.TernaryExpr(
                    DeserializeNode(AObject.GetValue<TJSONObject>('condition'), ANodeIdMap),
                    DeserializeNode(AObject.GetValue<TJSONObject>('thenBranch'), ANodeIdMap),
                    DeserializeNode(AObject.GetValue<TJSONObject>('elseBranch'), ANodeIdMap)
                );
        antLambdaExpression:
        begin
            var paramsJson := AObject.GetValue<TJSONArray>('parameters');
            var params := TArray<IIdentifierNode>.Create();
            SetLength(params, paramsJson.Count);
            // Important: Add the (incomplete) node to the map before deserializing children
            // to allow children to reference it.
            // However, with immutable nodes, we can't do that. The check for forward refs handles this limitation.
            for i := 0 to paramsJson.Count - 1 do
            begin
                params[i] := IIdentifierNode(DeserializeNode(paramsJson.Items[i] as TJSONObject, ANodeIdMap));
            end;
            var body := DeserializeNode(AObject.GetValue<TJSONObject>('body'), ANodeIdMap);
            Result := TAst.LambdaExpr(params, body);
        end;
        antFunctionCall:
        begin
            var callee := DeserializeNode(AObject.GetValue<TJSONObject>('callee'), ANodeIdMap);
            var argsJson := AObject.GetValue<TJSONArray>('arguments');
            var args := TArray<IAstNode>.Create();
            SetLength(args, argsJson.Count);
            for i := 0 to argsJson.Count - 1 do
            begin
                args[i] := DeserializeNode(argsJson.Items[i] as TJSONObject, ANodeIdMap);
            end;
            Result := TAst.FunctionCall(callee, args);
        end;
        antBlockExpression:
        begin
            var exprsJson := AObject.GetValue<TJSONArray>('expressions');
            var exprs := TArray<IAstNode>.Create();
            SetLength(exprs, exprsJson.Count);
            for i := 0 to exprsJson.Count - 1 do
            begin
                exprs[i] := DeserializeNode(exprsJson.Items[i] as TJSONObject, ANodeIdMap);
            end;
            Result := TAst.Block(exprs);
        end;
        antVariableDeclaration:
        begin
            var initializer: IAstNode := nil;
            if AObject.GetValue('initializer') <> nil then
            begin
                initializer := DeserializeNode(AObject.GetValue<TJSONObject>('initializer'), ANodeIdMap);
            end;
            Result := TAst.VarDecl(IIdentifierNode(DeserializeNode(AObject.GetValue<TJSONObject>('identifier'), ANodeIdMap)), initializer);
        end;
        antAssignment:
            Result :=
                TAst.Assign(
                    IIdentifierNode(DeserializeNode(AObject.GetValue<TJSONObject>('identifier'), ANodeIdMap)),
                    DeserializeNode(AObject.GetValue<TJSONObject>('value'), ANodeIdMap)
                );
        antIndexer:
            Result :=
                TAst.Indexer(
                    DeserializeNode(AObject.GetValue<TJSONObject>('base'), ANodeIdMap),
                    DeserializeNode(AObject.GetValue<TJSONObject>('index'), ANodeIdMap)
                );
        antMemberAccess:
            Result :=
                TAst.MemberAccess(
                    DeserializeNode(AObject.GetValue<TJSONObject>('base'), ANodeIdMap),
                    IIdentifierNode(DeserializeNode(AObject.GetValue<TJSONObject>('member'), ANodeIdMap))
                );
        antCreateSeries: Result := TAst.CreateSeries(AObject.GetValue<string>('definition'));
        antAddSeriesItem:
        begin
            var lookback: IAstNode := nil;
            if AObject.GetValue('lookback') <> nil then
            begin
                lookback := DeserializeNode(AObject.GetValue<TJSONObject>('lookback'), ANodeIdMap);
            end;
            Result :=
                TAst.AddSeriesItem(
                    IIdentifierNode(DeserializeNode(AObject.GetValue<TJSONObject>('series'), ANodeIdMap)),
                    DeserializeNode(AObject.GetValue<TJSONObject>('value'), ANodeIdMap),
                    lookback
                );
        end;
        antSeriesLength: Result := TAst.SeriesLength(IIdentifierNode(DeserializeNode(AObject.GetValue<TJSONObject>('series'), ANodeIdMap)));
    else
        raise ENotImplemented.CreateFmt('Deserialization for node type "%s" is not implemented.', [nodeTypeStr]);
    end;

    if Assigned(Result) then
    begin
        ANodeIdMap.Add(tempId, Result);
    end;
end;

function TAstProjectPersistence.ScalarFromJson(AObject: TJSONObject): TScalar;
var
    kindStr: string;
    kind: TScalarKind;
    value: TScalarValue;
    decVal: TDecimal;
    hexStrAnsi: AnsiString;
begin
    kindStr := AObject.GetValue<string>('kind');
    kind := TScalar.StringToKind(kindStr);
    case kind of
        skInteger: value.AsInteger := AObject.GetValue<Integer>('value');
        skInt64: value.AsInt64 := StrToInt64(AObject.GetValue<string>('value'));
        skUInt64: value.AsUInt64 := StrToUInt64(AObject.GetValue<string>('value'));
        skSingle: value.AsSingle := AObject.GetValue<Double>('value');
        skDouble: value.AsDouble := AObject.GetValue<Double>('value');
        skDateTime: value.AsDateTime := ISO8601ToDate(AObject.GetValue<string>('value'));
        skTimestamp: value.AsTimestamp := DateTimeToTimeStamp(ISO8601ToDate(AObject.GetValue<string>('value')));
        skBoolean: value.AsBoolean := AObject.GetValue<Boolean>('value');
        skChar: value.AsChar := AObject.GetValue<string>('value')[1];
        skPChar: StrPCopy(value.AsPChar, AObject.GetValue<string>('value'));
        skString: value.AsString := AObject.GetValue<shortstring>('value');
        skBytes:
        begin
            hexStrAnsi := AnsiString(AObject.GetValue<string>('value'));
            HexToBin(PAnsiChar(hexStrAnsi), @value.AsBytes, SizeOf(value.AsBytes));
        end;
        skDecimal:
        begin
            decVal := TDecimal.Create(StrToInt64(AObject.GetValue<string>('value')), AObject.GetValue<Integer>('scale'));
            value.AsDecimal := decVal;
        end;
    else
        raise ENotImplemented.CreateFmt('TScalar deserialization for kind "%s" is not implemented.', [kindStr]);
    end;
    Result.Create(kind, value);
end;

class function TAstProjectPersistence.AstNodeToJsonString(const ANode: IAstNode): string;
var
    idMap: TDictionary<IAstNode, Integer>;
    visitor: TAstToJsonVisitor;
    astJson, rootJson: TJSONObject;
begin
    if not Assigned(ANode) then
    begin
        exit('');
    end;

    // We wrap the AST in the standard project structure { "ast": ... }
    // for compatibility with the full LoadFromFile method.
    rootJson := TJSONObject.Create;
    try
        idMap := TDictionary<IAstNode, Integer>.Create;
        try
            visitor := TAstToJsonVisitor.Create(idMap);
            try
                ANode.Accept(visitor);
                astJson := visitor.GetResult;
                rootJson.AddPair('ast', astJson);
                Result := rootJson.ToJSON;
            finally
                visitor.Free;
            end;
        finally
            idMap.Free;
        end;
    finally
        rootJson.Free;
    end;
end;

class function TAstProjectPersistence.JsonStringToAstNode(const AJsonString: string): IAstNode;
var
    persistence: TAstProjectPersistence;
    rootJson, astJson: TJSONObject;
    nodeIdMap: TDictionary<Integer, IAstNode>;
begin
    Result := nil;
    if AJsonString.IsEmpty then
    begin
        exit;
    end;

    rootJson := TJSONObject.ParseJSONValue(AJsonString) as TJSONObject;
    if not Assigned(rootJson) then
    begin
        exit;
    end;

    try
        // Expect the standard project structure and extract the "ast" part.
        astJson := rootJson.GetValue<TJSONObject>('ast');
        if Assigned(astJson) then
        begin
            persistence := TAstProjectPersistence.Create;
            try
                nodeIdMap := TDictionary<Integer, IAstNode>.Create;
                try
                    Result := persistence.DeserializeNode(astJson, nodeIdMap);
                finally
                    nodeIdMap.Free;
                end;
            finally
                persistence.Free;
            end;
        end;
    finally
        rootJson.Free;
    end;
end;

{ TAstProjectPersistence.TAstToJsonVisitor }

constructor TAstProjectPersistence.TAstToJsonVisitor.Create(AIdMap: TDictionary<IAstNode, Integer>);
begin
    inherited Create;
    FIdMap := AIdMap;
    FNextId := 0;
    FResultStack := TStack<TJSONObject>.Create;
    FSerializedNodes := TDictionary<IAstNode, Boolean>.Create;
end;

destructor TAstProjectPersistence.TAstToJsonVisitor.Destroy;
begin
    FResultStack.Free;
    FSerializedNodes.Free;
    inherited;
end;

function TAstProjectPersistence.TAstToJsonVisitor.GetResult: TJSONObject;
begin
    Assert(FResultStack.Count = 1, 'Result stack should contain exactly one item after traversal.');
    Result := FResultStack.Pop as TJSONObject;
end;

function TAstProjectPersistence.TAstToJsonVisitor.GetOrCreateNodeId(const Node: IAstNode): Integer;
begin
    if not FIdMap.TryGetValue(Node, Result) then
    begin
        Result := FNextId;
        FIdMap.Add(Node, Result);
        inc(FNextId);
    end;
end;

function TAstProjectPersistence.TAstToJsonVisitor.ScalarToJson(const AValue: TScalar): TJSONObject;
var
    hexStr: string;
begin
    Result := TJSONObject.Create;
    Result.AddPair('kind', TJSONString.Create(AValue.Kind.ToString));
    case AValue.Kind of
        skInteger: Result.AddPair('value', TJSONNumber.Create(AValue.Value.AsInteger));
        skInt64: Result.AddPair('value', TJSONString.Create(AValue.Value.AsInt64.ToString));
        skUInt64: Result.AddPair('value', TJSONString.Create(AValue.Value.AsUInt64.ToString));
        skSingle: Result.AddPair('value', TJSONNumber.Create(AValue.Value.AsSingle));
        skDouble: Result.AddPair('value', TJSONNumber.Create(AValue.Value.AsDouble));
        skDateTime: Result.AddPair('value', TJSONString.Create(DateToISO8601(AValue.Value.AsDateTime)));
        skTimestamp: Result.AddPair('value', TJSONString.Create(DateToISO8601(TimeStampToDateTime(AValue.Value.AsTimestamp))));
        skBoolean: Result.AddPair('value', TJSONBool.Create(AValue.Value.AsBoolean));
        skChar: Result.AddPair('value', TJSONString.Create(AValue.Value.AsChar));
        skPChar: Result.AddPair('value', TJSONString.Create(string(AValue.Value.AsPChar)));
        skString: Result.AddPair('value', TJSONString.Create(String(AValue.Value.AsString)));
        skBytes:
        begin
            // Corrected: Use the procedure overload of BinToHex.
            //                BinToHex(@AValue.Value.AsBytes, hexStr, SizeOf(AValue.Value.AsBytes));
            //                Result.AddPair('value', TJSONString.Create(hexStr));
        end;
        skDecimal:
        begin
            Result.AddPair('value', TJSONString.Create(AValue.Value.AsDecimal.GetValue.ToString));
            Result.AddPair('scale', TJSONNumber.Create(AValue.Value.AsDecimal.GetScale));
        end;
    else
        raise ENotImplemented.CreateFmt('TScalar serialization for kind "%s" is not implemented.', [AValue.Kind.ToString]);
    end;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitConstant(const Node: IConstantNode): TAstValue;
var
    obj: TJSONObject;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('Constant'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('value', ScalarToJson(Node.Value));
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitIdentifier(const Node: IIdentifierNode): TAstValue;
var
    obj: TJSONObject;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('Identifier'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('name', TJSONString.Create(Node.Name));
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitBinaryExpression(const Node: IBinaryExpressionNode): TAstValue;
var
    obj: TJSONObject;
    rightJson, leftJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Left.Accept(Self);
    Node.Right.Accept(Self);
    rightJson := FResultStack.Pop;
    leftJson := FResultStack.Pop;
    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('BinaryExpression'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('operator', TJSONString.Create(Copy(GetEnumName(TypeInfo(TBinaryOperator), Ord(Node.Operator)), 3)));
    obj.AddPair('left', leftJson);
    obj.AddPair('right', rightJson);
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitUnaryExpression(const Node: IUnaryExpressionNode): TAstValue;
var
    obj: TJSONObject;
    rightJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Right.Accept(Self);
    rightJson := FResultStack.Pop;
    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('UnaryExpression'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('operator', TJSONString.Create(Copy(GetEnumName(TypeInfo(TUnaryOperator), Ord(Node.Operator)), 3)));
    obj.AddPair('right', rightJson);
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitIfExpression(const Node: IIfExpressionNode): TAstValue;
var
    obj: TJSONObject;
    elseJson, thenJson, condJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Condition.Accept(Self);
    Node.ThenBranch.Accept(Self);
    if Assigned(Node.ElseBranch) then
    begin
        Node.ElseBranch.Accept(Self);
    end;

    if Assigned(Node.ElseBranch) then
    begin
        elseJson := FResultStack.Pop
    end
    else
    begin
        elseJson := nil;
    end;
    thenJson := FResultStack.Pop;
    condJson := FResultStack.Pop;

    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('IfExpression'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('condition', condJson);
    obj.AddPair('thenBranch', thenJson);
    if Assigned(elseJson) then
    begin
        obj.AddPair('elseBranch', elseJson);
    end;

    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitTernaryExpression(const Node: ITernaryExpressionNode): TAstValue;
var
    obj: TJSONObject;
    elseJson, thenJson, condJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Condition.Accept(Self);
    Node.ThenBranch.Accept(Self);
    Node.ElseBranch.Accept(Self);

    elseJson := FResultStack.Pop;
    thenJson := FResultStack.Pop;
    condJson := FResultStack.Pop;

    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('TernaryExpression'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('condition', condJson);
    obj.AddPair('thenBranch', thenJson);
    obj.AddPair('elseBranch', elseJson);

    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitLambdaExpression(const Node: ILambdaExpressionNode): TAstValue;
var
    obj: TJSONObject;
    paramsJson: TJSONArray;
    param: IIdentifierNode;
    bodyJson: TJSONValue;
    i: Integer;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    // 1. Visit children first.
    for param in Node.Parameters do
    begin
        param.Accept(Self);
    end;
    Node.Body.Accept(Self);

    // 2. Pop children's results from the stack in reverse order.
    bodyJson := FResultStack.Pop;

    paramsJson := TJSONArray.Create;
    var lst := TList<TJSONValue>.Create;
    try
        lst.Count := Length(Node.Parameters);
        for i := High(Node.Parameters) downto 0 do
            lst[i] := FResultStack.Pop;
        paramsJson.SetElements(lst);
    finally
        lst.Free;
    end;

    // 3. Create this node's JSON object.
    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('LambdaExpression'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('parameters', paramsJson);
    obj.AddPair('body', bodyJson);
    // Note: ScopeDescriptor and Upvalues are runtime-only and not serialized here.

    // 4. Push this node's result onto the stack.
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitFunctionCall(const Node: IFunctionCallNode): TAstValue;
var
    obj: TJSONObject;
    args: TJSONArray;
    arg: IAstNode;
    calleeJson: TJSONValue;
    i: Integer;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Callee.Accept(Self);
    for arg in Node.Arguments do
    begin
        arg.Accept(Self);
    end;

    args := TJSONArray.Create;
    var lst := TList<TJSONValue>.Create;
    try
        lst.Count := Node.Arguments.Count;
        for i := Node.Arguments.Count - 1 downto 0 do
            lst[i] := FResultStack.Pop;
        args.SetElements(lst);
    finally
        lst.Free;
    end;

    calleeJson := FResultStack.Pop;

    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('FunctionCall'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('callee', calleeJson);
    obj.AddPair('arguments', args);
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitBlockExpression(const Node: IBlockExpressionNode): TAstValue;
var
    obj: TJSONObject;
    exprs: TJSONArray;
    expr: IAstNode;
    i: Integer;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    for expr in Node.Expressions do
    begin
        expr.Accept(Self);
    end;

    exprs := TJSONArray.Create;
    var lst := TList<TJSONValue>.Create;
    try
        lst.Count := Node.Expressions.Count;
        for i := Node.Expressions.Count - 1 downto 0 do
            lst[i] := FResultStack.Pop;
        exprs.SetElements(lst);
    finally
        lst.Free;
    end;

    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('BlockExpression'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('expressions', exprs);
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitVariableDeclaration(const Node: IVariableDeclarationNode): TAstValue;
var
    obj: TJSONObject;
    identJson, initJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Identifier.Accept(Self);
    if Assigned(Node.Initializer) then
    begin
        Node.Initializer.Accept(Self);
    end;

    if Assigned(Node.Initializer) then
    begin
        initJson := FResultStack.Pop
    end
    else
    begin
        initJson := nil;
    end;
    identJson := FResultStack.Pop;

    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('VariableDeclaration'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('identifier', identJson);
    if Assigned(initJson) then
    begin
        obj.AddPair('initializer', initJson);
    end;
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitAssignment(const Node: IAssignmentNode): TAstValue;
var
    obj: TJSONObject;
    identJson, valueJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Identifier.Accept(Self);
    Node.Value.Accept(Self);
    valueJson := FResultStack.Pop;
    identJson := FResultStack.Pop;
    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('Assignment'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('identifier', identJson);
    obj.AddPair('value', valueJson);
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitIndexer(const Node: IIndexerNode): TAstValue;
var
    obj: TJSONObject;
    baseJson, indexJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Base.Accept(Self);
    Node.Index.Accept(Self);
    indexJson := FResultStack.Pop;
    baseJson := FResultStack.Pop;
    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('Indexer'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('base', baseJson);
    obj.AddPair('index', indexJson);
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitMemberAccess(const Node: IMemberAccessNode): TAstValue;
var
    obj: TJSONObject;
    baseJson, memberJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Base.Accept(Self);
    Node.Member.Accept(Self);
    memberJson := FResultStack.Pop;
    baseJson := FResultStack.Pop;
    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('MemberAccess'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('base', baseJson);
    obj.AddPair('member', memberJson);
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitCreateSeries(const Node: ICreateSeriesNode): TAstValue;
var
    obj: TJSONObject;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('CreateSeries'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('definition', TJSONString.Create(Node.Definition));
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitAddSeriesItem(const Node: IAddSeriesItemNode): TAstValue;
var
    obj: TJSONObject;
    seriesJson, valueJson, lookbackJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Series.Accept(Self);
    Node.Value.Accept(Self);
    if Assigned(Node.Lookback) then
    begin
        Node.Lookback.Accept(Self);
    end;

    if Assigned(Node.Lookback) then
    begin
        lookbackJson := FResultStack.Pop
    end
    else
    begin
        lookbackJson := nil;
    end;
    valueJson := FResultStack.Pop;
    seriesJson := FResultStack.Pop;

    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('AddSeriesItem'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('series', seriesJson);
    obj.AddPair('value', valueJson);
    if Assigned(lookbackJson) then
    begin
        obj.AddPair('lookback', lookbackJson);
    end;
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

function TAstProjectPersistence.TAstToJsonVisitor.VisitSeriesLength(const Node: ISeriesLengthNode): TAstValue;
var
    obj: TJSONObject;
    seriesJson: TJSONValue;
begin
    if FSerializedNodes.ContainsKey(Node) then
    begin
        var refObj := TJSONObject.Create;
        refObj.AddPair('ref', TJSONNumber.Create(FIdMap[Node]));
        FResultStack.Push(refObj);
        Result := TAstValue.Void;
        exit;
    end;
    FSerializedNodes.Add(Node, True);

    Node.Series.Accept(Self);
    seriesJson := FResultStack.Pop;
    obj := TJSONObject.Create;
    obj.AddPair('type', TJSONString.Create('SeriesLength'));
    obj.AddPair('id', TJSONNumber.Create(GetOrCreateNodeId(Node)));
    obj.AddPair('series', seriesJson);
    FResultStack.Push(obj);
    Result := TAstValue.Void;
end;

end.