%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% ktn_code: functions useful for dealing with Erlang code
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-module(ktn_code).

-elvis([{elvis_style, dont_repeat_yourself, #{min_complexity => 25}}]).
-elvis([{elvis_style, no_throw, disable}]).

-export([beam_to_string/1, beam_to_erl/2, parse_tree/1, eval/1, consult/1, to_str/1]).
%% Getters
-export([type/1, attr/2, node_attr/2, content/1]).

-export_type([tree_node/0, tree_node_type/0, beam_lib_beam/0]).

%% NOTE: we use atom() below, because erl_scan:category() is not exported.
-type tree_node_type() :: atom().
-type tree_node() ::
    #{
        type => tree_node_type(),
        attrs => map(),
        node_attrs => map(),
        content => [tree_node()]
    }.
-type beam_lib_beam() :: file:filename() | binary().
% Should eventually become beam_lib:beam(), once that's exposed
% (https://github.com/erlang/otp/pull/7534)
-type erl_syntax_annotation_or_location() :: erl_anno:anno() | erl_anno:location().
% Should eventually become erl_syntax:annotation_or_location(), once that's exposed
% (https://github.com/erlang/otp/pull/7535)
-type erl_parse_foo() ::
    {attribute, Pos :: erl_syntax_annotation_or_location(), Name :: erl_syntax:syntaxTree(),
        Args :: none | [erl_syntax:syntaxTree()]}
    | {macro, Pos :: erl_syntax_annotation_or_location(), Name :: erl_syntax:syntaxTree(),
        Args :: none | [erl_syntax:syntaxTree()]}
    | {atom, [{node, Node :: erl_syntax:syntaxTree()}], non_reversible_form}.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Exported API
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% @doc If the beam was not compiled with `debug_info'
%%      the code generated by this function will look really ugly
%% @end
-spec beam_to_string(beam_lib_beam()) -> {ok, string()} | {error, beam_lib, term()}.
beam_to_string(BeamPath) ->
    case beam_lib:chunks(BeamPath, [abstract_code]) of
        {ok, {_, [{abstract_code, {raw_abstract_v1, Forms}}]}} ->
            Src = erl_prettypr:format(
                erl_syntax:form_list(tl(Forms))
            ),
            {ok, Src};
        Error ->
            Error
    end.

%% @doc If the beam was not compiled with `debug_info'
%%      the code generated by this function will look really ugly
%% @end
-spec beam_to_erl(beam_lib_beam(), string()) -> ok.
beam_to_erl(BeamPath, ErlPath) ->
    case beam_to_string(BeamPath) of
        {ok, Src} ->
            {ok, Fd} = file:open(ErlPath, [write]),
            io:fwrite(Fd, "~s~n", [Src]),
            file:close(Fd);
        Error ->
            Error
    end.

%% @doc Parses code in a string or binary format and returns the parse tree.
-spec parse_tree(string() | binary()) -> tree_node().
parse_tree(Source) ->
    SourceStr = to_str(Source),
    ScanOpts = [text, return_comments],
    {ok, Tokens, _} = erl_scan:string(SourceStr, {1, 1}, ScanOpts),

    IoString = ktn_io_string:new(SourceStr),
    {ok, Forms} = ktn_dodger:parse(IoString, {1, 1}, [{scan_opts, [text]}]),
    ok = file:close(IoString),

    Comments = lists:filter(fun is_comment/1, Tokens),
    Children =
        [
            to_map(Form)
         || Form <- Forms,
            %% filter forms that couldn't be parsed
            element(1, Form) =/= error
        ],

    #{
        type => root,
        attrs => #{tokens => lists:map(fun token_to_map/1, Tokens)},
        content => to_map(Comments) ++ Children
    }.

-spec is_comment(erl_scan:token()) -> boolean().
is_comment({comment, _, _}) ->
    true;
is_comment(_) ->
    false.

-spec revert(erl_syntax:syntaxTree()) -> erl_parse_foo().
revert(Form) ->
    MaybeReverted =
        try
            erl_syntax:revert(Form)
        catch
            _:_ ->
                Form
        end,
    case erl_syntax:is_tree(MaybeReverted) of
        true ->
            revert(erl_syntax:type(Form), Form);
        false ->
            MaybeReverted
    end.

-spec revert(atom(), erl_syntax:syntaxTree()) -> erl_parse_foo().
revert(attribute, Node0) ->
    Subs = erl_syntax:subtrees(Node0),
    Gs = [[erl_syntax:revert(X) || X <- L] || L <- Subs],
    Node = erl_syntax:update_tree(Node0, Gs),

    Name =
        try
            erl_syntax:atom_value(
                erl_syntax:attribute_name(Node)
            )
        of
            'if' ->
                if_attr;
            'else' ->
                else_attr;
            Other ->
                Other
        catch
            _:_ ->
                erl_syntax:attribute_name(Node)
        end,

    Args = erl_syntax:attribute_arguments(Node),
    Pos = erl_syntax:get_pos(Node),
    {attribute, Pos, Name, Args};
revert(macro, Node0) ->
    Subs = erl_syntax:subtrees(Node0),
    Gs = [[erl_syntax:revert(X) || X <- L] || L <- Subs],
    Node = erl_syntax:update_tree(Node0, Gs),

    Name = erl_syntax:macro_name(Node),
    Args = erl_syntax:macro_arguments(Node),
    Pos = erl_syntax:get_pos(Node),
    {macro, Pos, Name, Args};
revert(_, Node) ->
    %% When a node can't be reverted we avoid failing by returning
    %% the a node for the atom 'non_reversible_form'
    {atom, [{node, Node}], non_reversible_form}.

token_to_map({Type, Attrs}) ->
    #{type => Type, attrs => #{text => get_text(Attrs), location => get_location(Attrs)}};
token_to_map({Type, Attrs, Value}) ->
    Map = token_to_map({Type, Attrs}),
    Map#{value => Value}.

%% @doc Evaluates the Erlang expression in the string provided.
-spec eval(string() | binary()) -> term().
eval(Source) ->
    eval(Source, []).

-spec eval(string() | binary(), orddict:orddict()) -> term().
eval(Source, Bindings) ->
    SourceStr = to_str(Source),
    {ok, Tokens, _} = erl_scan:string(SourceStr),
    {ok, Parsed} = erl_parse:parse_exprs(Tokens),
    {value, Result, _} = erl_eval:exprs(Parsed, Bindings),
    Result.

%% @doc Like `file:consult/1' but for strings and binaries.
-spec consult(string() | binary()) -> [term()].
consult(Source) ->
    SourceStr = to_str(Source),
    {ok, Tokens, _} = erl_scan:string(SourceStr),
    Forms = split_when(fun is_dot/1, Tokens),
    ParseFun =
        fun(Form) ->
            {ok, Expr} = erl_parse:parse_exprs(Form),
            Expr
        end,
    Parsed = lists:map(ParseFun, Forms),
    ExprsFun =
        fun(P) ->
            {value, Value, _} = erl_eval:exprs(P, []),
            Value
        end,
    lists:map(ExprsFun, Parsed).

%% Getters

-spec type(tree_node()) -> undefined | tree_node_type().
type(#{type := Type}) ->
    Type;
type(undefined) ->
    undefined.

-spec attr(term(), tree_node()) -> term() | undefined.
attr(Key, #{attrs := Attrs}) ->
    case maps:is_key(Key, Attrs) of
        true ->
            maps:get(Key, Attrs);
        false ->
            undefined
    end;
attr(_Key, Node) when is_map(Node) ->
    undefined;
attr(_Key, undefined) ->
    undefined.

-spec node_attr(term(), tree_node()) -> term() | undefined.
node_attr(Key, #{node_attrs := Attrs}) ->
    case maps:is_key(Key, Attrs) of
        true ->
            maps:get(Key, Attrs);
        false ->
            undefined
    end;
node_attr(_Key, Node) when is_map(Node) ->
    undefined;
node_attr(_Key, undefined) ->
    undefined.

-spec content(tree_node()) -> [tree_node()].
content(#{content := Content}) ->
    Content;
content(_Node) ->
    [].

-spec to_str(binary() | list() | atom() | integer()) -> string().
to_str(Arg) when is_binary(Arg) ->
    Encoding = source_encoding(Arg),
    unicode:characters_to_list(Arg, Encoding);
to_str(Arg) when is_atom(Arg) ->
    atom_to_list(Arg);
to_str(Arg) when is_integer(Arg) ->
    integer_to_list(Arg);
to_str(Arg) when is_list(Arg) ->
    Arg.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Internal
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

-spec source_encoding(binary()) -> latin1 | utf8.
source_encoding(Source) ->
    Re = ".*\n?.*(coding *[:=] *(?<encoding>[-a-zA-Z0-9]+))",
    ReOpts = [firstline, {capture, all_names, list}],
    case re:run(Source, Re, ReOpts) of
        {match, [Encoding]} ->
            case string:to_lower(Encoding) of
                "latin-1" ->
                    latin1;
                _ ->
                    utf8
            end;
        nomatch ->
            utf8
    end.

-spec is_dot(tuple()) -> boolean().
is_dot({dot, _}) ->
    true;
is_dot(_) ->
    false.

%% @private
get_location(Attrs) when is_integer(Attrs) ->
    Line = Attrs,
    {Line, 1};
get_location(Attrs) when is_list(Attrs) ->
    Line = proplists:get_value(line, Attrs),
    Column = proplists:get_value(column, Attrs),
    case {Line, Column} of
        {undefined, undefined} ->
            proplists:get_value(location, Attrs, {-1, -1});
        _ ->
            {Line, Column}
    end;
get_location({_Line, _Column} = Location) ->
    Location;
get_location(_Attrs) ->
    {-1, -1}.

%% @private
get_text(Attrs) when is_integer(Attrs) ->
    undefined;
get_text(Attrs) when is_list(Attrs) ->
    proplists:get_value(text, Attrs, "");
get_text(_Attrs) ->
    "".

%% @doc Converts a parse tree form the abstract format to a map based repr.
%% @todo Attributes are not being handled correctly.
-spec to_map(term()) -> tree_node() | [tree_node()].
to_map(ListParsed) when is_list(ListParsed) ->
    lists:map(fun to_map/1, ListParsed);
to_map({function, Attrs, Name, Arity, Clauses}) ->
    #{
        type => function,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name,
                arity => Arity
            },
        content => to_map(Clauses)
    };
to_map({function, Name, Arity}) ->
    #{type => function, attrs => #{name => Name, arity => Arity}};
to_map({function, Module, Name, Arity}) ->
    #{
        type => function,
        attrs =>
            #{
                module => Module,
                name => Name,
                arity => Arity
            }
    };
to_map({clause, Attrs, Patterns, Guards, Body}) ->
    #{
        type => clause,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{pattern => to_map(Patterns), guards => to_map(Guards)},
        content => to_map(Body)
    };
to_map({match, Attrs, Left, Right}) ->
    #{
        type => match,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map([Left, Right])
    };
to_map({maybe_match, Attrs, Left, Right}) ->
    #{
        type => maybe_match,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map([Left, Right])
    };
to_map({tuple, Attrs, Elements}) ->
    #{
        type => tuple,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(Elements)
    };
%% Literals
to_map({Type, Attrs, Value}) when
    Type == atom; Type == integer; Type == float; Type == string; Type == char
->
    #{
        type => Type,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                value => Value
            }
    };
to_map({bin, Attrs, Elements}) ->
    #{
        type => binary,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(Elements)
    };
to_map({bin_element, Attrs, Value, Size, TSL}) ->
    #{
        type => binary_element,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                type_spec_list => TSL
            },
        node_attrs =>
            #{
                value => to_map(Value),
                size =>
                    case Size of
                        default ->
                            #{type => default};
                        _ ->
                            to_map(Size)
                    end
            }
    };
%% Variables
to_map({var, Attrs, Name}) ->
    #{
        type => var,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            }
    };
%% Function call
to_map({call, Attrs, Function, Arguments}) ->
    #{
        type => call,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{function => to_map(Function)},
        content => to_map(Arguments)
    };
to_map({remote, Attrs, Module, Function}) ->
    #{
        type => remote,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{module => to_map(Module), function => to_map(Function)}
    };
%% case
to_map({'case', Attrs, Expr, Clauses}) ->
    CaseExpr = to_map({case_expr, Attrs, Expr}),
    CaseClauses = to_map({case_clauses, Attrs, Clauses}),
    #{
        type => 'case',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{expression => to_map(Expr)},
        content => [CaseExpr, CaseClauses]
    };
to_map({case_expr, Attrs, Expr}) ->
    #{
        type => case_expr,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [to_map(Expr)]
    };
to_map({case_clauses, Attrs, Clauses}) ->
    #{
        type => case_clauses,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(Clauses)
    };
%% fun
to_map({'fun', Attrs, {function, Name, Arity}}) ->
    #{
        type => 'fun',
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name,
                arity => Arity
            }
    };
to_map({'fun', Attrs, {function, Module, Name, Arity}}) ->
    #{
        type => 'fun',
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                module => Module,
                name => Name,
                arity => Arity
            }
    };
to_map({'fun', Attrs, {clauses, Clauses}}) ->
    #{
        type => 'fun',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(Clauses)
    };
to_map({named_fun, Attrs, Name, Clauses}) ->
    #{
        type => named_fun,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            },
        content => to_map(Clauses)
    };
%% query - deprecated, implemented for completion.
to_map({query, Attrs, ListCompr}) ->
    #{
        type => query,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(ListCompr)
    };
%% try..catch..after
to_map({'try', Attrs, Body, [], CatchClauses, AfterBody}) ->
    TryBody = to_map(Body),
    TryCatch = to_map({try_catch, Attrs, CatchClauses}),
    TryAfter = to_map({try_after, Attrs, AfterBody}),

    #{
        type => 'try',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{catch_clauses => to_map(CatchClauses), after_body => to_map(AfterBody)},
        content => TryBody ++ [TryCatch, TryAfter]
    };
%% try..of..catch..after
to_map({'try', Attrs, Expr, CaseClauses, CatchClauses, AfterBody}) ->
    TryCase = to_map({try_case, Attrs, Expr, CaseClauses}),
    TryCatch = to_map({try_catch, Attrs, CatchClauses}),
    TryAfter = to_map({try_after, Attrs, AfterBody}),

    #{
        type => 'try',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [TryCase, TryCatch, TryAfter]
    };
to_map({try_case, Attrs, Expr, Clauses}) ->
    #{
        type => try_case,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{expression => to_map(Expr)},
        content => to_map(Clauses)
    };
to_map({try_catch, Attrs, Clauses}) ->
    #{
        type => try_catch,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(Clauses)
    };
to_map({try_after, Attrs, AfterBody}) ->
    #{
        type => try_after,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(AfterBody)
    };
%% maybe..end
to_map({'maybe', Attrs, Body}) ->
    MaybeBody = to_map(Body),
    #{
        type => 'maybe',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => MaybeBody
    };
%% maybe..else..end
to_map({'maybe', Attrs, Body, Else}) ->
    MaybeBody = to_map(Body),
    MaybeElse = to_map(Else),
    #{
        type => 'maybe',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => MaybeBody ++ [MaybeElse]
    };
to_map({'else', Attrs, Clauses}) ->
    #{
        type => 'else',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(Clauses)
    };
%% if
to_map({'if', Attrs, IfClauses}) ->
    #{
        type => 'if',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(IfClauses)
    };
%% catch
to_map({'catch', Attrs, Expr}) ->
    #{
        type => 'catch',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [to_map(Expr)]
    };
%% receive
to_map({'receive', Attrs, Clauses}) ->
    RecClauses = to_map({receive_case, Attrs, Clauses}),
    #{
        type => 'receive',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [RecClauses]
    };
to_map({'receive', Attrs, Clauses, AfterExpr, AfterBody}) ->
    RecClauses = to_map({receive_case, Attrs, Clauses}),
    RecAfter = to_map({receive_after, Attrs, AfterExpr, AfterBody}),
    #{
        type => 'receive',
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [RecClauses, RecAfter]
    };
to_map({receive_case, Attrs, Clauses}) ->
    #{
        type => receive_case,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(Clauses)
    };
to_map({receive_after, Attrs, Expr, Body}) ->
    #{
        type => receive_after,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{expression => to_map(Expr)},
        content => to_map(Body)
    };
%% List
to_map({nil, Attrs}) ->
    #{type => nil, attrs => #{location => get_location(Attrs), text => get_text(Attrs)}};
to_map({cons, Attrs, Head, Tail}) ->
    #{
        type => cons,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [to_map(Head), to_map(Tail)]
    };
%% Map
to_map({map, Attrs, Pairs}) ->
    #{
        type => map,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(Pairs)
    };
to_map({map, Attrs, Var, Pairs}) ->
    #{
        type => map,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{var => to_map(Var)},
        content => to_map(Pairs)
    };
to_map({Type, Attrs, Key, Value}) when map_field_exact == Type; map_field_assoc == Type ->
    #{
        type => Type,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{key => to_map(Key), value => to_map(Value)}
    };
%% List Comprehension
to_map({lc, Attrs, Expr, GeneratorsFilters}) ->
    LcExpr = to_map({lc_expr, Attrs, Expr}),
    LcGenerators = to_map(GeneratorsFilters),
    #{
        type => lc,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [LcExpr | LcGenerators]
    };
to_map({generate, Attrs, Pattern, Expr}) ->
    #{
        type => generate,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{pattern => to_map(Pattern), expression => to_map(Expr)}
    };
to_map({zip, Attrs, Generators}) ->
    #{
        type => zip,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                generators => [to_map(Generator) || Generator <- Generators]
            }
    };
to_map({generate_strict, Attrs, Pattern, Expr}) ->
    #{
        type => generate_strict,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{pattern => to_map(Pattern), expression => to_map(Expr)}
    };
to_map({lc_expr, Attrs, Expr}) ->
    #{
        type => lc_expr,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [to_map(Expr)]
    };
%% Binary Comprehension
to_map({bc, Attrs, Expr, GeneratorsFilters}) ->
    BcExpr = to_map({bc_expr, Attrs, Expr}),
    BcGenerators = to_map(GeneratorsFilters),
    #{
        type => bc,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [BcExpr | BcGenerators]
    };
to_map({b_generate, Attrs, Pattern, Expr}) ->
    #{
        type => b_generate,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{pattern => to_map(Pattern), expression => to_map(Expr)}
    };
to_map({b_generate_strict, Attrs, Pattern, Expr}) ->
    #{
        type => b_generate_strict,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{pattern => to_map(Pattern), expression => to_map(Expr)}
    };
to_map({bc_expr, Attrs, Expr}) ->
    #{
        type => bc_expr,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => [to_map(Expr)]
    };
%% Map Comprehension
to_map({mc, Anno, RepE0, RepQs}) ->
    McExpr = to_map({mc_expr, Anno, RepE0}),
    McGenerators = to_map(RepQs),
    #{
        type => mc,
        attrs => #{location => get_location(Anno), text => get_text(Anno)},
        content => [McExpr | McGenerators]
    };
to_map({m_generate, Anno, Pattern, RepE0}) ->
    #{
        type => m_generate,
        attrs => #{location => get_location(Anno), text => get_text(Anno)},
        node_attrs => #{pattern => to_map(Pattern), expression => to_map(RepE0)}
    };
to_map({m_generate_strict, Anno, Pattern, RepE0}) ->
    #{
        type => m_generate_strict,
        attrs => #{location => get_location(Anno), text => get_text(Anno)},
        node_attrs => #{pattern => to_map(Pattern), expression => to_map(RepE0)}
    };
to_map({mc_expr, Anno, RepE0}) ->
    #{
        type => mc_expr,
        attrs => #{location => get_location(Anno), text => get_text(Anno)},
        content => [to_map(RepE0)]
    };
%% Operation
to_map({op, Attrs, Operation, Left, Right}) ->
    #{
        type => op,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                operation => Operation
            },
        content => to_map([Left, Right])
    };
to_map({op, Attrs, Operation, Single}) ->
    #{
        type => op,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                operation => Operation
            },
        content => to_map([Single])
    };
%% Record
to_map({record, Attrs, Name, Fields}) ->
    #{
        type => record,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            },
        content => to_map(Fields)
    };
to_map({record, Attrs, Var, Name, Fields}) ->
    #{
        type => record,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            },
        node_attrs => #{variable => to_map(Var)},
        content => to_map(Fields)
    };
to_map({record_index, Attrs, Name, Field}) ->
    #{
        type => record_index,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            },
        content => [to_map(Field)]
    };
to_map({record_field, Attrs, Name}) ->
    #{
        type => record_field,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{name => to_map(Name)}
    };
to_map({record_field, Attrs, Name, Default}) ->
    #{
        type => record_field,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{default => to_map(Default), name => to_map(Name)}
    };
to_map({record_field, Attrs, Var, Name, Field}) ->
    #{
        type => record_field,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            },
        node_attrs => #{variable => to_map(Var)},
        content => [to_map(Field)]
    };
%% Block
to_map({block, Attrs, Body}) ->
    #{
        type => block,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        content => to_map(Body)
    };
%% Record Attribute
to_map({attribute, Attrs, record, {Name, Fields}}) ->
    #{
        type => record_attr,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            },
        content => to_map(Fields)
    };
to_map({typed_record_field, Field, Type}) ->
    FieldMap = to_map(Field),
    #{
        type => typed_record_field,
        attrs =>
            #{
                location => attr(location, FieldMap),
                text => attr(text, FieldMap),
                field => FieldMap
            },
        node_attrs => #{type => to_map(Type)}
    };
%% Type
to_map({type, Attrs, 'fun', Types}) ->
    #{
        type => type,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => 'fun'
            },
        content => to_map(Types)
    };
to_map({type, Attrs, constraint, [Sub, SubType]}) ->
    #{
        type => type,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => constraint,
                subtype => Sub
            },
        content => to_map(SubType)
    };
to_map({type, Attrs, bounded_fun, [FunType, Defs]}) ->
    #{
        type => type,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => bounded_fun
            },
        node_attrs => #{'fun' => to_map(FunType)},
        content => to_map(Defs)
    };
to_map({type, Attrs, Name, any}) ->
    to_map({type, Attrs, Name, [any]});
to_map({type, Attrs, any}) ->
    #{
        type => type,
        attrs =>
            #{
                location => get_location(Attrs),
                text => "...",
                name => '...'
            }
    };
to_map({type, Attrs, Name, Types}) ->
    #{
        type => type,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            },
        content => to_map(Types)
    };
%% any()
to_map({user_type, Attrs, Name, Types}) ->
    #{
        type => user_type,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            },
        content => to_map(Types)
    };
to_map({type, Attrs, map_field_assoc, Name, Type}) ->
    {Location, Text} =
        case Attrs of
            Line when is_integer(Attrs) ->
                {{Line, Line}, undefined};
            Attrs ->
                {get_location(Attrs), get_text(Attrs)}
        end,
    #{
        type => type_map_field,
        attrs => #{location => Location, text => Text},
        node_attrs => #{key => to_map(Name), type => to_map(Type)}
    };
to_map({remote_type, Attrs, [Module, Function, Args]}) ->
    #{
        type => remote_type,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs =>
            #{
                module => to_map(Module),
                function => to_map(Function),
                args => to_map(Args)
            }
    };
to_map({ann_type, Attrs, [Var, Type]}) ->
    #{
        type => record_field,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{var => to_map(Var), type => to_map(Type)}
    };
to_map({paren_type, Attrs, [Type]}) ->
    #{
        type => record_field,
        attrs => #{location => get_location(Attrs), text => get_text(Attrs)},
        node_attrs => #{type => to_map(Type)}
    };
%% any()
to_map(any) ->
    #{type => any};
%% Other Attributes
to_map({attribute, Attrs, type, {Name, Type, Args}}) ->
    #{
        type => type_attr,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name
            },
        node_attrs => #{args => to_map(Args), type => to_map(Type)}
    };
to_map({attribute, Attrs, spec, {{Name, Arity}, Types}}) ->
    #{
        type => spec,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                name => Name,
                arity => Arity
            },
        node_attrs => #{types => to_map(Types)}
    };
to_map({attribute, Attrs, Type, Value}) ->
    #{
        type => Type,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs),
                value => Value
            }
    };
%% Comments
to_map({comment, Attrs, _Text}) ->
    #{type => comment, attrs => #{location => get_location(Attrs), text => get_text(Attrs)}};
%% Macro
to_map({macro, Attrs, Name, Args}) ->
    Args1 =
        case Args of
            none ->
                [];
            _ ->
                Args
        end,
    NameStr = macro_name(Name),
    #{
        type => macro,
        attrs =>
            #{
                location => get_location(Attrs),
                text => get_text(Attrs) ++ NameStr,
                name => NameStr
            },
        content => to_map(Args1)
    };
%% Representation of Parse Errors and End-of-File
to_map({error, E}) ->
    #{
        type => error,
        attrs => #{
            value => E
        }
    };
to_map({warning, W}) ->
    #{
        type => warning,
        attrs => #{
            value => W
        }
    };
to_map({eof, Location}) ->
    #{
        type => eof,
        attrs => #{
            location => get_location(Location)
        }
    };
%% Unhandled forms
to_map(Parsed) when is_tuple(Parsed) ->
    case erl_syntax:is_tree(Parsed) of
        true ->
            to_map(revert(Parsed));
        false ->
            throw({unhandled_abstract_form, Parsed})
    end;
to_map(Parsed) ->
    throw({unexpected_abstract_form, Parsed}).

-spec macro_name(erl_syntax:syntaxTree()) -> string().
macro_name(Name) ->
    case erl_syntax:type(Name) of
        atom ->
            erl_syntax:atom_name(Name);
        variable ->
            erl_syntax:variable_literal(Name)
    end.

%% @doc Splits a list whenever an element satisfies the When predicate.
%%      Returns a list of lists where each list includes the matched element
%%      as its last one.
%%      E.g.
%%      <code>
%%        split_when(fun (X) -> $. == X end, "a.b.c") = ["a.", "b.", "c"]
%%      </code>
%%      NOTE: Copied from ktn_lists not to bring the whole erlang-katana
%%            repo as a dependency here
%% @end
-spec split_when(fun((T) -> boolean()), [T]) -> [[T]].
split_when(When, List) ->
    split_when(When, List, [[]]).

split_when(When, [], [[] | Results]) ->
    split_when(When, [], Results);
split_when(_When, [], Results) ->
    Reversed = lists:map(fun lists:reverse/1, Results),
    lists:reverse(Reversed);
split_when(When, [Head | Tail], [Current0 | Rest]) ->
    Current = [Head | Current0],
    Result =
        case When(Head) of
            true ->
                [[], Current | Rest];
            false ->
                [Current | Rest]
        end,
    split_when(When, Tail, Result).