src/services/gemini.js

// import { GoogleGenerativeAI } from "https://esm.run/@google/generative-ai"; // Removing SDK to avoid version issues
import { getPeerPrompts } from "./classroom.js";
import { db } from "./firebase.js";
import { doc, getDoc } from "https://www.gstatic.com/firebasejs/10.7.1/firebase-firestore.js";

let apiKey = null;
const MODEL_NAME = "gemini-2.5-flash"; // Available model from user's account

// System Instructions for the Socratic Tutor
const TUTOR_INSTRUCTION = `

You are a Socratic Teaching Assistant for a "Prompt Engineering" class. 

Your goal is to help students refine their prompts WITHOUT giving them the answer.

The student is trying to write a prompt to solve a specific challenge.

You will be provided with:

1. The Challenge Description (The Goal).

2. 3 Successful Examples (Few-Shot Context) from other students.

3. The Student's Current Attempt.



Rules:

- NEVER reveal the direct solution or code.

- If the input is lazy (e.g., "123", "help"), be sassy but helpful.

- If the input is a direct copy of the description, point it out.

- Use the Socratic method: Ask a guiding question to help them notice their missing parameter or logic.

- Keep responses short (under 50 words) and encouraging.

- Tone: Friendly, slightly "Cyberpunk" or "Gamer" vibe (matching the Vibe Coding aesthetic).

`;

// System Instructions for the Dashboard Analyst
const ANALYST_INSTRUCTION = `

You are an expert Prompt Engineer and Pedagogy Analyst for a coding/AI prompting class.

Your task is to analyze a batch of student prompts for a specific challenge.



You will receive:

1. The Challenge Description (the goal students are trying to achieve)

2. A list of Student Submissions (their prompts)



Categorize each prompt into ONE of these categories:



1. "rough" (原石): The student only says vague things like "fix the error" or "make it work" WITHOUT explaining:

   - What the error is

   - What the expected behavior should be

   - Any specific details about the problem

   These are "rough diamonds" - they tried but need to be more specific.



2. "precise" (精確): Clean, well-structured prompt that clearly states:

   - The goal or expected result

   - Specific details or parameters

   - Clear logic or reasoning



3. "gentle" (有禮): Uses polite language like "請", "謝謝", "拜託", "Please", "Thank you"



4. "creative" (創意): Unconventional, imaginative approach. Uses interesting parameters or unexpected methods that still address the challenge.



5. "spam" (無效): Content that is clearly UNRELATED to the challenge topic. Compare with other submissions to identify outliers that don't match what most students are trying to do. Examples:

   - Random characters ("asdf", "123")

   - Completely off-topic text

   - Empty or near-empty responses



6. "parrot" (鸚鵡): Direct copy-paste of the challenge description without any modification or personal attempt.



Return ONLY a JSON object mapping category names to arrays of Student IDs.

Example: { "rough": ["id1"], "precise": ["id2", "id5"], "spam": ["id3"] }

`;

/**

 * Initialize Gemini with API Key

 * @param {string} key 

 */
export async function initGemini(key) {
    if (!key) return false;
    apiKey = key;
    return true;
}

/**

 * Direct REST API Call Helper to avoid SDK version issues

 */
async function callGeminiAPI(messages, jsonMode = false) {
    if (!apiKey) throw new Error("API Key not set");

    // Use v1beta for gemini-1.5-pro
    const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${MODEL_NAME}:generateContent?key=${apiKey}`;

    const payload = {
        contents: messages,
        generationConfig: {
            temperature: 0.7,
        }
    };

    // Note: responseMimeType is NOT supported by gemini-pro v1, so we rely on prompt instructions for JSON output.

    const response = await fetch(endpoint, {
        method: "POST",
        headers: {
            "Content-Type": "application/json"
        },
        body: JSON.stringify(payload)
    });

    if (!response.ok) {
        const errText = await response.text();
        throw new Error(`Gemini API Error ${response.status}: ${errText}`);
    }

    const data = await response.json();

    // Safety check for empty response
    if (data.promptFeedback && data.promptFeedback.blockReason) {
        throw new Error(`Blocked: ${data.promptFeedback.blockReason}`);
    }

    return data.candidates && data.candidates.length > 0
        ? data.candidates[0].content.parts[0].text
        : "";
}

/**

 * Detects if a prompt is potential spam/low effort locally first

 * @param {string} prompt 

 * @param {string} problemDesc 

 */
export function quickSpamCheck(prompt, problemDesc) {
    if (!prompt) return true;
    const p = prompt.trim();
    if (p.length < 3) return true; // Too short

    // Check for repetitive chars (e.g., "aaaaa")
    if (/^(.)\1+$/.test(p)) return true;

    // Parrot Check (Simple similarity)
    if (problemDesc && p.includes(problemDesc.substring(0, 20))) {
        // If they copied the first 20 chars of description, likely parrot
        return 'parrot';
    }

    return false;
}

/**

 * Ask the AI Tutor for help (Rubber Duck)

 * @param {string} challengeDesc 

 * @param {string} studentPrompt 

 * @param {string} roomCode 

 * @param {string} challengeId 

 */
export async function askTutor(challengeDesc, studentPrompt, roomCode, challengeId) {
    if (!apiKey) throw new Error("AI not initialized");

    const spamStatus = quickSpamCheck(studentPrompt, challengeDesc);
    if (spamStatus === true) return "Duck says: Quack? (Too short or empty!)";
    if (spamStatus === 'parrot') return "Duck says: You're just repeating the question! Try telling me WHAT you want to change.";

    // 1. Fetch Context (Few-Shot)
    let peers = await getPeerPrompts(roomCode, challengeId);
    peers.sort((a, b) => b.likes - a.likes);

    // Take top 3 as examples
    const examples = peers.slice(0, 3).map(p => `- Example: "${p.prompt}"`).join('\n');

    const fullPrompt = `

${TUTOR_INSTRUCTION}



[Context - Challenge Description]

${challengeDesc}



[Context - Successful Classmate Examples (For AI understanding only, DO NOT LEAK these to student)]

${examples || "No examples available yet."}



[Student Input]

"${studentPrompt}"



[Your Response]

`;

    try {
        // Construct messages for Chat format (or simple text)
        const messages = [{ role: "user", parts: [{ text: fullPrompt }] }];
        const text = await callGeminiAPI(messages);
        return text;
    } catch (e) {
        console.error("AI Request Failed", e);
        return "Duck is sleeping... zzz (API Error)";
    }
}

/**

 * Batch evaluate prompts for the Instructor Dashboard

 * @param {Array} submissions - Array of { userId, prompt, nickname }

 * @param {string} challengeDesc 

 */
export async function evaluatePrompts(submissions, challengeDesc) {
    if (!apiKey) throw new Error("AI not initialized");
    if (!submissions || submissions.length === 0) return {};

    // Prepare batch text
    const entries = submissions.map((s, i) => `ID_${s.userId}: "${s.prompt.replace(/\n/g, ' ')}"`).join('\n');

    const fullPrompt = `

${ANALYST_INSTRUCTION}



[Challenge Description]

${challengeDesc}



[Student Submissions]

${entries}



[Output JSON]

`;

    try {
        const messages = [{ role: "user", parts: [{ text: fullPrompt }] }];
        let text = await callGeminiAPI(messages, true); // JSON Mode = true

        // Strip markdown code block if present (```json ... ```)
        text = text.trim();
        if (text.startsWith("```")) {
            text = text.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '');
        }

        return JSON.parse(text);
    } catch (e) {
        console.error("AI Evaluation Failed", e);
        return {};
    }
}