/*
 * Copyright ...
 * Lizenztext
 *
 * This file implements the scanhash_arm_yespower function for ARM-based mining.
 */

#include "cpuminer-config.h"
#include "miner.h"
#include "yespower-1.0.1/yespower.h"
#include "sysendian.h"
#include "version.h"  // Enthält Definitionen für BLOCK_VERSION_RASPBERRY, BLOCK_VERSION_NOARM, BLOCK_VERSION_DEFAULT

#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdbool.h>
#include <jansson.h>
#include <curl/curl.h>
#include <pthread.h>

// Externe Deklarationen aus miner.h
extern struct work_restart *work_restart;
extern bool fulltest(const uint32_t *hash, const uint32_t *target);

// Funktion zur Auswahl der Yespower-Parameter basierend auf der Blockversion
static const yespower_params_t *select_yespower_params_by_version(int32_t nVersion) {
    /*
     * Prüfe, ob das Raspberry-Bit gesetzt ist.
     */
    if ((nVersion & BLOCK_VERSION_RASPBERRY) == BLOCK_VERSION_RASPBERRY) {
        /*
         * Beispiel-Parameter für Raspberry (ARM).
         * N, r und pers/perslen kannst du anpassen.
         */
        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;
    }
    /*
     * Prüfe, ob das Non-ARM-Bit gesetzt ist.
     */
    else if ((nVersion & BLOCK_VERSION_NOARM) == BLOCK_VERSION_NOARM) {
        /*
         * Beispiel-Parameter für Non-ARM (z. B. x86).
         */
        static const yespower_params_t params_noarm = {
            .version = YESPOWER_1_0,
            .N = 4096,
            .r = 16,
            .pers = (const uint8_t *)"NoARM",
            .perslen = 5
        };
        return &params_noarm;
    }
    /*
     * Prüfe, ob das Default-Bit gesetzt ist.
     */
    else if ((nVersion & BLOCK_VERSION_DEFAULT) == BLOCK_VERSION_DEFAULT) {
        static const yespower_params_t params_default = {
            .version = YESPOWER_1_0,
            .N = 4096, // Standardwert für alle Plattformen
            .r = 16,
            .pers = (const uint8_t *)"Default",
            .perslen = 7 // "Default" hat 7 Zeichen
        };
        return &params_default;
    }
    else {
        /*
         * Fallback, falls kein passendes Bit gesetzt ist.
         */
        static const yespower_params_t params_fallback = {
            .version = YESPOWER_1_0,
            .N = 4096,
            .r = 16,
            .pers = (const uint8_t *)"Fallback",
            .perslen = 8
        };
        return &params_fallback;
    }
}

// Scanhash-Funktion (berechnet den Hash für verschiedene Nonces)
int scanhash_arm_yespower(int thr_id, uint32_t *pdata,
    const uint32_t *ptarget,
    uint32_t max_nonce, unsigned long *hashes_done)
{
    // Wähle die Yespower-Parameter basierend auf der Blockversion
    const yespower_params_t *params = select_yespower_params_by_version(pdata[0]);

    if (!params) {
        fprintf(stderr, "Thread %d: Ungültige Yespower-Parameter.\n", thr_id);
        return 0;
    }

    union {
        uint8_t u8[80];     // 80 Bytes für den Blockheader
        uint32_t u32[20];
    } data;
    union {
        yespower_binary_t yb;
        uint32_t u32[8];
    } hash;

    uint32_t n = pdata[19] - 1; // Nonce starten
    const uint32_t Htarg = ptarget[7]; // Zielwert (nur ein Teil des Ziels wird verwendet)
    int i;

    *hashes_done = 0;

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

    do {
        be32enc(&data.u32[19], ++n); // Nonce inkrementieren

        // 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 das Ziel erfüllt
        if (le32dec(&hash.u32[7]) <= Htarg) {
            for (i = 0; i < 8; i++) { // Korrigiere die Anzahl auf 8
                hash.u32[i] = le32dec(&hash.u32[i]);
            }

            if (fulltest(hash.u32, ptarget)) {
                *hashes_done = n - pdata[19] + 1;
                pdata[19] = n; // Nonce aktualisieren
                return 1;
            }
        }

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

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