#include <oqs/oqs.h>
#include <oqs/sha3.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

static uint8_t *read_file(const char *path, size_t *length) {
    FILE *file = fopen(path, "rb");
    if (file == NULL) {
        fprintf(stderr, "Could not open %s\n", path);
        exit(1);
    }
    fseek(file, 0, SEEK_END);
    long size = ftell(file);
    rewind(file);
    if (size < 0) {
        fprintf(stderr, "Could not determine size of %s\n", path);
        exit(1);
    }
    uint8_t *bytes = malloc((size_t)size);
    if (bytes == NULL || fread(bytes, 1, (size_t)size, file) != (size_t)size) {
        fprintf(stderr, "Could not read %s\n", path);
        exit(1);
    }
    fclose(file);
    *length = (size_t)size;
    return bytes;
}

static void write_file(const char *path, const uint8_t *bytes, size_t length) {
    FILE *file = fopen(path, "wb");
    if (file == NULL || fwrite(bytes, 1, length, file) != length) {
        fprintf(stderr, "Could not write %s\n", path);
        exit(1);
    }
    fclose(file);
}

int main(void) {
    OQS_SIG *sig = OQS_SIG_new(OQS_SIG_alg_falcon_padded_512);
    if (sig == NULL) {
        fprintf(stderr, "Falcon-padded-512 is unavailable\n");
        return 1;
    }

    size_t public_key_len;
    size_t private_key_len;
    size_t message_len;
    size_t rust_signature_len;
    uint8_t *public_key = read_file("fixtures/public-key.bin", &public_key_len);
    uint8_t *private_key = read_file("fixtures/private-key.bin", &private_key_len);
    uint8_t *message = read_file("fixtures/message.bin", &message_len);
    uint8_t *rust_signature =
        read_file("fixtures/rust-signature.bin", &rust_signature_len);
    size_t adapted_message_len = 64 + 2 + message_len;
    uint8_t *adapted_message = malloc(adapted_message_len);
    OQS_SHA3_shake256(adapted_message, 64, public_key, public_key_len);
    adapted_message[64] = 0;
    adapted_message[65] = 0;
    for (size_t i = 0; i < message_len; i++) {
        adapted_message[66 + i] = message[i];
    }

    printf("liboqs public_key_bytes=%zu private_key_bytes=%zu signature_bytes=%zu\n",
           sig->length_public_key, sig->length_secret_key, sig->length_signature);

    if (public_key_len != sig->length_public_key ||
        private_key_len != sig->length_secret_key ||
        rust_signature_len != sig->length_signature) {
        fprintf(stderr, "Contractless and liboqs object sizes differ\n");
        return 1;
    }

    OQS_STATUS rust_valid = OQS_SIG_verify(
        sig, adapted_message, adapted_message_len,
        rust_signature, rust_signature_len, public_key
    );
    printf("Rust signature verified in liboqs: %s\n",
           rust_valid == OQS_SUCCESS ? "true" : "false");

    uint8_t *oqs_signature = malloc(sig->length_signature);
    size_t oqs_signature_len = sig->length_signature;
    OQS_STATUS signed_ok = OQS_SIG_sign(
        sig, oqs_signature, &oqs_signature_len,
        adapted_message, adapted_message_len, private_key
    );
    if (signed_ok != OQS_SUCCESS) {
        fprintf(stderr, "liboqs signing failed\n");
        return 1;
    }
    printf("liboqs produced signature_bytes=%zu\n", oqs_signature_len);
    write_file("fixtures/oqs-signature.bin", oqs_signature, oqs_signature_len);

    free(oqs_signature);
    free(adapted_message);
    free(rust_signature);
    free(message);
    free(private_key);
    free(public_key);
    OQS_SIG_free(sig);

    return rust_valid == OQS_SUCCESS ? 0 : 2;
}