app/services/llm_engine.py

import os
import json
from groq import AsyncGroq
from dotenv import load_dotenv
from app.services.skill_manager import skill_manager

load_dotenv()

class LLMEngine:
    def __init__(self):
        self.clients = []
        
        key1 = os.getenv("GROQ_API_KEY")
        if key1:
            try:
                self.clients.append(AsyncGroq(api_key=key1))
            except Exception as e:
                print(f"⚠️ Gagal memuat Token Utama: {e}")

        key2 = os.getenv("GROQ_API_KEY_BACKUP")
        if key2:
            try:
                self.clients.append(AsyncGroq(api_key=key2))
            except Exception as e:
                print(f"⚠️ Gagal memuat Token Backup: {e}")
            
        print(f"✅ LLM Engine (Async) siap dengan {len(self.clients)} Client aktif.")

    async def _execute_with_retry(self, messages, model, temperature=0.5, response_format=None):
        """
        Mencoba request Async secara bergantian.
        """
        if not self.clients:
            raise Exception("Tidak ada API Key Groq yang terdeteksi di .env!")

        last_error = Exception("Unknown Error")

        for i, client in enumerate(self.clients):
            try:
                completion = await client.chat.completions.create(
                    messages=messages,
                    model=model,
                    temperature=temperature,
                    response_format=response_format
                )
                return completion.choices[0].message.content

            except Exception as e:
                print(f"⚠️ Token ke-{i+1} Gagal. Error: {e}")
                last_error = e
                continue
        
        print("❌ Semua Token Gagal/Habis.")
        raise last_error

    async def process_user_intent(self, user_text: str, available_skills: list, user_role: str = "", history: list = []):
        skills_str = "\n".join([f"- {s}" for s in available_skills])
        role_status_str = "USER BELUM MEMILIKI ROLE (ROLE KOSONG)." if not user_role else f"USER ROLE: {user_role}"
        
        system_prompt = f"""
        ROLE: Kamu adalah 'Router' untuk MORA, sebuah AI Learning Assistant.
        Tugasmu BUKAN menjawab pertanyaan, tapi mengarahkan user ke fitur yang benar.
        
        DAFTAR SKILL TERSEDIA DI DATABASE:
        {skills_str}
        STATUS USER SAAT INI: {role_status_str}
        
        INSTRUKSI UTAMA:
        Analisis pesan user DAN HISTORY PERCAKAPAN untuk menentukan ACTION JSON.
        
        1. ACTION: "START_EXAM"
            - Trigger: User ingin "tes", "ujian", "uji kemampuan", "soal", atau menyebut topik teknis (SQL, Python, CV, NLP). kalau user tidak menyebut keyword teknis dari subskill maka akan menampilkan list dari sub skill yang ada. 
            - TUGAS PENTING (MAPPING): User sering menyebut topik spesifik (misal "SQL"). Kamu WAJIB mencocokkannya dengan "Nama Skill Tersedia" yang paling relevan.
                Contoh: 
                - User: "Tes SQL" -> Detected: "Software & Data Foundations"
                - User: "Tes Vision" -> Detected: "Deep Learning & Computer Vision"
                - User: "Tes HTML" -> Detected: "HTML & CSS Fundamentals
            
        2. ACTION: "GET_RECOMMENDATION" (FOKUS: MASA DEPAN / SARAN)
           - Trigger: User bingung mau belajar apa, minta saran, minta roadmap, atau bertanya "Next step apa?".
           - Contoh: "Saya harus belajar apa?", "Rekomendasi materi dong", "Habis ini enaknya belajar apa?".
           - PENTING: Jangan pilih ini jika user hanya ingin melihat data  progress, nilai/laporan.
            
        3. ACTION: "START_PSYCH_TEST"
           - Trigger: Role Kosong, tanya "karir", "cocok kerja apa" user bingung minat.
           - KONTEKS: Jika di history BOT menawarakan tes minat, dan User jawab "Mau/Ya/Boleh", PILIH INI.

        3. ACTION: "CHECK_PROGRESS" (FOKUS: PROGRESS / DATA / LAPORAN / NILAI )
           - Trigger: User ingin melihat HASIL belajarnya, statistiknya, progressnya, atau pencapaiannya sejauh ini.
           - Kata Kunci Spesifik: "Progress", "Rapor", "Nilai saya", "Laporan", "Stats", "Pencapaian", "Sejauh mana", "Sudah berapa persen".
           - Contoh: "Cek progress saya", "Lihat nilai ujian kemarin", "Saya sudah sampai mana?".
           
        5. ACTION: "CASUAL_CHAT"
            - Trigger: Hanya untuk sapaan ("Halo"), curhat, atau pertanyaan di luar konteks belajar.
            - JANGAN gunakan ini jika user jelas-jelas minta tes/soal.
            - PENTING Jika role user kosong arahkan untuk tes minat psych test, 
            - di akhir kalimat selalu ajak/tawarkan fitur lain, seperti cek rekomendasi belajar, atau tanya tanya lebih dalam, tes, cek progress, dan lain lain
            - jangan buat soal sendiri
            
        OUTPUT JSON (Hanya JSON, tanpa teks lain):
        {{
            "action": "...",
            "detected_skills": ["Nama Skill Database 1", "Nama Skill Database 2"] (Array berisi String nama skill persis dari daftar diatas. Kosongkan jika tidak ada.)
        }}
        """
        messages = [{"role": "system", "content": system_prompt}]
        
        # Masukkan 5 chat terakhir dari history agar AI tau konteks
        # Kita pastikan formatnya dictionary
        for msg in history[-5:]:
            role = msg.get('role') if isinstance(msg, dict) else msg.role
            content = msg.get('content') if isinstance(msg, dict) else msg.content
            messages.append({"role": role, "content": content})
            
        # Masukkan pesan user saat ini (paling baru)
        messages.append({"role": "user", "content": user_text})
        
        try:
            # Kita panggil _execute_with_retry dan kirim 'messages' yang sudah lengkap tadi
            response_content = await self._execute_with_retry(
                messages=messages,
                model="llama-3.3-70b-versatile",
                temperature=0.0,
                response_format={"type": "json_object"}
            )
            
            print(f"DEBUG AI MAPPING: {response_content}")
            return json.loads(response_content)
            
        except Exception as e:
            print(f"Error Intent: {e}")
            # Fallback aman
            return {"action": "CASUAL_CHAT", "detected_skills": []}
            
    async def generate_question(self, topics: list, level: str):
        topics_str = ", ".join(topics)
        prompt = f"""
        Buatkan 1 soal esai pendek dengan konsep how, what, why untuk menguji pemahaman user
        Tentang topik: {topics_str}.
        Tingkat Kesulitan: {level}.
        Bahasa: Indonesia.
        
        Output JSON:
        {{
            "question_text": "Pertanyaan...",
            "grading_rubric": {{
                "keywords": ["kata1", "kata2"],
                "explanation_focus": "Poin utama yang harus dijelaskan"
            }}
        }}
        """
        try:
            response_content = await self._execute_with_retry(
                messages=[{"role": "user", "content": prompt}],
                model="llama-3.3-70b-versatile",
                temperature=0.5,
                response_format={"type": "json_object"}
            )
            return json.loads(response_content)
        except Exception as e:
            print(f"ERROR Generate: {e}")
            return {"question_text": f"Error generate soal.{e}", "grading_rubric": {}}

    async def evaluate_answer(self, user_answer: str, question_context: dict):
        prompt = f"""
        Bertindaklah sebagai Dosen AI yang menilai jawaban mahasiswa.
        
        Soal/Konteks: {json.dumps(question_context)}
        Jawaban Mahasiswa: "{user_answer}"
        
        Tugas:
        1. Beri skor 0-100. jika skor dibawah 80 beelum correct
        2. Beri feedback singkat & ramah (Bahasa Indonesia).
            3. Tentukan apakah jawaban BENAR secara konsep (is_correct).
        
        Output JSON:
        {{
            "score": 85,
            "feedback": "Penjelasanmu bagus, tapi kurang detail di bagian...",
            "is_correct": true
        }}
        """
#
        try:
            # Perhatikan: Kita panggil _execute_with_retry, bukan self.client.create
            response_content = await self._execute_with_retry(
                messages=[{"role": "user", "content": prompt}],
                model="llama-3.3-70b-versatile",
                response_format={"type": "json_object"}
            )
            return json.loads(response_content)
        except Exception as e:
            print(f"ERROR Evaluate answer: {e}")
            return {"score": 0, "feedback": "Error menilai.", "is_correct": False}

    async def casual_chat(self, user_text: str, history: list = [], is_role_empty: bool = False):
        
        # 1. BASE SYSTEM PROMPT (Identitas Utama)
        # Ini selalu ada, baik role kosong maupun tidak.
        base_system_prompt = """
        Kamu adalah MORA, asisten belajar AI yang ramah, suportif, dan kekinian. 
        Jawablah dengan singkat, padat, dan menggunakan emoji sesekali.
        """
        
        messages = [
            {"role": "system", "content": base_system_prompt}
        ]

        # 2. INSERT HISTORY (Normal Flow)
        # Kita tetap masukkan history agar konteks obrolan nyambung
        for msg in history[-5:]:
            messages.append({"role": msg['role'], "content": msg['content']})

        # 3. INSERT USER MESSAGE (Normal Flow)
        messages.append({"role": "user", "content": user_text})

        # 4. INJECT RESTRICTION (JIKA ROLE KOSONG)
        # Kita taruh ini DI PALING BAWAH (Setelah user message).
        # Tujuannya: Mengoreksi jika user minta aneh-aneh.
        if is_role_empty:
            restriction_msg = """
            [SYSTEM ALERT - PRIORITY HIGH]
            Status User: ROLE KOSONG (Belum memilih jalur karir).
            
            INSTRUKSI RESPON:
            1. JIKA user meminta Soal/Tes/Coding/rekomendasi/progress:
               TOLAK permintaan tersebut dengan halus.
               Katakan: "Wah semangat banget! 🔥 Tapi pilih Role dulu yuk biar jelas arahnya. Mau coba Tes Minat?" tetapi sesuaikan lagi konteksnya
               
            2. JIKA user hanya menyapa/curhat:
               Respon normal, tapi selipkan saran untuk memilih Role atau Tes Minat.
            """
            # Masukkan sebagai role 'system' agar dipatuhi
            messages.append({"role": "system", "content": restriction_msg})

        # 5. EXECUTE LLM
        try:
            # PENTING: Panggil _execute_with_retry, JANGAN self.client
            response_content = await self._execute_with_retry(
                messages=messages,
                model="llama-3.1-8b-instant",
                temperature=0.6 
            )
            return response_content
            
        except Exception as e:
            return f"Maaf, error sistem: {str(e)}"

    async def analyze_psych_result(self, role: str, traits: list[str]):
        """
        Membuat penjelasan psikologis kenapa user cocok di role tersebut.
        """
        traits_str = "\n".join(traits)
        
        prompt = f"""
        Kamu adalah Konsultan Karir IT yang ahli membaca kepribadian.
        
        DATA USER:
        User baru saja mengikuti tes kepribadian sederhana.
        Hasil kecocokan tertinggi: **{role}**.
        Kebiasaan/Pilihan User:
        {traits_str}
        
        TUGAS:
        Berikan analisis singkat (maksimal 3 kalimat) dan memotivasi.
        Jelaskan hubungan antara kebiasaan user di atas dengan job role {role}.
        Gunakan gaya bahasa santai tapi meyakinkan.
        
        Contoh Output:
        "Wah, kamu punya bakat alami jadi AI Engineer! Kebiasaanmu yang suka menganalisis fakta dan mencari review mendalam menunjukkan kamu punya pola pikir analitis yang kuat, modal penting buat ngolah data!"
        """
        
        try:
            return await self._execute_with_retry(
                messages=[{"role": "user", "content": prompt}],
                model="llama-3.1-8b-instant",
                temperature=0.7
            )
        except Exception as e:
            print(f"ERROR Psych Analyze: {e}")
            return f"Kamu cocok jadi {role}!"

    async def analyze_progress(self, user_name: str, progress_data: dict):
        data_str = json.dumps(progress_data, indent=2)

        system_msg = {
            "role": "system", 
            "content": f"""
            Kamu adalah MORA, asisten belajar AI yang ceria, suportif, dan to-the-point.
            
            TUGAS:
            Analisis data progress student ini dan buat laporan singkat.
            
            DATA PROGRESS:
            {data_str}
            
            ATURAN FORMATTING (WAJIB MARKDOWN):
            1. Sapa user dengan namanya + emoji.
            2. Gunakan **Bold** untuk poin penting (nama course, skor, level).
            3. Pisahkan bagian menjadi dua kategori menggunakan Bullet Points:
               - 🏆 **Highlights** (Untuk course completed / naik level / skor tinggi).
               - 🚧 **Next Focus** (Untuk course yang masih in-progress/macet).
            4. Tutup dengan kalimat ajakan (Call to Action) yang semangat.
            5. Jangan terlalu panjang, maksimal 4-5 baris poin.
            
            Gaya Bahasa: Gaul, motivasi tinggi, pakai emoji (🚀, 🎉, 🔥).
            """
        }
        
        try:
            return await self._execute_with_retry(
                messages=[system_msg],
                model="llama-3.1-8b-instant", 
                temperature=0.7
            )
        except Exception as e:
            print(f"ERROR Analyze Progress: {e}")
            return f"Error generate progress: {str(e)}"

    async def generate_curriculum_stateless(self, user_data: dict):
        """
        Menggabungkan Data JSON Asli + Kecerdasan LLM.
        """
        name = user_data.get('name', 'Learner')
        role_name = user_data.get('active_path', 'General Tech')
        missing_skills = user_data.get('missing_skills', [])

        if not missing_skills:
            return []

        # --- STEP 1: AMBIL DATA DARI SKILL MANAGER ---
        # Disini kita menggunakan object 'skill_manager' yang sudah di-import
        role_json_data = skill_manager.get_role_data(role_name)
        
        verified_context_list = []

        for gap in missing_skills:
            s_name = gap['skill_name']
            t_level = gap['target_level'].lower() 
            
            # Cari skill di JSON
            found_skill = None
            if role_json_data:
                for s in role_json_data.get('sub_skills', []):
                    # Simple matching nama skill
                    if s['name'].lower() in s_name.lower() or s_name.lower() in s['name'].lower():
                        found_skill = s
                        break
            
            # Ambil detail course jika ketemu
            if found_skill:
                level_data = found_skill.get('levels', {}).get(t_level, {})
                rec_data = level_data.get('recommendation', {})
                
                real_course = rec_data.get('course_name', 'NOT_FOUND')
                real_chapters = rec_data.get('specific_chapters', [])
                
                verified_context_list.append({
                    "requested_skill": s_name,
                    "target_level": t_level,
                    "OFFICIAL_COURSE": real_course,
                    "OFFICIAL_CHAPTERS": real_chapters
                })
            else:
                verified_context_list.append({
                    "requested_skill": s_name,
                    "target_level": t_level,
                    "OFFICIAL_COURSE": "NOT_FOUND",
                    "OFFICIAL_CHAPTERS": []
                })

        context_str = json.dumps(verified_context_list, indent=2)

        # --- STEP 2: PROMPT ---
        system_prompt = f"""
        ROLE: Expert Curriculum Developer.
        TUGAS: Susun rekomendasi kursus berdasarkan DATA RESMI DATABASE.
        
        DATA USER:
        - Nama: {name}
        - Target Role: {role_name}
        
        DATA RESMI (CONTEXT):
        {context_str}

        INSTRUKSI UTAMA:
        1. Iterasi setiap skill dalam DATA RESMI.
        2. Jika 'OFFICIAL_COURSE' tersedia (Bukan NOT_FOUND):
           - WAJIB GUNAKAN Judul & Chapters tersebut. JANGAN MENGARANG.
        3. Jika 'OFFICIAL_COURSE' adalah "NOT_FOUND":
           - Generate judul & bab yang relevan.
        
        LOGIKA BADGE (PRIORITY):
        - "🔴 High Priority": Jika level target = materi kursus (Setara).
        - "🟡 Medium Priority": Jika level target < materi kursus (Upskill/Lebih sulit).
        - "🟢 Low Priority": Jika level target > materi kursus (Review/Lebih mudah).

        OUTPUT JSON:
        {{
            "items": [
                {{
                    "skill": "Nama Skill",
                    "current_level": "Level Target",
                    "course_to_take": "Judul Kursus",
                    "chapters": ["Bab 1", "Bab 2"],
                    "match_score": 95.5,
                    "badge": "🔴 High Priority"
                }}
            ]
        }}
        """

        try:
            response_content = await self._execute_with_retry(
                messages=[{"role": "system", "content": system_prompt}],
                model="llama-3.3-70b-versatile",
                temperature=0.3, # Rendah agar patuh data
                response_format={"type": "json_object"}
            )
            
            data = json.loads(response_content)
            
            if "items" in data and isinstance(data["items"], list):
                return data["items"]
            
            for val in data.values():
                if isinstance(val, list):
                    return val
            
            return []

        except Exception as e:
            print(f"Error Gen Curriculum: {e}")
            return []

llm_engine = LLMEngine()