#include "cpuminer-config.h"
#include "version.h"
#include "miner.h"

#include "yespower-1.0.1/yespower.h"
#include "yespower-1.0.1/sysendian.h"
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>

#ifdef TARGET_RASPBERRY_PI
    #define BLOCK_VERSION BLOCK_VERSION_RASPBERRY
#elif defined(TARGET_ARM_SERVER)
    #define BLOCK_VERSION BLOCK_VERSION_ARM_SERVER
#elif defined(TARGET_X86_64)
    #define BLOCK_VERSION BLOCK_VERSION_X86_64
#else
    #define BLOCK_VERSION BLOCK_VERSION_DEFAULT 
#endif

/* Auswahl der Yespower-Parameter basierend auf der Zielplattform */
const yespower_params_t *select_yespower_params(void) {
    #ifdef TARGET_RASPBERRY_PI
        static const yespower_params_t params_rpi = {
            .version = YESPOWER_1_0,
            .N = 1024, // Angepasster Wert für bessere Performance
            .r = 8,
            .pers = (const uint8_t *)"Raspberry",
            .perslen = 9 // "Raspberry" hat 10 Zeichen
        };
        return &params_rpi;

    #elif defined(TARGET_ARM_SERVER)
        static const yespower_params_t params_arm_server = {
            .version = YESPOWER_1_0,
            .N = 4096,
            .r = 16,
            .pers = (const uint8_t *)"ARMServer",
            .perslen = 9 // "ARMServer" hat 9 Zeichen
        };
        return &params_arm_server;

    #elif defined(TARGET_X86_64)
        static const yespower_params_t params_x86_64 = {
            .version = YESPOWER_1_0,
            .N = 4096,
            .r = 16,
            .pers = (const uint8_t *)"Default",
            .perslen = 7 // "Default" hat 7 Zeichen
        };
        return &params_x86_64;

    #elif defined(TARGET_WINDOWS)
        static const yespower_params_t params_windows = {
            .version = YESPOWER_1_0,
            .N = 4096,
            .r = 16,
            .pers = (const uint8_t *)"Windows",
            .perslen = 7 // "Windows" hat 7 Zeichen
        };
        return &params_windows;

    #else
        static const yespower_params_t params_default = {
            .version = YESPOWER_1_0,
            .N = 4096,
            .r = 16,
            .pers = (const uint8_t *)"Default",
            .perslen = 7 // "Default" hat 7 Zeichen
        };
        return &params_default;
    #endif
}

/* Berechnung des Yespower-Hashes */
int yespower_hash(const char *input, char *output) {
    const yespower_params_t *params = select_yespower_params();
    return yespower_tls((const uint8_t *)input, 80, params, (yespower_binary_t *)output);
}

/* Scanhash-Funktion für ARM-Architektur mit Yespower */
int scanhash_arm_yespower(int thr_id, uint32_t *data, const uint32_t *target, uint32_t max_nonce, unsigned long *hashes_done) {
    uint32_t nonce = data[19]; // Nonce ist das 20. Element der Daten
    unsigned char hash[32];    // Speicher für den berechneten Hash
    int result = 0;            // Rückgabewert
    *hashes_done = 0;          // Initialisierung der Hashanzahl

    // Wähle die Yespower-Parameter basierend auf Kompilierungszeit-Makros
    const yespower_params_t *params = select_yespower_params();

    for (; nonce < max_nonce; nonce++) {
        data[19] = nonce; // Aktualisiere die Nonce

        // Berechne den Hash mit Yespower
        if (yespower_tls((const uint8_t *)data, 80, params, (yespower_binary_t *)hash) != 0) {
            fprintf(stderr, "Thread %d: Fehler bei der Yespower-Berechnung.\n", thr_id);
            break;
        }

        // Prüfe, ob der berechnete Hash kleiner als das Ziel ist
        if (memcmp(hash, target, 32) <= 0) {
            printf("Thread %d: Gültiger Hash gefunden! Nonce: %u\n", thr_id, nonce);
            result = 1;
            break;
        }

        (*hashes_done)++;
    }

    data[19] = nonce; // Stelle die Nonce wieder her
    return result;
}