-module(kryptos@eddsa).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/kryptos/eddsa.gleam").
-export([key_size/1, generate_key_pair/1, sign/2, verify/3, from_bytes/2, to_bytes/1, public_key_from_bytes/2, public_key_to_bytes/1, from_pem/1, from_der/1, to_pem/1, to_der/1, public_key_from_pem/1, public_key_from_der/1, public_key_to_pem/1, public_key_to_der/1, public_key_from_private_key/1, curve/1, public_key_curve/1]).
-export_type([private_key/0, public_key/0, curve/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.

?MODULEDOC(
    " Edwards-curve Digital Signature Algorithm (EdDSA).\n"
    "\n"
    " EdDSA provides digital signatures using Edwards curves Ed25519 and Ed448.\n"
    " Unlike ECDSA, EdDSA has built-in hashing (SHA-512 for Ed25519, SHAKE256\n"
    " for Ed448) and produces deterministic signatures.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import kryptos/eddsa\n"
    "\n"
    " let #(private_key, public_key) = eddsa.generate_key_pair(eddsa.Ed25519)\n"
    " let message = <<\"hello world\":utf8>>\n"
    " let signature = eddsa.sign(private_key, message)\n"
    " let valid = eddsa.verify(public_key, message, signature)\n"
    " // valid == True\n"
    " ```\n"
).

-type private_key() :: any().

-type public_key() :: any().

-type curve() :: ed25519 | ed448.

-file("src/kryptos/eddsa.gleam", 40).
?DOC(
    " Returns the key size in bytes for the given curve.\n"
    "\n"
    " - Ed25519: 32 bytes\n"
    " - Ed448: 57 bytes\n"
).
-spec key_size(curve()) -> integer().
key_size(Curve) ->
    case Curve of
        ed25519 ->
            32;

        ed448 ->
            57
    end.

-file("src/kryptos/eddsa.gleam", 56).
?DOC(
    " Generates a new EdDSA key pair.\n"
    "\n"
    " ## Parameters\n"
    " - `curve`: The curve to use for key generation (Ed25519 or Ed448)\n"
    "\n"
    " ## Returns\n"
    " A tuple of `#(private_key, public_key)`.\n"
).
-spec generate_key_pair(curve()) -> {private_key(), public_key()}.
generate_key_pair(Curve) ->
    kryptos_ffi:eddsa_generate_key_pair(Curve).

-file("src/kryptos/eddsa.gleam", 72).
?DOC(
    " Signs a message using EdDSA.\n"
    "\n"
    " The message is hashed internally using the curve's built-in hash function\n"
    " (SHA-512 for Ed25519, SHAKE256 for Ed448). Signatures are deterministic:\n"
    " signing the same message with the same key always produces the same signature.\n"
    "\n"
    " ## Parameters\n"
    " - `private_key`: An EdDSA private key from `generate_key_pair`\n"
    " - `message`: The message to sign (any length)\n"
    "\n"
    " ## Returns\n"
    " A signature (64 bytes for Ed25519, 114 bytes for Ed448).\n"
).
-spec sign(private_key(), bitstring()) -> bitstring().
sign(Private_key, Message) ->
    kryptos_ffi:eddsa_sign(Private_key, Message).

-file("src/kryptos/eddsa.gleam", 85).
?DOC(
    " Verifies an EdDSA signature against a message.\n"
    "\n"
    " ## Parameters\n"
    " - `public_key`: The EdDSA public key corresponding to the signing key\n"
    " - `message`: The original message that was signed\n"
    " - `signature`: The signature to verify\n"
    "\n"
    " ## Returns\n"
    " `True` if the signature is valid, `False` otherwise.\n"
).
-spec verify(public_key(), bitstring(), bitstring()) -> boolean().
verify(Public_key, Message, Signature) ->
    kryptos_ffi:eddsa_verify(Public_key, Message, Signature).

-file("src/kryptos/eddsa.gleam", 101).
?DOC(
    " Imports a private key from raw bytes.\n"
    "\n"
    " The bytes should be the raw private key seed:\n"
    " - Ed25519: 32 bytes\n"
    " - Ed448: 57 bytes\n"
    "\n"
    " Returns the private key and its corresponding public key, or `Error(Nil)`\n"
    " if the bytes are invalid.\n"
).
-spec from_bytes(curve(), bitstring()) -> {ok, {private_key(), public_key()}} |
    {error, nil}.
from_bytes(Curve, Private_bytes) ->
    kryptos_ffi:eddsa_private_key_from_bytes(Curve, Private_bytes).

-file("src/kryptos/eddsa.gleam", 113).
?DOC(
    " Exports a private key to raw bytes.\n"
    "\n"
    " Returns the raw private key seed:\n"
    " - Ed25519: 32 bytes\n"
    " - Ed448: 57 bytes\n"
).
-spec to_bytes(private_key()) -> bitstring().
to_bytes(Key) ->
    kryptos_ffi:eddsa_private_key_to_bytes(Key).

-file("src/kryptos/eddsa.gleam", 124).
?DOC(
    " Imports a public key from raw bytes.\n"
    "\n"
    " The bytes should be the raw public key point:\n"
    " - Ed25519: 32 bytes\n"
    " - Ed448: 57 bytes\n"
    "\n"
    " Returns the public key or `Error(Nil)` if the bytes are invalid.\n"
).
-spec public_key_from_bytes(curve(), bitstring()) -> {ok, public_key()} |
    {error, nil}.
public_key_from_bytes(Curve, Public_bytes) ->
    kryptos_ffi:eddsa_public_key_from_bytes(Curve, Public_bytes).

-file("src/kryptos/eddsa.gleam", 136).
?DOC(
    " Exports a public key to raw bytes.\n"
    "\n"
    " Returns the raw public key point:\n"
    " - Ed25519: 32 bytes\n"
    " - Ed448: 57 bytes\n"
).
-spec public_key_to_bytes(public_key()) -> bitstring().
public_key_to_bytes(Key) ->
    kryptos_ffi:eddsa_public_key_to_bytes(Key).

-file("src/kryptos/eddsa.gleam", 149).
?DOC(
    " Imports an EdDSA private key from PEM-encoded data.\n"
    "\n"
    " The key must be in PKCS#8 format.\n"
    "\n"
    " ## Parameters\n"
    " - `pem`: PEM-encoded key string\n"
    "\n"
    " ## Returns\n"
    " `Ok(#(private_key, public_key))` on success, `Error(Nil)` on failure.\n"
).
-spec from_pem(binary()) -> {ok, {private_key(), public_key()}} | {error, nil}.
from_pem(Pem) ->
    kryptos_ffi:eddsa_import_private_key_pem(Pem).

-file("src/kryptos/eddsa.gleam", 162).
?DOC(
    " Imports an EdDSA private key from DER-encoded data.\n"
    "\n"
    " The key must be in PKCS#8 format.\n"
    "\n"
    " ## Parameters\n"
    " - `der`: DER-encoded key data\n"
    "\n"
    " ## Returns\n"
    " `Ok(#(private_key, public_key))` on success, `Error(Nil)` on failure.\n"
).
-spec from_der(bitstring()) -> {ok, {private_key(), public_key()}} |
    {error, nil}.
from_der(Der) ->
    kryptos_ffi:eddsa_import_private_key_der(Der).

-file("src/kryptos/eddsa.gleam", 173).
?DOC(
    " Exports an EdDSA private key to PEM format.\n"
    "\n"
    " The key is exported in PKCS#8 format.\n"
    "\n"
    " ## Parameters\n"
    " - `key`: The private key to export\n"
    "\n"
    " ## Returns\n"
    " `Ok(pem_string)` on success, `Error(Nil)` on failure.\n"
).
-spec to_pem(private_key()) -> {ok, binary()} | {error, nil}.
to_pem(Key) ->
    _pipe = kryptos_ffi:eddsa_export_private_key_pem(Key),
    gleam@result:map(
        _pipe,
        fun(Pem) -> <<(gleam@string:trim_end(Pem))/binary, "\n"/utf8>> end
    ).

-file("src/kryptos/eddsa.gleam", 192).
?DOC(
    " Exports an EdDSA private key to DER format.\n"
    "\n"
    " The key is exported in PKCS#8 format.\n"
    "\n"
    " ## Parameters\n"
    " - `key`: The private key to export\n"
    "\n"
    " ## Returns\n"
    " `Ok(der_data)` on success, `Error(Nil)` on failure.\n"
).
-spec to_der(private_key()) -> {ok, bitstring()} | {error, nil}.
to_der(Key) ->
    kryptos_ffi:eddsa_export_private_key_der(Key).

-file("src/kryptos/eddsa.gleam", 205).
?DOC(
    " Imports an EdDSA public key from PEM-encoded data.\n"
    "\n"
    " The key must be in SPKI format.\n"
    "\n"
    " ## Parameters\n"
    " - `pem`: PEM-encoded key string\n"
    "\n"
    " ## Returns\n"
    " `Ok(public_key)` on success, `Error(Nil)` on failure.\n"
).
-spec public_key_from_pem(binary()) -> {ok, public_key()} | {error, nil}.
public_key_from_pem(Pem) ->
    kryptos_ffi:eddsa_import_public_key_pem(Pem).

-file("src/kryptos/eddsa.gleam", 218).
?DOC(
    " Imports an EdDSA public key from DER-encoded data.\n"
    "\n"
    " The key must be in SPKI format.\n"
    "\n"
    " ## Parameters\n"
    " - `der`: DER-encoded key data\n"
    "\n"
    " ## Returns\n"
    " `Ok(public_key)` on success, `Error(Nil)` on failure.\n"
).
-spec public_key_from_der(bitstring()) -> {ok, public_key()} | {error, nil}.
public_key_from_der(Der) ->
    kryptos_ffi:eddsa_import_public_key_der(Der).

-file("src/kryptos/eddsa.gleam", 229).
?DOC(
    " Exports an EdDSA public key to PEM format.\n"
    "\n"
    " The key is exported in SPKI format.\n"
    "\n"
    " ## Parameters\n"
    " - `key`: The public key to export\n"
    "\n"
    " ## Returns\n"
    " `Ok(pem_string)` on success, `Error(Nil)` on failure.\n"
).
-spec public_key_to_pem(public_key()) -> {ok, binary()} | {error, nil}.
public_key_to_pem(Key) ->
    _pipe = kryptos_ffi:eddsa_export_public_key_pem(Key),
    gleam@result:map(
        _pipe,
        fun(Pem) -> <<(gleam@string:trim_end(Pem))/binary, "\n"/utf8>> end
    ).

-file("src/kryptos/eddsa.gleam", 249).
?DOC(
    " Exports an EdDSA public key to DER format.\n"
    "\n"
    " The key is exported in SPKI format.\n"
    "\n"
    " ## Parameters\n"
    " - `key`: The public key to export\n"
    "\n"
    " ## Returns\n"
    " `Ok(der_data)` on success, `Error(Nil)` on failure.\n"
).
-spec public_key_to_der(public_key()) -> {ok, bitstring()} | {error, nil}.
public_key_to_der(Key) ->
    kryptos_ffi:eddsa_export_public_key_der(Key).

-file("src/kryptos/eddsa.gleam", 260).
?DOC(
    " Derives the public key from an EdDSA private key.\n"
    "\n"
    " ## Parameters\n"
    " - `key`: The private key\n"
    "\n"
    " ## Returns\n"
    " The corresponding public key.\n"
).
-spec public_key_from_private_key(private_key()) -> public_key().
public_key_from_private_key(Key) ->
    kryptos_ffi:eddsa_public_key_from_private(Key).

-file("src/kryptos/eddsa.gleam", 271).
?DOC(
    " Returns the curve for an EdDSA private key.\n"
    "\n"
    " ## Parameters\n"
    " - `key`: The private key\n"
    "\n"
    " ## Returns\n"
    " The curve used by this key.\n"
).
-spec curve(private_key()) -> curve().
curve(Key) ->
    kryptos_ffi:eddsa_private_key_curve(Key).

-file("src/kryptos/eddsa.gleam", 282).
?DOC(
    " Returns the curve for an EdDSA public key.\n"
    "\n"
    " ## Parameters\n"
    " - `key`: The public key\n"
    "\n"
    " ## Returns\n"
    " The curve used by this key.\n"
).
-spec public_key_curve(public_key()) -> curve().
public_key_curve(Key) ->
    kryptos_ffi:eddsa_public_key_curve(Key).