Ab ek or kaam karo ki agar user sub or topic mei kise ek ko choose karne

src/ai/flows/generate-mock-exam-questions.ts

@@ -16,8 +16,8 @@ import {z} from 'genkit';
 // Input Schema
 const GenerateMockExamQuestionsInputSchema = z.object({
   exam: z.string().describe('The name of the Indian Government Exam.'),
-  subject: z.string().optional().describe('The subject for the questions (optional).'),
-  topic: z.string().optional().describe('The specific topic within the subject (optional).'),
+  subjects: z.array(z.string()).optional().describe('A list of subjects for the questions (optional).'),
+  topics: z.array(z.string()).optional().describe('A list of specific topics within the subjects (optional).'),
   difficulty: z.enum(['Easy', 'Medium', 'Hard', 'Mixed']).describe('The difficulty level of the questions.'),
   numberOfQuestions: z.number().int().min(1).max(100).describe('The number of questions to generate.'),
   language: z.enum(['English', 'Hindi', 'Bilingual']).describe('The language for the questions and options.'),
@@ -32,6 +32,8 @@ const QuestionOutputSchema = z.object({
   options: z.array(z.string()).length(4).describe('An array containing the four answer options (A, B, C, D).'),
   correctAnswerIndex: z.number().int().min(0).max(3).describe('The 0-indexed position of the correct answer within the options array.'),
   explanation: z.string().describe('A detailed explanation for the correct answer.'),
+  subject: z.string().describe('The subject this question belongs to.'),
+  topic: z.string().describe('The topic this question belongs to.'),
 });
 
 const GenerateMockExamQuestionsOutputSchema = z.array(QuestionOutputSchema).describe('An array of generated multiple-choice questions.');
@@ -44,11 +46,11 @@ Your task is to generate {{numberOfQuestions}} unique multiple-choice questions
 
 The difficulty level should be "{{difficulty}}".
 
-{{#if subject}}
-Focus on the subject: "{{subject}}".
+{{#if subjects}}
+Focus on the following subjects: {{#each subjects}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}.
 {{/if}}
-{{#if topic}}
-Specifically, cover the topic: "{{topic}}".
+{{#if topics}}
+Within those subjects, specifically cover these topics: {{#each topics}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}.
 {{/if}}
 
 {{#if suggestion}}
@@ -57,26 +59,26 @@ Specifically, cover the topic: "{{topic}}".
 
 **VERY IMPORTANT INSTRUCTIONS FOR ACCURACY:**
 
-1.  **Chain of Thought Process:** Before creating the options, first, think step-by-step to formulate the question text and determine the single, unambiguously correct answer and a detailed explanation. Only after this internal verification should you create the multiple-choice options. Ensure one option is 100% correct and the others are plausible but incorrect distractors.
+1.  **Chain of Thought Process:** Before creating the options, first, think step-by-step to formulate the question text, determine its subject and topic, find the single, unambiguously correct answer, and create a detailed explanation. Only after this internal verification should you create the multiple-choice options. Ensure one option is 100% correct and the others are plausible but incorrect distractors.
 
-2.  **Subject-Specific Rules:**
-    {{#if subject}}
-    When the subject is "Quantitative Aptitude" or "Mathematics":
+2.  **Subject-Specific Rules:** For each question you generate, apply the following rules based on its subject:
+    When a question's subject is "Quantitative Aptitude" or "Mathematics":
     - **CRITICAL FOR RENDERING:** Wrap all mathematical formulas and expressions in single dollar signs for inline math (e.g., $x^2 + y^2 = r^2$) and double dollar signs for block-level math. For example: $$ \\frac{a}{b} $$. This is absolutely essential for the formulas to display correctly.
     - Solve the question yourself step-by-step to ensure the correct answer is generated accurately before creating the options.
 
-    When the subject is "English Language & Comprehension" or "English":
+    When a question's subject is "English Language & Comprehension" or "English":
     - Strictly adhere to established grammar rules, like those found in Wren & Martin. Avoid using ambiguous synonyms or idioms in a way that could have multiple interpretations.
 
-    When the subject is "General Intelligence & Reasoning" or "Reasoning":
+    When a question's subject is "General Intelligence & Reasoning" or "Reasoning":
     - Double-check the logic of any patterns (e.g., in number or letter series). The logic must be consistent and not open to interpretation. Verify your own logic before finalizing the question.
-    {{/if}}
 
 Your final output **MUST** be a JSON array of question objects. Each object must have:
 - 'questionText': The question itself. Ensure all math expressions are wrapped in dollar signs ($...$ or $$...$$).
 - 'options': An array of exactly four distinct answer choices.
 - 'correctAnswerIndex': The 0-indexed number (0, 1, 2, or 3) corresponding to the correct answer in the 'options' array.
 - 'explanation': Provide a detailed, step-by-step explanation in simple, easy-to-understand language. First, explain the conventional method. Then, if a faster method exists, add a section titled "**Short Trick:**" and explain the shortcut. **Ensure all mathematical expressions are in LaTeX format and correctly wrapped in dollar signs ($...$ for inline and $$...$$ for block) for proper rendering.**
+- 'subject': The subject this question belongs to from the provided list of subjects.
+- 'topic': The specific topic this question belongs to.
 
 Ensure the questions are relevant, clear, and unambiguous.
 `;

src/components/result-page.tsx

@@ -16,7 +16,6 @@ import rehypeKatex from 'rehype-katex';
 
 import type { TestResult, TestSession } from '@/lib/types';
 import { offerPersonalizedStudySuggestions } from '@/ai/flows/offer-personalized-study-suggestions';
-import { useToast } from '@/hooks/use-toast';
 
 const COLORS = {
   correct: 'hsl(var(--chart-2))',
@@ -28,7 +27,6 @@ export function ResultPageClient({ resultId }: { resultId: string }) {
   const [suggestions, setSuggestions] = useState<string[]>([]);
   const { user, isUserLoading } = useUser();
   const firestore = useFirestore();
-  const { toast } = useToast();
 
   const resultRef = useMemoFirebase(() => {
     if (!user || !firestore) return null;
@@ -56,7 +54,7 @@ export function ResultPageClient({ resultId }: { resultId: string }) {
               skippedQuestions: result.skipped,
               overallAccuracy: result.accuracy,
               performanceBreakdown: result.performanceBreakdown.map(p => ({
-                categoryType: result.config.topic ? 'topic' as const : 'subject' as const,
+                categoryType: p.categoryType,
                 categoryName: p.category,
                 correctCount: p.correctCount,
                 incorrectCount: p.incorrectCount,

src/components/test-interface.tsx

@@ -130,14 +130,27 @@ export function TestInterface({ testId }: { testId: string }) {
         let incorrectAnswers = 0;
         let skipped = 0;
 
+        const performanceByCategory: { [key: string]: { correct: number; incorrect: number; skipped: number; total: number; type: 'subject' | 'topic' } } = {};
+
         session.questions.forEach((q, i) => {
+            const categoryName = q.topic || q.subject;
+            const categoryType = q.topic ? 'topic' as const : 'subject' as const;
+
+            if (!performanceByCategory[categoryName]) {
+                performanceByCategory[categoryName] = { correct: 0, incorrect: 0, skipped: 0, total: 0, type: categoryType };
+            }
+            performanceByCategory[categoryName].total++;
+
             const userAnswer = session.userAnswers[i];
             if (userAnswer.status === 'not-visited' || userAnswer.status === 'not-answered' || userAnswer.status === 'marked-for-review') {
                 skipped++;
+                performanceByCategory[categoryName].skipped++;
             } else if (userAnswer.selectedOption === q.correctAnswerIndex) {
                 correctAnswers++;
+                performanceByCategory[categoryName].correct++;
             } else {
                 incorrectAnswers++;
+                performanceByCategory[categoryName].incorrect++;
             }
         });
         
@@ -149,22 +162,18 @@ export function TestInterface({ testId }: { testId: string }) {
             score -= incorrectAnswers * session.config.negativeMarkingRatio;
         }
 
-        const performanceBreakdown: import('@/lib/types').PerformanceBreakdown[] = [];
-
-        if (session.config.topic || session.config.subject) {
-            const categoryName = session.config.topic || session.config.subject!;
-            const attemptedInCategory = correctAnswers + incorrectAnswers;
-            const accuracyInCategory = attemptedInCategory > 0 ? (correctAnswers / attemptedInCategory) * 100 : 0;
-            
-            performanceBreakdown.push({
-                category: categoryName,
-                accuracy: accuracyInCategory,
-                correctCount: correctAnswers,
-                incorrectCount: incorrectAnswers,
-                skippedCount: skipped,
-                totalCount: session.questions.length,
-            });
-        }
+        const performanceBreakdown: import('@/lib/types').PerformanceBreakdown[] = Object.entries(performanceByCategory).map(([category, stats]) => {
+            const attemptedInCategory = stats.correct + stats.incorrect;
+            return {
+                category: category,
+                categoryType: stats.type,
+                accuracy: attemptedInCategory > 0 ? (stats.correct / attemptedInCategory) * 100 : 0,
+                correctCount: stats.correct,
+                incorrectCount: stats.incorrect,
+                skippedCount: stats.skipped,
+                totalCount: stats.total,
+            };
+        });
 
         const result: TestResult = {
             id: session.id,
@@ -181,7 +190,7 @@ export function TestInterface({ testId }: { testId: string }) {
             performanceBreakdown,
         };
         
-        const finalSession: TestSession = { ...session, userId: user.uid, endTime: endTime };
+        const finalSession: TestSession = { ...session, userId: user.uid, endTime: endTime, userAnswers: session.userAnswers.map(ua => ({...ua, selectedOption: ua.selectedOption === undefined ? null : ua.selectedOption})) };
         
         const batch = writeBatch(firestore);
 

src/components/test-setup-form.tsx

@@ -24,6 +24,15 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
+import {
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+
 import { Input } from "@/components/ui/input";
 import { Switch } from "@/components/ui/switch";
 import { Slider } from "@/components/ui/slider";
@@ -35,11 +44,13 @@ import type { TestSession, UserConfiguration } from "@/lib/types";
 import { useDoc, useUser, useFirestore, useMemoFirebase } from "@/firebase";
 import { doc } from "firebase/firestore";
 import { Textarea } from "./ui/textarea";
+import { ScrollArea } from "./ui/scroll-area";
+import { cn } from "@/lib/utils";
 
 const formSchema = z.object({
   exam: z.string({ required_error: "Please select an exam." }),
-  subject: z.string().optional(),
-  topic: z.string().optional(),
+  subjects: z.array(z.string()).optional(),
+  topics: z.array(z.string()).optional(),
   numberOfQuestions: z.number().min(5).max(100),
   difficulty: z.enum(DIFFICULTIES),
   language: z.enum(LANGUAGES),
@@ -72,6 +83,8 @@ export function TestSetupForm() {
   const form = useForm<z.infer<typeof formSchema>>({
     resolver: zodResolver(formSchema),
     defaultValues: {
+      subjects: [],
+      topics: [],
       numberOfQuestions: 10,
       difficulty: "Medium",
       language: "English",
@@ -80,38 +93,41 @@ export function TestSetupForm() {
   });
 
   const examValue = form.watch("exam");
-  const subjectValue = form.watch("subject");
+  const subjectsValue = form.watch("subjects");
   const negativeMarkingValue = form.watch("negativeMarking");
   
   useEffect(() => {
     if (examValue) {
       const availableSubjects = SUBJECTS[examValue] || [];
       setSubjects(availableSubjects);
-      const currentSubject = form.getValues('subject');
-      if(currentSubject && currentSubject !== 'all' && !availableSubjects.includes(currentSubject)) {
-        form.resetField("subject", { defaultValue: undefined });
-        form.resetField("topic", { defaultValue: undefined });
+      const currentSubjects = form.getValues('subjects') || [];
+      const validSubjects = currentSubjects.filter(s => availableSubjects.includes(s));
+
+      if (validSubjects.length !== currentSubjects.length) {
+          form.setValue("subjects", validSubjects);
       }
     } else {
       setSubjects([]);
-      form.resetField("subject", { defaultValue: undefined });
-      form.resetField("topic", { defaultValue: undefined });
+      form.setValue("subjects", []);
     }
-  }, [examValue, form]);
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [examValue]);
 
   useEffect(() => {
-    if (examValue && subjectValue) {
-        const availableTopics = TOPICS[examValue]?.[subjectValue] || [];
+    if (examValue && subjectsValue && subjectsValue.length === 1) {
+        const availableTopics = TOPICS[examValue]?.[subjectsValue[0]] || [];
         setTopics(availableTopics);
-        const currentTopic = form.getValues('topic');
-        if(currentTopic && currentTopic !== 'all' && !availableTopics.includes(currentTopic)) {
-            form.resetField("topic", { defaultValue: undefined });
+        const currentTopics = form.getValues('topics') || [];
+        const validTopics = currentTopics.filter(t => availableTopics.includes(t));
+        if(validTopics.length !== currentTopics.length) {
+            form.setValue('topics', validTopics);
         }
     } else {
         setTopics([]);
-        form.resetField("topic", { defaultValue: undefined });
+        form.setValue('topics', []);
     }
-  }, [examValue, subjectValue, form]);
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [examValue, subjectsValue]);
 
 
   function onSubmit(values: z.infer<typeof formSchema>) {
@@ -129,8 +145,8 @@ export function TestSetupForm() {
       try {
         const questions = await generateMockExamQuestions({
           exam: values.exam,
-          subject: values.subject === 'all' ? undefined : values.subject,
-          topic: values.topic === 'all' ? undefined : values.topic,
+          subjects: values.subjects && values.subjects.length > 0 ? values.subjects : undefined,
+          topics: values.topics && values.topics.length > 0 ? values.topics : undefined,
           numberOfQuestions: values.numberOfQuestions,
           difficulty: values.difficulty,
           language: values.language,
@@ -200,32 +216,115 @@ export function TestSetupForm() {
             />
             <FormField
               control={form.control}
-              name="subject"
+              name="subjects"
               render={({ field }) => (
                 <FormItem>
-                  <FormLabel>Subject (Optional)</FormLabel>
-                  <Select onValueChange={field.onChange} value={field.value ?? 'all'} disabled={subjects.length === 0}>
-                    <FormControl>
-                      <SelectTrigger><SelectValue placeholder="Select a subject" /></SelectTrigger>
-                    </FormControl>
-                    <SelectContent><SelectItem value="all">All Subjects</SelectItem>{subjects.map(s => <SelectItem key={s} value={s}>{s}</SelectItem>)}</SelectContent>
-                  </Select>
+                  <FormLabel>Subjects</FormLabel>
+                   <DropdownMenu>
+                    <DropdownMenuTrigger asChild>
+                      <FormControl>
+                        <Button
+                          variant="outline"
+                          className={cn(
+                            "w-full justify-start text-left font-normal h-auto min-h-10 py-2",
+                            !field.value?.length && "text-muted-foreground"
+                          )}
+                          disabled={subjects.length === 0}
+                        >
+                          {field.value?.length > 0 ? (
+                             <div className="flex gap-2 flex-wrap">
+                                {field.value.map(val => (
+                                    <div key={val} className="truncate rounded-md bg-secondary text-secondary-foreground px-2 py-1 text-xs">
+                                        {val}
+                                    </div>
+                                ))}
+                             </div>
+                          ) : (
+                            "Select subjects"
+                          )}
+                        </Button>
+                      </FormControl>
+                    </DropdownMenuTrigger>
+                    <DropdownMenuContent className="w-[var(--radix-dropdown-menu-trigger-width)]" align="start">
+                        <DropdownMenuLabel>Available Subjects</DropdownMenuLabel>
+                        <DropdownMenuSeparator />
+                        <ScrollArea className="h-48">
+                            {subjects.map(subject => (
+                                <DropdownMenuCheckboxItem
+                                key={subject}
+                                checked={field.value?.includes(subject)}
+                                onCheckedChange={(checked) => {
+                                    const selected = field.value || [];
+                                    return checked
+                                    ? field.onChange([...selected, subject])
+                                    : field.onChange(selected.filter(s => s !== subject));
+                                }}
+                                >
+                                {subject}
+                                </DropdownMenuCheckboxItem>
+                            ))}
+                        </ScrollArea>
+                    </DropdownMenuContent>
+                  </DropdownMenu>
                   <FormMessage />
                 </FormItem>
               )}
             />
              <FormField
               control={form.control}
-              name="topic"
+              name="topics"
               render={({ field }) => (
                 <FormItem>
-                  <FormLabel>Topic (Optional)</FormLabel>
-                  <Select onValueChange={field.onChange} value={field.value ?? 'all'} disabled={topics.length === 0}>
-                    <FormControl>
-                      <SelectTrigger><SelectValue placeholder="Select a topic" /></SelectTrigger>
-                    </FormControl>
-                    <SelectContent><SelectItem value="all">All Topics</SelectItem>{topics.map(t => <SelectItem key={t} value={t}>{t}</SelectItem>)}</SelectContent>
-                  </Select>
+                  <FormLabel>Topics</FormLabel>
+                  <DropdownMenu>
+                    <DropdownMenuTrigger asChild>
+                      <FormControl>
+                        <Button
+                           variant="outline"
+                           className={cn(
+                            "w-full justify-start text-left font-normal h-auto min-h-10 py-2",
+                            !field.value?.length && "text-muted-foreground"
+                          )}
+                          disabled={topics.length === 0}
+                        >
+                          {field.value?.length > 0 ? (
+                             <div className="flex gap-2 flex-wrap">
+                                {field.value.map(val => (
+                                    <div key={val} className="truncate rounded-md bg-secondary text-secondary-foreground px-2 py-1 text-xs">
+                                        {val}
+                                    </div>
+                                ))}
+                             </div>
+                          ) : (
+                            "Select topics"
+                          )}
+                        </Button>
+                      </FormControl>
+                    </DropdownMenuTrigger>
+                    <DropdownMenuContent className="w-[var(--radix-dropdown-menu-trigger-width)]" align="start">
+                        <DropdownMenuLabel>Available Topics</DropdownMenuLabel>
+                        <DropdownMenuSeparator />
+                         <ScrollArea className="h-48">
+                            {topics.map(topic => (
+                                <DropdownMenuCheckboxItem
+                                key={topic}
+                                checked={field.value?.includes(topic)}
+                                onCheckedChange={(checked) => {
+                                    const selected = field.value || [];
+                                    return checked
+                                    ? field.onChange([...selected, topic])
+                                    : field.onChange(selected.filter(s => s !== topic));
+                                }}
+                                >
+                                {topic}
+                                </DropdownMenuCheckboxItem>
+                            ))}
+                        </ScrollArea>
+                    </DropdownMenuContent>
+                  </DropdownMenu>
+                   <FormDescription>
+                    Topics are only available when one subject is selected.
+                  </FormDescription>
                   <FormMessage />
                 </FormItem>
               )}

src/lib/types.ts

@@ -10,8 +10,8 @@ export type AIProviderSettings = {
 
 export type ExamConfig = {
   exam: string;
-  subject?: string;
-  topic?: string;
+  subjects?: string[];
+  topics?: string[];
   numberOfQuestions: number;
   difficulty: 'Easy' | 'Medium' | 'Hard' | 'Mixed';
   language: 'English' | 'Hindi' | 'Bilingual';
@@ -45,6 +45,7 @@ export type TestSession = {
 
 export type PerformanceBreakdown = {
   category: string;
+  categoryType: 'subject' | 'topic';
   accuracy: number;
   correctCount: number;
   incorrectCount: number;