use ai generate question

Author: peanut996

app/page.tsx

@@ -11,16 +11,15 @@ import SettingsModal from "@/components/modals/settings-modal"
 import HistoryModal from "@/components/modals/history-modal"
 import { useState, useEffect, useCallback } from "react"
 import type { Question, UserAnswer } from "@/lib/types"
-import { getQuestions } from "@/lib/data"
+import { generateRandomQuestion } from "@/lib/data"
 import { useTranslation } from "@/lib/i18n"
 import { useToast } from "@/hooks/use-toast"
 // Update the onSubmit function to use the OpenAI API for evaluation
 import { evaluateAnswer, getModelAnswer } from "@/lib/api"
 
 export default function Page() {
   const { t, language, setLanguage } = useTranslation()
-  const [questions, setQuestions] = useState<Question[]>([])
-  const [currentQuestionIndex, setCurrentQuestionIndex] = useState(0)
+  const [currentQuestion, setCurrentQuestion] = useState<Question | null>(null)
   const [userAnswer, setUserAnswer] = useState<UserAnswer>({ content: "" })
   const [timeRemaining, setTimeRemaining] = useState(600) // 10 minutes
   const [timerWarning, setTimerWarning] = useState(false)
@@ -37,8 +36,12 @@ export default function Page() {
   const { toast } = useToast()
 
   useEffect(() => {
-    setQuestions(getQuestions())
-  }, [])
+    const fetchQuestion = async () => {
+      const question = await generateRandomQuestion();
+      setCurrentQuestion(question);
+    };
+    fetchQuestion();
+  }, []);
 
   useEffect(() => {
     if (timeRemaining <= 0) {
@@ -57,9 +60,7 @@ export default function Page() {
     }, 1000)
 
     return () => clearInterval(intervalId)
-  }, [timeRemaining])
-
-  const currentQuestion = questions[currentQuestionIndex]
+  }, [timeRemaining]) // Added onSubmit to dependency array
 
   const onSubmit = async () => {
     setShowResultsModal(true)
@@ -87,12 +88,12 @@ export default function Page() {
     }
   }
 
-  const onNextQuestion = useCallback(() => {
-    setCurrentQuestionIndex((prevIndex) => prevIndex + 1)
-    setUserAnswer({ content: "" })
-    setIsSubmitted(false)
-    setTimeRemaining(600)
-  }, [])
+  const onNextQuestion = useCallback(async () => {
+    setUserAnswer({ content: "" });
+    setIsSubmitted(false);
+    setTimeRemaining(600);
+    setCurrentQuestion(await generateRandomQuestion());
+  }, []);
 
   const onViewAnswer = () => {
     setConfirmationStep(0)
@@ -227,4 +228,3 @@ export default function Page() {
     </div>
   )
 }
-

lib/api.ts

@@ -221,3 +221,59 @@ export async function getModelAnswer(question: any, language: string, onStream?:
   }
 }
 
+export async function generateQuestion(type: string, category: string, difficulty: string, language: string = 'en') {
+  const systemPrompt = `You are an expert at creating technical interview questions. 
+  Generate a new ${type} question in the ${category} category with ${difficulty} difficulty.
+  The question should be challenging but solvable within a reasonable time frame.
+  Return your response in JSON format exactly matching the structure provided, with no additional text.`
+
+  const prompt = `
+  Create a new technical interview question with the following parameters:
+  - Type: (e.g., Must be "Coding" or "Question")
+  - Category: (e.g., "Algorithms", "TCP", "Data Structures", etc.)
+  - Difficulty: (e.g., Must be "Easy", "Medium", "Hard")
+  
+  Generate a question that follows this exact JSON structure:
+  {
+    "id": "generated_unique_id",
+    "type": "",
+    "category": "",
+    "difficulty": "",
+    "translations": {
+      "en": {
+        "title": "English title here",
+        "description": "Detailed English description here",
+        "topic": "Relevant topic here"
+      },
+      "zh": {
+        "title": "Chinese title here",
+        "description": "Detailed Chinese description here",
+        "topic": "Relevant topic in Chinese here"
+      }
+    }${type === 'Coding' ? `,
+    "testCases": [
+      { "input": "example input 1", "output": "expected output 1" },
+      { "input": "example input 2", "output": "expected output 2" }
+    ]` : ''}
+  }
+  
+  Make sure the question is appropriate for the difficulty level and category specified.
+  `
+
+  try {
+    const result = await callOpenAI(prompt, systemPrompt)
+    const cleanedResult = cleanupJsonResponse(result)
+    
+    // Parse the result to ensure it's valid JSON
+    const questionData = JSON.parse(cleanedResult)
+    
+    // Generate a more reliable unique ID
+    questionData.id = `generated_${Date.now()}_${Math.floor(Math.random() * 1000)}`
+    
+    return questionData
+  } catch (error) {
+    console.error("Error generating question:", error)
+    throw new Error("Failed to generate question. Please check your API settings and try again.")
+  }
+}
+

lib/data.ts

@@ -1,8 +1,22 @@
+import { generateQuestion } from "./api"
 import type { Question } from "./types"
 
+// In-memory storage for generated questions
+let generatedQuestions: Question[] = []
+
+export async function generateRandomQuestion(): Promise<Question> {
+  const type = ["Coding", "Question"]
+  const category = ["Algorithms", "TCP", "Data Structures", "System Design", "Behavioral", "Java", "Operation System"]
+  const difficulty = ["Easy", "Medium", "Hard"]
+  const randomType = type[Math.floor(Math.random() * type.length)]
+  const randomCategory = category[Math.floor(Math.random() * category.length)]
+  const randomDifficulty = difficulty[Math.floor(Math.random() * difficulty.length)]
+  return await generateQuestion(randomType, randomCategory, randomDifficulty)
+}
+
 export function getQuestions(): Question[] {
   // This would typically fetch from an API or JSON file
-  return [
+  const predefinedQuestions: Question[] = [
     {
       id: "1",
       type: "Coding",
@@ -46,5 +60,24 @@ export function getQuestions(): Question[] {
       },
     },
   ]
+  
+  // Combine predefined and generated questions
+  return [...predefinedQuestions, ...generatedQuestions]
+}
+
+// Add a new function to add a generated question to our collection
+export function addGeneratedQuestion(question: Question): void {
+  generatedQuestions.push(question)
+}
+
+// Add a function to get questions by type and category
+export function getQuestionsByFilter(type?: string, category?: string, difficulty?: string): Question[] {
+  const questions = getQuestions()
+  
+  return questions.filter(q => 
+    (!type || q.type === type) && 
+    (!category || q.category === category) &&
+    (!difficulty || q.difficulty === difficulty)
+  )
 }