#include "game.h"
#include <time.h>
#include <stdlib.h>
#include <string.h>

#define MAX_RAND_TRIES_PER_WORD 10
#define EMPTY_CHAR 0

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

// Creates the word salad by placing words randomly and filling empty spaces
int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], unsigned int wordCount)
{
  /*
->int i=0;
->Schleife while (false)
 {
      ** Wir konen auch mit Structs arbeiten um die Position von jeder Buchstabe zu speichern
      -> vertikale oder horizonale Plazierung zuffälig generieren
      -> Stelle der  Buchstabe des Wort zufällig generieren und Sicherstellen, dass das Wort die Grenzen unseres Wortsalat nicht überschreitet
      -> Prüfen, dass es sich nicht mit andere Wörter überschneidet(zb: indem wir die gefülte Blocks unseres Wortsalat als besetzt in unserem Feld markieren)
        und 0 zuruckgeben, wenn est nichterste passt und 1 wenn es passt
 }
-> Im Feld plazieren
-> Wiederholen bis das Feld Words leer ist
-> Scleife die der gesamte Array durchgeht. Wenn eine Stelle leer ist, dann Zufallsbuchstabe generieren und Block füllen

   */
 if (searchFieldLen == 0 || wordCount ==0)
      return 0;

// Initialisiert das gesamte Spielfeld, indem alle Zellen auf EMPTY_CHAR gesetzt werden.
// Dadurch werden alle Felder als leer markiert, bevor Wörter eingefügt werden.
      for (unsigned int i = 0; i < searchFieldLen; i++) {
         for (unsigned int j = 0; j< searchFieldLen; j++){
            salad[i][j] = EMPTY_CHAR;
         }
      }

      srand((unsigned int)time(NULL)); // Zufallsgenerator mit Zeit initialisieren

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


      for (unsigned int w = 0; w < wordCount; w++){  // Zählt alle Wörter durch
         const char *word = words[w];                // Abkürzung zu word[w]
         size_t len = strlen(word);                  // Misst die länge des aktuellen Wortes
         int placed = 0;                             // Schaut, ob das aktuelle Wort platziert wurde


         if (len == 0 || len > searchFieldLen) { // Überspringt Wörter, die nicht ins Spielfeld passen
            continue;
         }

            for (int tries = 0; tries < MAX_RAND_TRIES_PER_WORD && !placed; tries++) { // Versucht die Wörter zu platzieren
            int dir = rand() %2;                                                       //  0 = horizontal, 1 = vertikal
            unsigned int row = rand() % searchFieldLen;                                // Zufällige Richtung für Startposition
            unsigned int col = rand() % searchFieldLen;

            // horizontal
            if (dir == 0 && col + len <= searchFieldLen) {  // Prüft, ob das Wort horizontal reinpasst
               int fits = 1;                                // geht davon aus, dass es passt
               for (size_t k = 0; k < len; k++) {           // Prüft jeden Buchstaben des Wortes
                  if (salad[row][col + k] != EMPTY_CHAR &&  // Prüft ob der Buchstabe reinpasst
                     salad[row][col + k] != word[k]) {
                        fits = 0;
                        break;

                     }
               }
               if (fits) {                            // Prüft, ob das Wort in diese Position passt
                  for (size_t k = 0; k < len; k++)    // Läuft über jeden Buchstaben des Wortes
                     salad[row][col + k] = word[k];   // Schreibt den Buchstaben ins Spielfeld
                  placed = 1;
               }
            }

            // vertikal
            else if (dir == 1 && row + len <=searchFieldLen) {
               int fits = 1;
               for (size_t k = 0; k < len; k++) {
                  if (salad[row + k][col] != EMPTY_CHAR && salad[row + k][col] != word[k]) {
                     fits = 0;
                     break;
                  }
               }
               if (fits) {
                  for (size_t k = 0; k < len; k++)
                     salad[row + k][col] = word[k];
                  placed = 1;

               }
            }
            }
            if (placed)
               placedWords++;
      }


      for (unsigned int i = 0; i < searchFieldLen; i++) {      // Gehe jede Zelle des Spielfelds durch
         for (unsigned int j = 0; j < searchFieldLen; j++) {
            if (salad[i][j] ==EMPTY_CHAR)                      // Nur leere Felder betrachten
               salad[i][j] = 'A' + (rand() % 26);              // zufällige Buchstaben erzeugen
         }
      }

      return placedWords;  // Gibt an, wie viele Wörter platziert wurden

}

// Prints the word salad to console

void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
{
/*
    -> Doppelschleife. Erste print die erste 100 Zeichen von salad[0][0bis99] hintereinander ohne Leerzeichen und dann kommt ein \n
    -> Dann wieter bis salad[99]
 */
/*
   for (unsigned int i = 0; i < searchFieldLen; i++) {       // Läuft über jede Zeile des Spielfelds
      for (unsigned int j = 0; j < searchFieldLen; j++) {    // Läuft über jede Spalte in dieser Zeile
         printf("%c ", salad[i][j]);                         // Gibt den Buchstaben in der Zelle aus
      }
      printf("\n");                                          // Beginnt eine neue Zeile nach jeder Reihe
      }
*/
}
