ale_call

%%%-------------------------------------------------------------------

%%% @doc

%%% ale_call - Erlang interface to the Aleph Rust compiler binary

%%%

%%% This module provides functions to convert Aleph ASTs (in Erlang terms)

%%% into JSON and call the Rust Aleph compiler to generate code.

%%% It supports configuring the Rust binary path and specifying output type.

%%%-------------------------------------------------------------------

-module(ale_call).
-include_lib("kernel/include/file.hrl").

%% Public API exports

-export([

    generate/1,

    generate/2,

    generate_from_file/1,

    generate_from_file/2,

    set_rust_generator_path/1,

    get_rust_generator_path/0,

    check_rust_generator/0,

    diagnostic_info/0,

    call_rust_generator_direct/1,

    call_rust_generator_direct/2,

    call_rust_generator_port/1,

    call_rust_generator_port/2

]).

%% Default path to the Rust Aleph compiler executable

-define(DEFAULT_RUST_GENERATOR, "../aleph/target/release/alephc.exe").

-record(generator_config, {

    rust_path = ?DEFAULT_RUST_GENERATOR

}).

-define(CONFIG_KEY, ale_call_config).

%%%===================================================================

%%% @doc Convert an Aleph AST Erlang term into formatted JSON binary.

%%% -spec to_json(term()) -> binary()

%%%===================================================================

to_json(AlephTree) ->
    jsone:encode(AlephTree, [{space, 2}, {indent, 2}]).

%%%===================================================================

%%% Public API

%%%===================================================================


%%%===================================================================

%%% @doc Generate code from an Aleph AST.

%%% Uses "ale" as the default output type.

%%% -spec generate(term()) -> {ok,binary()} | {error,term()}

%%%===================================================================

generate(AlephAST) ->
    generate(AlephAST, "ale").

%%%===================================================================

%%% @doc Generate code from an Aleph AST with specified output type.

%%% -spec generate(term(), string()) -> {ok,binary()} | {error,term()}

%%%===================================================================

generate(AlephAST, OutputType) ->
    JsonAST = to_json(AlephAST),
    call_rust_generator_direct(JsonAST, OutputType).

%%%===================================================================

%%% @doc Generate code from a JSON file.

%%% Uses "ale" as the default output type.

%%% -spec generate_from_file(string()) -> {ok,binary()} | {error,term()}

%%%===================================================================

generate_from_file(JsonFile) ->
    generate_from_file(JsonFile, "ale").

%%%===================================================================

%%% @doc Generate code from a JSON file with specified output type.

%%% Reads JSON content then passes to Rust compiler.

%%% -spec generate_from_file(string(), string()) -> {ok,binary()} | {error,term()}

%%%===================================================================

generate_from_file(JsonFile, OutputType) ->
    case file:read_file(JsonFile) of
        {ok, JsonContent} -> call_rust_generator_direct(binary_to_list(JsonContent), OutputType);
        Error -> Error
    end.

%%%===================================================================

%%% @doc Set the file path of the Rust Aleph compiler executable.

%%% Stored in the process dictionary for current process.

%%% -spec set_rust_generator_path(string()) -> ok

%%%===================================================================

set_rust_generator_path(Path) ->
    put(?CONFIG_KEY, #generator_config{rust_path = Path}),
    ok.

%%%===================================================================

%%% @doc Get the Rust Aleph compiler executable path.

%%% Checks process dictionary, then environment variable ALEPHC_BIN,

%%% else returns the default path.

%%% -spec get_rust_generator_path() -> string()

%%%===================================================================

get_rust_generator_path() ->
    case get(?CONFIG_KEY) of
        undefined ->
            case os:getenv("ALEPHC_BIN") of
                false -> ?DEFAULT_RUST_GENERATOR;
                EnvPath -> EnvPath
            end;
        Config -> Config#generator_config.rust_path
    end.

%%%===================================================================

%%% @doc Check if the Rust Aleph compiler executable exists and is a file.

%%% Returns {ok, Path} or {error, not_found}.

%%% -spec check_rust_generator() -> {ok,string()} | {error,not_found}

%%%===================================================================

check_rust_generator() ->
    RustPath = get_rust_generator_path(),
    case filelib:is_regular(RustPath) of
        true -> {ok, RustPath};
        false -> {error, not_found}
    end.

%%%===================================================================

%%% @doc Print diagnostic information about the Rust compiler configuration.

%%% -spec diagnostic_info() -> ok

%%%===================================================================

diagnostic_info() ->
    RustPath = get_rust_generator_path(),
    io:format("=== ALEPH GEN Diagnostic ===~n"),
    io:format("Rust compiler path: ~s~nFile exists: ~p~n", [RustPath, filelib:is_regular(RustPath)]),
    ok.

%%%===================================================================

%%% Internal functions to invoke Rust Aleph compiler

%%%===================================================================


%%%===================================================================

%%% @doc Call Rust compiler using OS command,

%%% piping the JSON AST via echo and reading output.

%%% Defaults to output type "ale".

%%% -spec call_rust_generator_direct(binary() | string()) -> {ok,binary()} | {error,term()}

%%% -spec call_rust_generator_direct(binary() | string(), string()) -> {ok,binary()} | {error,term()}

%%%===================================================================

call_rust_generator_direct(JsonAST) ->
    call_rust_generator_direct(JsonAST, "ale").

call_rust_generator_direct(JsonAST, OutputType) ->
    RustPath = get_rust_generator_path(),
    JsonData = case is_binary(JsonAST) of
        true -> JsonAST;
        false -> list_to_binary(JsonAST)
    end,
    %% Compact JSON by removing all whitespace

    CompactJson = re:replace(JsonData, "\\s+", "", [global, {return, binary}]),
    %% Prepare OS-specific command for piping JSON into Rust compiler

    Command = case os:type() of
        {win32, _} ->
            "echo " ++ binary_to_list(CompactJson) ++ " | \"" ++ RustPath ++ "\" -i ast_json -o " ++ OutputType;
        _ ->
            "echo '" ++ binary_to_list(CompactJson) ++ "' | " ++ RustPath ++ " -i ast_json -o " ++ OutputType
    end,
    try
        Result = os:cmd(Command),
        {ok, list_to_binary(Result)}
    catch
        _:_ -> {error, command_failed}
    end.

%%%===================================================================

%%% @doc Call Rust compiler using Erlang port for better IO control.

%%% Sends compact single-line JSON, receives output from stdout.

%%% Defaults to output type "ale".

%%% -spec call_rust_generator_port(binary() | string()) -> {ok,binary()} | {error,term()}

%%% -spec call_rust_generator_port(binary() | string(), string()) -> {ok,binary()} | {error,term()}

%%%===================================================================

call_rust_generator_port(JsonAST) ->
    call_rust_generator_port(JsonAST, "ale").

call_rust_generator_port(JsonAST, OutputType) ->
    RustPath = get_rust_generator_path(),
    JsonData = case is_binary(JsonAST) of
        true -> JsonAST;
        false -> list_to_binary(JsonAST)
    end,
    %% Compact JSON into single line to avoid port issues

    CompactJson = re:replace(JsonData, "\\s+", " ", [global, {return, binary}]),
    Command = RustPath ++ " -i ast_json -o " ++ OutputType,
    Port = open_port({spawn, Command}, [stream, use_stdio, exit_status, binary, eof]),

    port_command(Port, CompactJson),
    receive_port_output(Port, <<>>).

%%%===================================================================

%%% @private

%%% Receive data from port until process exit or timeout

%%% Accumulates all output in binary.

%%%===================================================================

receive_port_output(Port, Acc) ->
    receive
        {Port, {data, Data}} ->
            receive_port_output(Port, <<Acc/binary, Data/binary>>);
        {Port, {exit_status, 0}} ->
            port_close(Port),
            {ok, Acc};
        {Port, {exit_status, Status}} ->
            port_close(Port),
            {error, {exit_status, Status, Acc}};
        {Port, eof} ->
            receive_port_output(Port, Acc)
    after 10000 ->
        port_close(Port),
        {error, timeout}
    end.