-module(ids@uuid).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([cast/1, generate_v4/0, generate_v7_from_timestamp/1, generate_v7/0, dump/1, decode_v7/1]).

-spec e(integer()) -> integer().
e(N) ->
    case N of
        0 ->
            48;

        1 ->
            49;

        2 ->
            50;

        3 ->
            51;

        4 ->
            52;

        5 ->
            53;

        6 ->
            54;

        7 ->
            55;

        8 ->
            56;

        9 ->
            57;

        10 ->
            97;

        11 ->
            98;

        12 ->
            99;

        13 ->
            100;

        14 ->
            101;

        15 ->
            102;

        _ ->
            102
    end.

-spec cast(bitstring()) -> {ok, binary()} | {error, binary()}.
cast(Raw_uuid) ->
    case Raw_uuid of
        <<A1:4,
            A2:4,
            A3:4,
            A4:4,
            A5:4,
            A6:4,
            A7:4,
            A8:4,
            B1:4,
            B2:4,
            B3:4,
            B4:4,
            C1:4,
            C2:4,
            C3:4,
            C4:4,
            D1:4,
            D2:4,
            D3:4,
            D4:4,
            E1:4,
            E2:4,
            E3:4,
            E4:4,
            E5:4,
            E6:4,
            E7:4,
            E8:4,
            E9:4,
            E10:4,
            E11:4,
            E12:4>> ->
            _pipe = <<(e(A1)),
                (e(A2)),
                (e(A3)),
                (e(A4)),
                (e(A5)),
                (e(A6)),
                (e(A7)),
                (e(A8)),
                45,
                (e(B1)),
                (e(B2)),
                (e(B3)),
                (e(B4)),
                45,
                (e(C1)),
                (e(C2)),
                (e(C3)),
                (e(C4)),
                45,
                (e(D1)),
                (e(D2)),
                (e(D3)),
                (e(D4)),
                45,
                (e(E1)),
                (e(E2)),
                (e(E3)),
                (e(E4)),
                (e(E5)),
                (e(E6)),
                (e(E7)),
                (e(E8)),
                (e(E9)),
                (e(E10)),
                (e(E11)),
                (e(E12))>>,
            _pipe@1 = gleam@bit_array:to_string(_pipe),
            gleam@result:replace_error(
                _pipe@1,
                <<"Error: BitString could not be converted to String."/utf8>>
            );

        _ ->
            {error, <<"Error: Raw UUID is malformed."/utf8>>}
    end.

-spec generate_v4() -> {ok, binary()} | {error, binary()}.
generate_v4() ->
    _assert_subject = crypto:strong_rand_bytes(16),
    <<U0:48, _:4, U1:12, _:2, U2:62>> = case _assert_subject of
        <<_:48, _:4, _:12, _:2, _:62>> -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"ids/uuid"/utf8>>,
                        function => <<"generate_v4"/utf8>>,
                        line => 26})
    end,
    cast(<<U0:48, 4:4, U1:12, 2:2, U2:62>>).

-spec generate_v7_from_timestamp(integer()) -> {ok, binary()} |
    {error, binary()}.
generate_v7_from_timestamp(Timestamp) ->
    _assert_subject = crypto:strong_rand_bytes(16),
    <<_:48, _:4, A:12, _:2, B:62>> = case _assert_subject of
        <<_:48, _:4, _:12, _:2, _:62>> -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"ids/uuid"/utf8>>,
                        function => <<"generate_v7_from_timestamp"/utf8>>,
                        line => 50})
    end,
    cast(<<Timestamp:48, 7:4, A:12, 2:2, B:62>>).

-spec generate_v7() -> {ok, binary()} | {error, binary()}.
generate_v7() ->
    Timestamp = os:system_time(millisecond),
    generate_v7_from_timestamp(Timestamp).

-spec d(integer()) -> integer().
d(N) ->
    case N of
        48 ->
            0;

        49 ->
            1;

        50 ->
            2;

        51 ->
            3;

        52 ->
            4;

        53 ->
            5;

        54 ->
            6;

        55 ->
            7;

        56 ->
            8;

        57 ->
            9;

        97 ->
            10;

        98 ->
            11;

        99 ->
            12;

        100 ->
            13;

        101 ->
            14;

        102 ->
            15;

        _ ->
            15
    end.

-spec dump(bitstring()) -> {ok, bitstring()} | {error, binary()}.
dump(Uuid) ->
    case Uuid of
        <<A1,
            A2,
            A3,
            A4,
            A5,
            A6,
            A7,
            A8,
            45,
            B1,
            B2,
            B3,
            B4,
            45,
            C1,
            C2,
            C3,
            C4,
            45,
            D1,
            D2,
            D3,
            D4,
            45,
            E1,
            E2,
            E3,
            E4,
            E5,
            E6,
            E7,
            E8,
            E9,
            E10,
            E11,
            E12>> ->
            _pipe = <<(d(A1)):4,
                (d(A2)):4,
                (d(A3)):4,
                (d(A4)):4,
                (d(A5)):4,
                (d(A6)):4,
                (d(A7)):4,
                (d(A8)):4,
                (d(B1)):4,
                (d(B2)):4,
                (d(B3)):4,
                (d(B4)):4,
                (d(C1)):4,
                (d(C2)):4,
                (d(C3)):4,
                (d(C4)):4,
                (d(D1)):4,
                (d(D2)):4,
                (d(D3)):4,
                (d(D4)):4,
                (d(E1)):4,
                (d(E2)):4,
                (d(E3)):4,
                (d(E4)):4,
                (d(E5)):4,
                (d(E6)):4,
                (d(E7)):4,
                (d(E8)):4,
                (d(E9)):4,
                (d(E10)):4,
                (d(E11)):4,
                (d(E12)):4>>,
            {ok, _pipe};

        _ ->
            {error, <<"Error: UUID is malformed."/utf8>>}
    end.

-spec decode_v7(binary()) -> {ok,
        {integer(), integer(), bitstring(), integer(), bitstring()}} |
    {error, binary()}.
decode_v7(Uuid_v7) ->
    _pipe = Uuid_v7,
    _pipe@1 = gleam_stdlib:identity(_pipe),
    _pipe@2 = dump(_pipe@1),
    gleam@result:'try'(_pipe@2, fun(D) -> case D of
                <<Timestamp:48/unsigned,
                    Ver:4/unsigned,
                    A:12/bitstring,
                    Var:2/unsigned,
                    B:62/bitstring>> ->
                    {ok, {Timestamp, Ver, A, Var, B}};

                _ ->
                    {error, <<"Error: Couldn't match raw UUID v7."/utf8>>}
            end end).