#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
    #define BLOCK_VERSION 0x10000000 // Raspberry Pi spezifische Version
#elif defined(TARGET_NOARM)
    #define BLOCK_VERSION 0x20000000 // Non-ARM spezifische Version
#else
    #define BLOCK_VERSION 0x00000000 // Standard Block-Version
#endif

/* Auswahl der Yespower-Parameter basierend auf der Zielplattform */
const yespower_params_t *select_yespower_params(void) {
    #ifdef TARGET_RASPBERRY
        static const yespower_params_t params_raspberry = {
            .version = YESPOWER_1_0,
            .N = 2048,
            .r = 8,
            .pers = (const uint8_t *)"Raspberry",
            .perslen = 9 // "Raspberry" hat 9 Zeichen
        };
        return &params_raspberry;

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

    #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
}

/* Scanhash-Funktion für Yespower */
int scanhash_arm_yespower(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done) {
    const yespower_params_t *params = select_yespower_params();

    union {
        uint8_t u8[80];
        uint32_t u32[20];
    } data;
    union {
        yespower_binary_t yb;
        uint32_t u32[8];
    } hash;

    uint32_t n = pdata[19] - 1; // Startwert für Nonce
    const uint32_t Htarg = ptarget[7]; // Zielwert für den Hash
    int i;

    *hashes_done = 0;

    // Konvertiere pdata in Big-Endian für Yespower
    for (i = 0; i < 19; i++) {
        be32enc(&data.u32[i], pdata[i]);
    }

    do {
        // Nonce inkrementieren und in Big-Endian umwandeln
        be32enc(&data.u32[19], ++n);

        // Berechnung des Yespower-Hashes
        if (yespower_tls(data.u8, 80, params, &hash.yb)) {
            fprintf(stderr, "Thread %d: Fehler bei der Yespower-Berechnung.\n", thr_id);
            abort();
        }

        // Prüfe, ob der berechnete Hash unterhalb des Zielwerts liegt
        if (le32dec(&hash.u32[7]) <= Htarg) {
            // Konvertiere den berechneten Hash zurück zu Little-Endian
            for (i = 0; i < 8; i++) {
                hash.u32[i] = le32dec(&hash.u32[i]);
            }

            // Überprüfe den vollständigen Zieltest
            if (fulltest(hash.u32, ptarget)) {
                *hashes_done = n - pdata[19] + 1;
                pdata[19] = n; // Aktualisiere die Nonce
                fprintf(stderr, "Thread %d: Erfolgreicher Hash gefunden! Nonce=%u\n", thr_id, n);
                return 1;
            }
        }

        (*hashes_done)++;

    } while (n < max_nonce && !work_restart[thr_id].restart);

    *hashes_done = n - pdata[19] + 1;
    pdata[19] = n; // Aktualisiere die Nonce
    return 0;
}