-module(caffeine_lang@rich_error).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/rich_error.gleam").
-export([error_code_to_string/1, error_message/1, error_code_for/1, from_compilation_error/1, from_compilation_errors/1]).
-export_type([rich_error/0, error_code/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type rich_error() :: {rich_error,
        caffeine_lang@errors:compilation_error(),
        error_code(),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        gleam@option:option(caffeine_lang@errors:source_location()),
        gleam@option:option(binary())}.

-type error_code() :: {error_code, binary(), integer()}.

-file("src/caffeine_lang/rich_error.gleam", 28).
?DOC(" Converts an ErrorCode to its display string (e.g., \"E103\").\n").
-spec error_code_to_string(error_code()) -> binary().
error_code_to_string(Code) ->
    S = erlang:integer_to_binary(erlang:element(3, Code)),
    Padding = 3 - string:length(S),
    case Padding > 0 of
        true ->
            <<<<"E"/utf8, (gleam@string:repeat(<<"0"/utf8>>, Padding))/binary>>/binary,
                S/binary>>;

        false ->
            <<"E"/utf8, S/binary>>
    end.

-file("src/caffeine_lang/rich_error.gleam", 83).
?DOC(
    " Extracts the human-readable message from a CompilationError.\n"
    " Delegates to errors.to_message for consistent behavior.\n"
).
-spec error_message(caffeine_lang@errors:compilation_error()) -> binary().
error_message(Error) ->
    caffeine_lang@errors:to_message(Error).

-file("src/caffeine_lang/rich_error.gleam", 88).
?DOC(" Maps a vendor string to its codegen error code.\n").
-spec vendor_to_error_code(binary()) -> error_code().
vendor_to_error_code(Vendor) ->
    case Vendor of
        V when V =:= <<"datadog"/utf8>> ->
            {error_code, <<"codegen"/utf8>>, 502};

        V@1 when V@1 =:= <<"honeycomb"/utf8>> ->
            {error_code, <<"codegen"/utf8>>, 503};

        V@2 when V@2 =:= <<"dynatrace"/utf8>> ->
            {error_code, <<"codegen"/utf8>>, 504};

        V@3 when V@3 =:= <<"newrelic"/utf8>> ->
            {error_code, <<"codegen"/utf8>>, 505};

        _ ->
            {error_code, <<"codegen"/utf8>>, 500}
    end.

-file("src/caffeine_lang/rich_error.gleam", 38).
?DOC(" Assigns an error code based on the CompilationError variant.\n").
-spec error_code_for(caffeine_lang@errors:compilation_error()) -> error_code().
error_code_for(Error) ->
    case Error of
        {frontend_parse_error, _, _} ->
            {error_code, <<"parse"/utf8>>, 100};

        {frontend_validation_error, _, _} ->
            {error_code, <<"validation"/utf8>>, 200};

        {linker_value_validation_error, _, _} ->
            {error_code, <<"linker"/utf8>>, 302};

        {linker_duplicate_error, _, _} ->
            {error_code, <<"linker"/utf8>>, 303};

        {linker_parse_error, _, _} ->
            {error_code, <<"linker"/utf8>>, 301};

        {linker_vendor_resolution_error, _, _} ->
            {error_code, <<"linker"/utf8>>, 304};

        {semantic_analysis_template_parse_error, _, _} ->
            {error_code, <<"semantic"/utf8>>, 402};

        {semantic_analysis_template_resolution_error, _, _} ->
            {error_code, <<"semantic"/utf8>>, 403};

        {semantic_analysis_dependency_validation_error, _, _} ->
            {error_code, <<"semantic"/utf8>>, 404};

        {generator_slo_query_resolution_error, _, _} ->
            {error_code, <<"codegen"/utf8>>, 501};

        {generator_terraform_resolution_error, Vendor, _, _} ->
            vendor_to_error_code(Vendor);

        {c_q_l_resolver_error, _, _} ->
            {error_code, <<"cql"/utf8>>, 601};

        {c_q_l_parser_error, _, _} ->
            {error_code, <<"cql"/utf8>>, 602};

        {compilation_errors, _} ->
            {error_code, <<"multiple"/utf8>>, 0}
    end.

-file("src/caffeine_lang/rich_error.gleam", 61).
?DOC(" Creates a RichError, extracting context from the error's ErrorContext.\n").
-spec from_compilation_error(caffeine_lang@errors:compilation_error()) -> rich_error().
from_compilation_error(Error) ->
    Ctx = caffeine_lang@errors:error_context(Error),
    {rich_error,
        Error,
        error_code_for(Error),
        erlang:element(3, Ctx),
        erlang:element(4, Ctx),
        erlang:element(5, Ctx),
        erlang:element(6, Ctx)}.

-file("src/caffeine_lang/rich_error.gleam", 75).
?DOC(
    " Flattens a CompilationError into a list of RichErrors.\n"
    " Unwraps CompilationErrors into individual RichErrors.\n"
).
-spec from_compilation_errors(caffeine_lang@errors:compilation_error()) -> list(rich_error()).
from_compilation_errors(Error) ->
    _pipe = Error,
    _pipe@1 = caffeine_lang@errors:to_list(_pipe),
    gleam@list:map(_pipe@1, fun from_compilation_error/1).