works well

Signed-off-by: Vimal Kumar <vimal78@gmail.com>

crossword-app/backend/src/app.js

@@ -27,7 +27,7 @@ app.use(limiter);
 
 const generateLimiter = rateLimit({
   windowMs: 5 * 60 * 1000,
-  max: 10,
+  max: 50,
   message: 'Too many puzzle generation requests, please wait before trying again.',
 });
 

crossword-app/backend/src/services/crosswordGenerator.js

@@ -8,19 +8,30 @@ class CrosswordGenerator {
   }
 
   async generatePuzzle(topics, difficulty = 'medium') {
+    console.log(`🎯 Starting puzzle generation - Topics: ${JSON.stringify(topics)}, Difficulty: ${difficulty}`);
+    
     try {
       const words = await this.selectWords(topics, difficulty);
+      console.log(`📚 Selected ${words.length} words for puzzle:`, words.map(w => w.word).join(', '));
+      
       if (words.length < this.minWords) {
+        console.log(`❌ Not enough words: ${words.length} < ${this.minWords}`);
         throw new Error('Not enough words available for selected topics');
       }
 
+      console.log(`🔧 Starting grid creation with ${words.length} words`);
       const gridResult = this.createGrid(words);
+      
       if (!gridResult) {
+        console.log(`❌ Grid creation failed - could not place words`);
         throw new Error('Could not place words in grid');
       }
 
+      console.log(`✅ Grid created successfully - Size: ${gridResult.size}x${gridResult.size}, Words placed: ${gridResult.placedWords.length}`);
+      
       const clues = this.generateClues(words, gridResult.placedWords);
       
+      console.log(`🎉 Puzzle generation completed successfully!`);
       return {
         grid: gridResult.grid,
         clues: clues,
@@ -32,7 +43,7 @@ class CrosswordGenerator {
         }
       };
     } catch (error) {
-      console.error('Error generating puzzle:', error);
+      console.error('❌ Error generating puzzle:', error);
       return null;
     }
   }
@@ -59,8 +70,14 @@ class CrosswordGenerator {
       const word = wordObj.word;
       let score = 0;
       
-      // Longer words get higher scores (they make good anchors)
-      score += word.length * 2;
+      // Moderate preference for medium-length words (5-7 chars optimal)
+      if (word.length >= 5 && word.length <= 7) {
+        score += 10; // Good base score for medium words
+      } else if (word.length >= 3 && word.length <= 4) {
+        score += 5; // Short words get some points
+      } else if (word.length >= 8) {
+        score += 3; // Long words get fewer points
+      }
       
       // Words with common letters get bonus points
       const commonLetters = ['E', 'A', 'R', 'I', 'O', 'T', 'N', 'S'];
@@ -80,7 +97,7 @@ class CrosswordGenerator {
     
     // Sort by score (descending) then shuffle within score groups
     scoredWords.sort((a, b) => {
-      if (Math.abs(a.crosswordScore - b.crosswordScore) <= 2) {
+      if (Math.abs(a.crosswordScore - b.crosswordScore) <= 3) {
         return Math.random() - 0.5; // Shuffle similar scores
       }
       return b.crosswordScore - a.crosswordScore;
@@ -91,7 +108,7 @@ class CrosswordGenerator {
 
   filterWordsByDifficulty(words, difficulty) {
     const difficultyMap = {
-      easy: { minLen: 3, maxLen: 7 },
+      easy: { minLen: 3, maxLen: 8 },
       medium: { minLen: 4, maxLen: 10 },
       hard: { minLen: 5, maxLen: 15 }
     };
@@ -104,19 +121,64 @@ class CrosswordGenerator {
   }
 
   createGrid(words) {
-    if (!words || words.length === 0) return null;
+    if (!words || words.length === 0) {
+      console.log(`❌ No words provided to createGrid`);
+      return null;
+    }
 
     const wordList = words.map(w => w.word.toUpperCase()).sort((a, b) => b.length - a.length);
     const size = this.calculateGridSize(wordList);
+    console.log(`📐 Calculated grid size: ${size}x${size} for words:`, wordList.join(', '));
     
+    // Try with different grid sizes and word counts
     for (let attempt = 0; attempt < 3; attempt++) {
       const currentSize = size + attempt;
-      const result = this.placeWordsInGrid(wordList, currentSize);
+      console.log(`🔍 Attempt ${attempt + 1}: Trying grid size ${currentSize}x${currentSize} with ${wordList.length} words`);
+      
+      // First try with all words
+      let result = this.placeWordsInGrid(wordList, currentSize);
       if (result) {
+        console.log(`✅ Success with all ${wordList.length} words on size ${currentSize}x${currentSize}`);
         return { grid: result.grid, size: currentSize, placedWords: result.placedWords };
       }
+      
+      // If that fails, try with 1-2 fewer words (but not too aggressive)
+      if (wordList.length > 7) {
+        const reducedWords = wordList.slice(0, wordList.length - 1);
+        console.log(`🔄 Retrying with ${reducedWords.length} words:`, reducedWords.join(', '));
+        result = this.placeWordsInGrid(reducedWords, currentSize);
+        if (result) {
+          console.log(`✅ Success with ${reducedWords.length} words on size ${currentSize}x${currentSize}`);
+          return { grid: result.grid, size: currentSize, placedWords: result.placedWords };
+        }
+      }
     }
     
+    // Only as last resort, try with minimum words
+    console.log(`🚨 Fallback: Trying with minimum 6 words`);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const currentSize = size + attempt;
+      if (wordList.length >= 6) {
+        const minWords = wordList.slice(0, 6);
+        console.log(`🔄 Last resort attempt ${attempt + 1}: ${minWords.length} words on ${currentSize}x${currentSize}:`, minWords.join(', '));
+        const result = this.placeWordsInGrid(minWords, currentSize);
+        if (result) {
+          console.log(`✅ Success with minimum ${minWords.length} words on size ${currentSize}x${currentSize}`);
+          return { grid: result.grid, size: currentSize, placedWords: result.placedWords };
+        }
+      }
+    }
+    
+    // Absolute last resort: simple cross pattern with just 2 words
+    if (wordList.length >= 2) {
+      console.log(`🆘 Emergency fallback: Simple 2-word cross pattern`);
+      const result = this.createSimpleCross(wordList.slice(0, 2));
+      if (result) {
+        return result;
+      }
+    }
+    
+    console.log(`❌ All grid creation attempts failed`);
     return null;
   }
 
@@ -180,64 +242,127 @@ class CrosswordGenerator {
   }
 
   placeWordsInGrid(words, size) {
+    console.log(`🎲 Creating ${size}x${size} grid for words:`, words.join(', '));
     const grid = Array(size).fill().map(() => Array(size).fill('.'));
     const placedWords = [];
     
-    if (this.backtrackPlacement(grid, words, 0, placedWords)) {
+    console.log(`🔄 Starting backtrack placement...`);
+    const startTime = Date.now();
+    const timeout = 5000; // Reduced to 5 second timeout
+    
+    if (this.backtrackPlacement(grid, words, 0, placedWords, startTime, timeout)) {
+      console.log(`✅ Backtracking successful! Placed ${placedWords.length} words`);
       const trimmed = this.trimGrid(grid, placedWords);
+      console.log(`📏 Grid trimmed to ${trimmed.grid.length}x${trimmed.grid[0].length}`);
       return { grid: trimmed.grid, placedWords: trimmed.placedWords };
     }
     
+    console.log(`❌ Backtracking failed for ${size}x${size} grid (timeout or no solution)`);
     return null;
   }
 
-  backtrackPlacement(grid, words, wordIndex, placedWords) {
+  backtrackPlacement(grid, words, wordIndex, placedWords, startTime = Date.now(), timeout = 5000, callCount = 0) {
+    // Check timeout more frequently
+    if (callCount % 50 === 0 && Date.now() - startTime > timeout) {
+      console.log(`⏰ Timeout reached after ${Date.now() - startTime}ms (${callCount} calls)`);
+      return false;
+    }
+
     if (wordIndex >= words.length) {
+      console.log(`🎉 All ${words.length} words placed successfully!`);
       return true;
     }
 
     const word = words[wordIndex];
     const size = grid.length;
+    
+    // Limit excessive logging for performance
+    if (callCount % 50 === 0 || wordIndex <= 2) {
+      console.log(`🔤 Placing word ${wordIndex + 1}/${words.length}: "${word}" (${word.length} chars) [call ${callCount}]`);
+    }
 
     // For the first word, place the longest word in the center horizontally
     if (wordIndex === 0) {
       const centerRow = Math.floor(size / 2);
       const centerCol = Math.floor((size - word.length) / 2);
+      console.log(`📍 First word "${word}": trying center position (${centerRow}, ${centerCol}) horizontal`);
       
       if (this.canPlaceWord(grid, word, centerRow, centerCol, 'horizontal')) {
+        console.log(`✅ First word "${word}" placed at center`);
         const originalState = this.placeWord(grid, word, centerRow, centerCol, 'horizontal');
         placedWords.push({ word, row: centerRow, col: centerCol, direction: 'horizontal', number: 1 });
         
-        if (this.backtrackPlacement(grid, words, wordIndex + 1, placedWords)) {
+        if (this.backtrackPlacement(grid, words, wordIndex + 1, placedWords, startTime, timeout, callCount + 1)) {
           return true;
         }
         
+        console.log(`🔙 Backtracking from first word "${word}"`);
         this.removeWord(grid, originalState);
         placedWords.pop();
+      } else {
+        console.log(`❌ Cannot place first word "${word}" at center`);
       }
       return false;
     }
 
-    // For the second word, try to create a central cross
+    // For the second word, try to create a central cross with smart selection
     if (wordIndex === 1) {
       const firstWord = placedWords[0];
-      const intersections = this.findWordIntersections(word, firstWord.word);
+      console.log(`🔍 Smart second word selection - trying to find word that intersects with "${firstWord.word}"`);
       
-      for (const intersection of intersections) {
-        const placement = this.calculateIntersectionPlacement(word, intersection.wordPos, firstWord, intersection.placedPos);
+      // Try all remaining words to find one that can intersect
+      const remainingWords = words.slice(1); // All words except the first
+      const wordsWithIntersections = [];
+      
+      // Score each remaining word by intersection potential
+      for (const candidateWord of remainingWords) {
+        const intersections = this.findWordIntersections(candidateWord, firstWord.word);
+        if (intersections.length > 0) {
+          wordsWithIntersections.push({
+            word: candidateWord,
+            intersectionCount: intersections.length,
+            intersections: intersections
+          });
+        }
+      }
+      
+      // Sort by intersection count (more intersections = better)
+      wordsWithIntersections.sort((a, b) => b.intersectionCount - a.intersectionCount);
+      console.log(`📊 Found ${wordsWithIntersections.length} words with intersections:`, 
+        wordsWithIntersections.map(w => `${w.word}(${w.intersectionCount})`).join(', '));
+      
+      // Try each word with intersections
+      for (const candidateInfo of wordsWithIntersections) {
+        const candidateWord = candidateInfo.word;
+        console.log(`🔍 Trying second word "${candidateWord}" with ${candidateInfo.intersectionCount} intersections`);
         
-        if (placement && this.canPlaceWord(grid, word, placement.row, placement.col, placement.direction)) {
-          const originalState = this.placeWord(grid, word, placement.row, placement.col, placement.direction);
-          placedWords.push({ word, ...placement, number: 2 });
+        for (const intersection of candidateInfo.intersections) {
+          const placement = this.calculateIntersectionPlacement(candidateWord, intersection.wordPos, firstWord, intersection.placedPos);
+          console.log(`🎯 Trying intersection at word[${intersection.wordPos}] = placed[${intersection.placedPos}], placement:`, placement);
           
-          if (this.backtrackPlacement(grid, words, wordIndex + 1, placedWords)) {
-            return true;
+          if (placement && this.canPlaceWord(grid, candidateWord, placement.row, placement.col, placement.direction)) {
+            console.log(`✅ Valid placement found for "${candidateWord}"`);
+            const originalState = this.placeWord(grid, candidateWord, placement.row, placement.col, placement.direction);
+            placedWords.push({ word: candidateWord, ...placement, number: 2 });
+            
+            // Create new word order with the selected second word
+            const newWordOrder = [words[0], candidateWord, ...words.slice(1).filter(w => w !== candidateWord)];
+            console.log(`🔄 New word order:`, newWordOrder.join(', '));
+            
+            if (this.backtrackPlacement(grid, newWordOrder, wordIndex + 1, placedWords, startTime, timeout, callCount + 1)) {
+              return true;
+            }
+            
+            console.log(`🔙 Backtracking from second word "${candidateWord}"`);
+            this.removeWord(grid, originalState);
+            placedWords.pop();
+          } else {
+            console.log(`❌ Invalid placement for "${candidateWord}" at`, placement);
           }
-          
-          this.removeWord(grid, originalState);
-          placedWords.pop();
         }
       }
+      
+      console.log(`❌ No valid second word found with intersections`);
       return false;
     }
 
@@ -255,7 +380,7 @@ class CrosswordGenerator {
         const originalState = this.placeWord(grid, word, row, col, direction);
         placedWords.push({ word, row, col, direction, number: wordIndex + 1 });
         
-        if (this.backtrackPlacement(grid, words, wordIndex + 1, placedWords)) {
+        if (this.backtrackPlacement(grid, words, wordIndex + 1, placedWords, startTime, timeout, callCount + 1)) {
           return true;
         }
         
@@ -775,6 +900,50 @@ class CrosswordGenerator {
     return grid[row] && grid[row][col] === letter;
   }
 
+  createSimpleCross(words) {
+    console.log(`🛠️ Creating simple cross with: ${words.join(', ')}`);
+    
+    // Find the best intersection between the two words
+    const word1 = words[0];
+    const word2 = words[1];
+    const intersections = this.findWordIntersections(word1, word2);
+    
+    if (intersections.length === 0) {
+      console.log(`❌ No intersections found between ${word1} and ${word2}`);
+      return null;
+    }
+    
+    // Use the first intersection
+    const intersection = intersections[0];
+    const size = Math.max(word1.length, word2.length) + 4;
+    const grid = Array(size).fill().map(() => Array(size).fill('.'));
+    
+    // Place first word horizontally in center
+    const centerRow = Math.floor(size / 2);
+    const centerCol = Math.floor((size - word1.length) / 2);
+    
+    for (let i = 0; i < word1.length; i++) {
+      grid[centerRow][centerCol + i] = word1[i];
+    }
+    
+    // Place second word vertically at intersection
+    const intersectionCol = centerCol + intersection.wordPos;
+    const word2StartRow = centerRow - intersection.placedPos;
+    
+    for (let i = 0; i < word2.length; i++) {
+      grid[word2StartRow + i][intersectionCol] = word2[i];
+    }
+    
+    const placedWords = [
+      { word: word1, row: centerRow, col: centerCol, direction: 'horizontal', number: 1 },
+      { word: word2, row: word2StartRow, col: intersectionCol, direction: 'vertical', number: 2 }
+    ];
+    
+    const trimmed = this.trimGrid(grid, placedWords);
+    console.log(`✅ Simple cross created successfully`);
+    return { grid: trimmed.grid, size: trimmed.grid.length, placedWords: trimmed.placedWords };
+  }
+
   shuffleArray(array) {
     const shuffled = [...array];
     for (let i = shuffled.length - 1; i > 0; i--) {

crossword-app/frontend/src/App.jsx

@@ -58,6 +58,7 @@ function App() {
       <TopicSelector 
         onTopicsChange={handleTopicsChange}
         availableTopics={topics}
+        selectedTopics={selectedTopics}
       />
 
       <div className="puzzle-controls">

crossword-app/frontend/src/components/TopicSelector.jsx

@@ -1,14 +1,11 @@
-import React, { useState } from 'react';
-
-const TopicSelector = ({ onTopicsChange, availableTopics = [] }) => {
-  const [selectedTopics, setSelectedTopics] = useState([]);
+import React from 'react';
 
+const TopicSelector = ({ onTopicsChange, availableTopics = [], selectedTopics = [] }) => {
   const handleTopicToggle = (topic) => {
     const newSelectedTopics = selectedTopics.includes(topic)
       ? selectedTopics.filter(t => t !== topic)
       : [...selectedTopics, topic];
     
-    setSelectedTopics(newSelectedTopics);
     onTopicsChange(newSelectedTopics);
   };
 

crossword-app/frontend/src/hooks/useCrossword.js

@@ -38,7 +38,10 @@ const useCrossword = () => {
         })
       });
 
-      if (!response.ok) throw new Error('Failed to generate puzzle');
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || 'Failed to generate puzzle');
+      }
       
       const puzzleData = await response.json();
       setPuzzle(puzzleData);