-module(neon@net).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/neon/net.gleam").
-export([address_to_ip_version/1, hostname/1, ip_address/1, parse_ip_address/1, ip_address_to_string/1, ipv4_address/4, ipv6_address/8, ip_address_version/1, port/1, port_to_int/1, timeout/1, posix_to_string/1]).
-export_type([address/0, ip_address/0, ip_version/0, port_/0, timeout_/0, posix/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.

-opaque address() :: {hostname, binary()} | {ip_address, ip_address()}.

-opaque ip_address() :: {ipv4_address,
        integer(),
        integer(),
        integer(),
        integer()} |
    {ipv6_address,
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer()}.

-type ip_version() :: ipv4 | ipv6.

-opaque port_() :: {port, integer()}.

-opaque timeout_() :: {timeout, integer()} | infinity.

-type posix() :: eaddrinuse |
    eaddrnotavail |
    eafnosupport |
    ealready |
    econnaborted |
    econnrefused |
    econnreset |
    edestaddrreq |
    ehostdown |
    ehostunreach |
    einprogress |
    eisconn |
    emsgsize |
    enetdown |
    enetreset |
    enetunreach |
    enopkg |
    enoprotoopt |
    enotconn |
    enotty |
    enotsock |
    eproto |
    eprotonosupport |
    eprototype |
    esocktnosupport |
    etimedout |
    ewouldblock |
    exbadport |
    exbadseq |
    nxdomain |
    eacces |
    eagain |
    ebadf |
    ebadmsg |
    ebusy |
    edeadlk |
    edeadlock |
    edquot |
    eexist |
    efault |
    efbig |
    eftype |
    eintr |
    einval |
    eio |
    eisdir |
    eloop |
    emfile |
    emlink |
    emultihop |
    enametoolong |
    enfile |
    enobufs |
    enodev |
    enolck |
    enolink |
    enoent |
    enomem |
    enospc |
    enosr |
    enostr |
    enosys |
    enotblk |
    enotdir |
    enotsup |
    enxio |
    eopnotsupp |
    eoverflow |
    eperm |
    epipe |
    erange |
    erofs |
    eshutdown |
    espipe |
    esrch |
    estale |
    etxtbsy |
    exdev.

-file("src/neon/net.gleam", 11).
?DOC(false).
-spec address_to_ip_version(address()) -> gleam@option:option(ip_version()).
address_to_ip_version(Address) ->
    case Address of
        {hostname, _} ->
            none;

        {ip_address, {ipv4_address, _, _, _, _}} ->
            {some, ipv4};

        {ip_address, {ipv6_address, _, _, _, _, _, _, _, _}} ->
            {some, ipv6}
    end.

-file("src/neon/net.gleam", 20).
?DOC(" Creates an address from a hostname string.\n").
-spec hostname(binary()) -> address().
hostname(Name) ->
    {hostname, Name}.

-file("src/neon/net.gleam", 25).
?DOC(" Creates an address from an IP address.\n").
-spec ip_address(ip_address()) -> address().
ip_address(Addr) ->
    {ip_address, Addr}.

-file("src/neon/net.gleam", 41).
?DOC(
    " Parses a string as an IP address.\n"
    "\n"
    " Accepts both IPv4 (e.g. `\"127.0.0.1\"`) and IPv6 (e.g. `\"::1\"`) formats.\n"
).
-spec parse_ip_address(binary()) -> {ok, ip_address()} | {error, posix()}.
parse_ip_address(Address) ->
    _pipe = Address,
    _pipe@1 = unicode:characters_to_list(_pipe),
    inet_ffi:parse_address(_pipe@1).

-file("src/neon/net.gleam", 48).
?DOC(" Converts an IP address to its string representation.\n").
-spec ip_address_to_string(ip_address()) -> binary().
ip_address_to_string(Address) ->
    inet_ffi:ntoa(Address).

-file("src/neon/net.gleam", 56).
?DOC(
    " Creates an IPv4 address from four octets.\n"
    "\n"
    " Each octet must be in the range 0-255. Returns `Error(Nil)` if any\n"
    " octet is out of range.\n"
).
-spec ipv4_address(integer(), integer(), integer(), integer()) -> {ok,
        ip_address()} |
    {error, nil}.
ipv4_address(A, B, C, D) ->
    case {(A >= 0) andalso (A =< 255),
        (B >= 0) andalso (B =< 255),
        (C >= 0) andalso (C =< 255),
        (D >= 0) andalso (D =< 255)} of
        {true, true, true, true} ->
            {ok, {ipv4_address, A, B, C, D}};

        {_, _, _, _} ->
            {error, nil}
    end.

-file("src/neon/net.gleam", 83).
?DOC(
    " Creates an IPv6 address from eight 16-bit groups.\n"
    "\n"
    " Each group must be in the range 0-65535. Returns `Error(Nil)` if any\n"
    " group is out of range.\n"
    "\n"
    " ```gleam\n"
    " // The loopback address ::1\n"
    " let assert Ok(addr) = ipv6_address(0, 0, 0, 0, 0, 0, 0, 1)\n"
    "\n"
    " // fe80::1 (link-local)\n"
    " let assert Ok(addr) = ipv6_address(0xfe80, 0, 0, 0, 0, 0, 0, 1)\n"
    "\n"
    " // 2001:db8::1 (documentation range)\n"
    " let assert Ok(addr) = ipv6_address(0x2001, 0x0db8, 0, 0, 0, 0, 0, 1)\n"
    " ```\n"
).
-spec ipv6_address(
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> {ok, ip_address()} | {error, nil}.
ipv6_address(A, B, C, D, E, F, G, H) ->
    case {(A >= 0) andalso (A =< 65535),
        (B >= 0) andalso (B =< 65535),
        (C >= 0) andalso (C =< 65535),
        (D >= 0) andalso (D =< 65535),
        (E >= 0) andalso (E =< 65535),
        (F >= 0) andalso (F =< 65535),
        (G >= 0) andalso (G =< 65535),
        (H >= 0) andalso (H =< 65535)} of
        {true, true, true, true, true, true, true, true} ->
            {ok, {ipv6_address, A, B, C, D, E, F, G, H}};

        {_, _, _, _, _, _, _, _} ->
            {error, nil}
    end.

-file("src/neon/net.gleam", 110).
?DOC(" Returns the IP version of an IP address.\n").
-spec ip_address_version(ip_address()) -> ip_version().
ip_address_version(Address) ->
    case Address of
        {ipv4_address, _, _, _, _} ->
            ipv4;

        {ipv6_address, _, _, _, _, _, _, _, _} ->
            ipv6
    end.

-file("src/neon/net.gleam", 135).
?DOC(
    " Creates a port from an integer.\n"
    "\n"
    " The value must be in the range 0-65535. Returns `Error(Nil)` if the\n"
    " value is out of range.\n"
).
-spec port(integer()) -> {ok, port_()} | {error, nil}.
port(Num) ->
    case {Num >= 0, Num =< 65535} of
        {true, true} ->
            {ok, {port, Num}};

        {_, _} ->
            {error, nil}
    end.

-file("src/neon/net.gleam", 143).
?DOC(" Returns the integer value of a port.\n").
-spec port_to_int(port_()) -> integer().
port_to_int(Port) ->
    {port, Num} = Port,
    Num.

-file("src/neon/net.gleam", 162).
?DOC(
    " Creates a timeout from a number of milliseconds.\n"
    "\n"
    " The value must be non-negative. Returns `Error(Nil)` if the value\n"
    " is negative.\n"
).
-spec timeout(integer()) -> {ok, timeout_()} | {error, nil}.
timeout(Num) ->
    case Num >= 0 of
        true ->
            {ok, {timeout, Num}};

        false ->
            {error, nil}
    end.

-file("src/neon/net.gleam", 258).
?DOC(" Converts a POSIX error code to its string representation.\n").
-spec posix_to_string(posix()) -> binary().
posix_to_string(Code) ->
    case Code of
        eaddrinuse ->
            <<"eaddrinuse"/utf8>>;

        eaddrnotavail ->
            <<"eaddrnotavail"/utf8>>;

        eafnosupport ->
            <<"eafnosupport"/utf8>>;

        ealready ->
            <<"ealready"/utf8>>;

        econnaborted ->
            <<"econnaborted"/utf8>>;

        econnrefused ->
            <<"econnrefused"/utf8>>;

        econnreset ->
            <<"econnreset"/utf8>>;

        edestaddrreq ->
            <<"edestaddrreq"/utf8>>;

        ehostdown ->
            <<"ehostdown"/utf8>>;

        ehostunreach ->
            <<"ehostunreach"/utf8>>;

        einprogress ->
            <<"einprogress"/utf8>>;

        eisconn ->
            <<"eisconn"/utf8>>;

        emsgsize ->
            <<"emsgsize"/utf8>>;

        enetdown ->
            <<"enetdown"/utf8>>;

        enetreset ->
            <<"enetreset"/utf8>>;

        enetunreach ->
            <<"enetunreach"/utf8>>;

        enopkg ->
            <<"enopkg"/utf8>>;

        enoprotoopt ->
            <<"enoprotoopt"/utf8>>;

        enotconn ->
            <<"enotconn"/utf8>>;

        enotty ->
            <<"enotty"/utf8>>;

        enotsock ->
            <<"enotsock"/utf8>>;

        eproto ->
            <<"eproto"/utf8>>;

        eprotonosupport ->
            <<"eprotonosupport"/utf8>>;

        eprototype ->
            <<"eprototype"/utf8>>;

        esocktnosupport ->
            <<"esocktnosupport"/utf8>>;

        etimedout ->
            <<"etimedout"/utf8>>;

        ewouldblock ->
            <<"ewouldblock"/utf8>>;

        exbadport ->
            <<"exbadport"/utf8>>;

        exbadseq ->
            <<"exbadseq"/utf8>>;

        nxdomain ->
            <<"nxdomain"/utf8>>;

        eacces ->
            <<"eacces"/utf8>>;

        eagain ->
            <<"eagain"/utf8>>;

        ebadf ->
            <<"ebadf"/utf8>>;

        ebadmsg ->
            <<"ebadmsg"/utf8>>;

        ebusy ->
            <<"ebusy"/utf8>>;

        edeadlk ->
            <<"edeadlk"/utf8>>;

        edeadlock ->
            <<"edeadlock"/utf8>>;

        edquot ->
            <<"edquot"/utf8>>;

        eexist ->
            <<"eexist"/utf8>>;

        efault ->
            <<"efault"/utf8>>;

        efbig ->
            <<"efbig"/utf8>>;

        eftype ->
            <<"eftype"/utf8>>;

        eintr ->
            <<"eintr"/utf8>>;

        einval ->
            <<"einval"/utf8>>;

        eio ->
            <<"eio"/utf8>>;

        eisdir ->
            <<"eisdir"/utf8>>;

        eloop ->
            <<"eloop"/utf8>>;

        emfile ->
            <<"emfile"/utf8>>;

        emlink ->
            <<"emlink"/utf8>>;

        emultihop ->
            <<"emultihop"/utf8>>;

        enametoolong ->
            <<"enametoolong"/utf8>>;

        enfile ->
            <<"enfile"/utf8>>;

        enobufs ->
            <<"enobufs"/utf8>>;

        enodev ->
            <<"enodev"/utf8>>;

        enolck ->
            <<"enolck"/utf8>>;

        enolink ->
            <<"enolink"/utf8>>;

        enoent ->
            <<"enoent"/utf8>>;

        enomem ->
            <<"enomem"/utf8>>;

        enospc ->
            <<"enospc"/utf8>>;

        enosr ->
            <<"enosr"/utf8>>;

        enostr ->
            <<"enostr"/utf8>>;

        enosys ->
            <<"enosys"/utf8>>;

        enotblk ->
            <<"enotblk"/utf8>>;

        enotdir ->
            <<"enotdir"/utf8>>;

        enotsup ->
            <<"enotsup"/utf8>>;

        enxio ->
            <<"enxio"/utf8>>;

        eopnotsupp ->
            <<"eopnotsupp"/utf8>>;

        eoverflow ->
            <<"eoverflow"/utf8>>;

        eperm ->
            <<"eperm"/utf8>>;

        epipe ->
            <<"epipe"/utf8>>;

        erange ->
            <<"erange"/utf8>>;

        erofs ->
            <<"erofs"/utf8>>;

        eshutdown ->
            <<"eshutdown"/utf8>>;

        espipe ->
            <<"espipe"/utf8>>;

        esrch ->
            <<"esrch"/utf8>>;

        estale ->
            <<"estale"/utf8>>;

        etxtbsy ->
            <<"etxtbsy"/utf8>>;

        exdev ->
            <<"exdev"/utf8>>
    end.