#include "game.h" // Einbindung einer benutzerdefinierten Header-Datei, vermutlich mit Konstanten und Deklarationen
#include <time.h> // Für Zeitfunktionen wie time(), wird für Zufallszahlengenerierung verwendet
#include <stdlib.h> // Für Funktionen wie rand(), srand(), malloc() etc.
#include <string.h> // Für Stringfunktionen wie strlen()

#define MAX_RAND_TRIES_PER_WORD 10 // Maximale Versuche pro Wort (nicht direkt verwendet im Code)
#define EMPTY_CHAR 0 // Definition eines leeren Zeichens (nicht direkt verwendet im Code)

/* Wörter aus der Wortliste zufällig horizontal oder vertikal platzieren
 * restliche Felder mit zufälligen Buchstaben füllen */

// Aufzählungstyp zur Richtungsprüfung
typedef enum {
    DIR_DOWN,    // Wort wird vertikal nach unten platziert
    DIR_RIGHT,   // Wort wird horizontal nach rechts platziert
    DIR_FAILURE, // Platzierung nicht möglich
} check_dir_e;

// Prüft, ob ein Wort an einer bestimmten Position und Richtung platziert werden kann
static check_dir_e check_field(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
                               unsigned int searchFieldLen, const unsigned int word_len,
                               const int pos_x, const int pos_y)
{
    const int random_direction = rand() % 2; // Zufällige Richtung: 0 = unten, 1 = rechts

    // Prüft, ob Richtung rechts möglich ist
    if (random_direction == 1) {
        for (int i = 0; i < word_len; i++) {
            if (pos_x + i >= searchFieldLen || salad[pos_y][pos_x + i] != '\0') {
                break; // Abbruch, wenn außerhalb des Feldes oder Feld bereits belegt
            }
            if (i == word_len - 1) {
                return DIR_RIGHT; // Richtung rechts ist möglich
            }
        }
    }

    // Prüft, ob Richtung unten möglich ist
    for (int i = 0; i < word_len; i++) {
        if (pos_y + i > searchFieldLen - 1 || salad[pos_y + i][pos_x] != '\0') {
            break; // Abbruch, wenn außerhalb des Feldes oder Feld bereits belegt
        }
        if (i == word_len - 1) {
            return DIR_DOWN; // Richtung unten ist möglich
        }
    }

    return DIR_FAILURE; // Keine Richtung möglich
}

// Erstellt das Buchstabensalat-Feld mit den gegebenen Wörtern
int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
                    unsigned int searchFieldLen, const char words[][MAX_WORD_LEN],
                    unsigned int wordCount)
{
    srand(time(NULL)); // Initialisiert Zufallszahlengenerator mit aktuellem Zeitpunkt

    int pos_x; // X-Position für Wortplatzierung
    int pos_y; // Y-Position für Wortplatzierung

    // Initialisiert das Feld mit leeren Zeichen
    for (unsigned int y = 0; y < searchFieldLen; y++) {
        for (unsigned int x = 0; x < searchFieldLen; x++) {
            salad[y][x] = '\0'; // Setzt jedes Feld auf leer
        }
    }

    int placedWords = 0; // Zähler für erfolgreich platzierte Wörter
    unsigned int cnt;

    // Schleife über alle Wörter
    for (cnt = 0; cnt < wordCount; cnt++) {
        check_dir_e direction = DIR_FAILURE; // Anfangszustand: keine Richtung möglich
        int tries = 0;

        // Versucht bis zu 1000-mal ein Wort zu platzieren
        while (direction == DIR_FAILURE && tries < 1000) {
            direction = DIR_FAILURE; // Rücksetzen der Richtung
            pos_x = rand() % searchFieldLen; // Zufällige X-Position
            pos_y = rand() % searchFieldLen; // Zufällige Y-Position

            // Prüft, ob das Wort an der Position platziert werden kann
            direction = check_field(salad, searchFieldLen, strlen(words[cnt]), pos_x, pos_y);

            // Platziert das Wort je nach Richtung
            switch (direction) {
            case DIR_DOWN:
                for (int i = 0; i < strlen(words[cnt]); i++) {
                    salad[pos_y + i][pos_x] = words[cnt][i]; // Buchstaben vertikal einfügen
                }
                placedWords++; // Erfolgreich platziertes Wort zählen
                break;
            case DIR_RIGHT:
                for (int i = 0; i < strlen(words[cnt]); i++) {
                    salad[pos_y][pos_x + i] = words[cnt][i]; // Buchstaben horizontal einfügen
                }
                placedWords++; // Erfolgreich platziertes Wort zählen
                break;
            case DIR_FAILURE:
                break; // Keine Aktion bei Fehlschlag
            }

            tries++; // Versuchszähler erhöhen

            // Wenn erfolgreich platziert, Schleife verlassen
            if (direction != DIR_FAILURE) {
                break;
            }
        }
    }

    // Füllt alle leeren Felder mit zufälligen Buchstaben
    for (unsigned int y = 0; y < searchFieldLen; y++) {
        for (unsigned int x = 0; x < searchFieldLen; x++) {
            if (salad[y][x] == '\0') {
                salad[y][x] = 'A' + (rand() % 26); // Zufälliger Buchstabe von A bis Z
            }
        }
    }

    return placedWords; // Gibt Anzahl der platzierten Wörter zurück
}

// Gibt das Buchstabensalat-Feld auf der Konsole aus
void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
                   unsigned int searchFieldLen)
{
    for (unsigned int y = 0; y < searchFieldLen; y++) {
        for (unsigned int x = 0; x < searchFieldLen; x++) {
            printf("%c ", salad[y][x]); // Gibt jeden Buchstaben mit Leerzeichen aus
        }
        printf("\n"); // Neue Zeile nach jeder Reihe
    }
}
// Prints the word salad to console
void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
                   unsigned int searchFieldLen)
{
    for (unsigned int y = 0; y < searchFieldLen; y++) {
        for (unsigned int x = 0; x < searchFieldLen; x++) {
            printf("%c ", salad[y][x]);
        }
        printf("\n");
    }
}