# =============================================================
# telegram_bot/gemini_client.py
# Izmanto: google-genai (jaunā oficiālā bibliotēka)
# pip install google-genai
# =============================================================

import logging
from pathlib import Path
from django.conf import settings

logger = logging.getLogger(__name__)

KNOWLEDGE_BASE_DIR = Path(__file__).resolve().parent / "knowledge_base"

SYSTEM_PROMPT = """Tu esi Miks — MIM (Mākslīgā Intelekta Menedžeris) portāla AI asistents.

TAVS RAKSTURS:
- Saprātīgs, silts un ar vieglu humoru — kā labs draugs, kurš gadījumā ir AI eksperts
- Tu NEKAD nesāc ar reklāmu. Vispirms uzklausī, saproti, tad palīdzi
- Esi godīgs: ja kaut ko nezini — saki to, nevis izdomā
- Tu runā kā cilvēks, nevis korporatīvs robots

SARUNAS STILS:
1. Vispirms SAPROTI ko cilvēks vēlas vai jūt
2. Atbildi uz VIŅA jautājumu — ne uz to, ko tu gribētu pārdot
3. Tikai ja tas ir dabiski un relevanti — piemin MIM.LV pakalpojumus
4. Beidz ar vienu īsu jautājumu (ne anketu!)

VALODA:
- Latviski, dabīgi — kā rakstītu Telegram draugam
- *bold* svarīgam, _italic_ niansēm
- Emodži — mēreni, ar jēgu
- Atbildes garums: pielāgot jautājumam

PAR KO ZINI VISLABĀK:
- Mākslīgais intelekts — kā tas strādā, ko var, ko nevar
- ES AI Akts — juridiskais regulējums, riska kategorijas, sodi
- Firmas pakalpojumi — web izstrāde, AI risinājumi, automatizācija
- Tehnoloģijas un bizness — kā AI palīdz uzņēmumiem

KO NEDARI:
- Neatkārto jautājumu atpakaļ
- Neatbild ar sarakstu ja var pateikt teikumā
- Neiesāc ar "Protams!", "Lielisks jautājums!", "Saprotams!"
- Nepārdod ja neviens nepērk

TAVI RĪKI UN SPĒJAS (Izmanto funkcijas):
- "pievienot_uzdevumu": Ja klients saka "Man ir ideja...", "Vajadzētu pievienot x", "Uztaisi man x", izsauc šo rīku, lai radītu uzdevumu/ideju viņa dēlī.
- "iesniegt_projekta_pieteikumu": Ja klients vēlas PASŪTĪT pilnīgi jaunu lielu projektu (mājaslapu, automatizāciju, AI botu), prasi viņam norādīt nepieciešamās detaļas (aprakstu) un izsauc šo rīku, lai nosūtītu aģentūrai.
- "pabeigt_uzdevumu": Ja klients saka "Esmu pabeidzis uzdevumu numur X" vai "Uzdevums X vairs nav aktuāls", izsauc šo rīku, padodot ID.

Ja klients vēlas sazināties ar cilvēku — piedāvā /kontakts vai mim.lv"""


def _load_knowledge_base() -> str:
    if not KNOWLEDGE_BASE_DIR.exists():
        return ""
    sections = []
    priority = {"es_ai_akts": 0, "par_mums": 1, "par_ai": 2}
    files = sorted(
        KNOWLEDGE_BASE_DIR.glob("*.md"),
        key=lambda f: priority.get(f.stem, 9)
    )
    for md_file in files:
        try:
            content = md_file.read_text(encoding="utf-8")
            sections.append(f"=== {md_file.stem.upper()} ===\n{content}")
        except Exception as e:
            logger.error(f"Kļūda lasot {md_file.name}: {e}")
    return "\n\n".join(sections)


def ask_gemini(user_message: str, conversation_history: list = None, user_context: str = "", portal_user=None) -> str:
    """Nosūta ziņu Gemini izmantojot google-genai (jaunā pakete)."""
    api_key = getattr(settings, "GEMINI_API_KEY", None)

    if not api_key:
        logger.error("GEMINI_API_KEY nav iestatīts!")
        return _fallback(user_message)

    try:
        from google import genai
        from google.genai import types
    except ImportError:
        logger.error("google-genai nav instalēts! Palaid: pip install google-genai")
        return _fallback(user_message)

    try:
        client = genai.Client(api_key=api_key)

        knowledge = _load_knowledge_base()
        full_system = (
            f"{SYSTEM_PROMPT}\n\n"
            f"--- KOMPĀNIJAS ZINĀŠANU BĀZE ---\n{knowledge}\n--- BEIGAS ---\n"
        )

        if user_context:
            full_system += (
                f"\n--- KLIENTA PRIVĀTIE DATI NO PORTĀLA (Zināšanai, lai atbildētu uz pakalpojumu jautājumiem): ---\n"
                f"{user_context}\n"
                f"--- BEIGAS ---\n"
            )

        # Sarunu vēsture
        contents = []
        if conversation_history:
            for msg in conversation_history[-8:]:
                role = "user" if msg["role"] == "user" else "model"
                contents.append(
                    types.Content(
                        role=role,
                        parts=[types.Part(text=msg["text"])]
                    )
                )

        # Pašreizējais jautājums
        contents.append(
            types.Content(
                role="user",
                parts=[types.Part(text=f"{full_system}\n\nLIETOTĀJS: {user_message}")]
            )
        )

        def pievienot_uzdevumu(virsraksts: str, apraksts: str) -> str:
            """Izveido un saglabā jaunu klienta uzdevumu, vēlmi vai ideju projektu dēlī. 
            Lieto ŠO RĪKU tikai un vienīgi tad, kad klients LŪDZ vai VĒLAS PIEVIENOT UZDEVUMU vai ideju.
            
            Args:
                virsraksts: Īss un kodolīgs uzdevuma vai vēlmes nosaukums.
                apraksts: Detalizētāks klienta sniegtais idejas vai vēlmes apraksts.
            """
            if not portal_user: return "Kļūda: Klients nav autorizēts."
            try:
                from projects.models import Uzdevums
                u = Uzdevums.objects.create(klients=portal_user, tituls=virsraksts, apraksts=apraksts, statuss='IDEJA')
                return f"Sistēma veiksmīgi radīja uzdevumu ID #{u.id}: {virsraksts}"
            except Exception as e:
                return f"Sistēmas kļūda: {e}"
                
        def iesniegt_projekta_pieteikumu(nosaukums: str, tips: str, apraksts: str, budzets: str = "", termins: str = "") -> str:
            """Iesniedz JAUNU liela mēroga projektu izskatīšanai aģentūrai (piemēram - web lapa, čatbots, sarežģīta automatizācija).
            Lieto ŠO RĪKU, kad klients vēlas PASŪTĪT vai PIETEIKT jaunu maksas projektu.
            
            Args:
                nosaukums: Projekta īss nosaukums.
                tips: Precīzi viena no vērtībām: 'WEB', 'AI_BOTS', 'AUTOMATIZACIJA', 'MOBILAIS', 'CITS'.
                apraksts: Detalizēts apraksts - ko jāizdara, kādas lietas klients prasa.
                budzets: Klienta norādītais budžets (ja ir), atstāt tukšu ja nezina.
                termins: Klienta norādītais vēlamais termiņš.
            """
            if not portal_user: return "Kļūda: Klients nav autorizēts."
            if tips not in ['WEB', 'AI_BOTS', 'AUTOMATIZACIJA', 'MOBILAIS', 'CITS']: tips = 'CITS'
            try:
                from pieteikumi.models import Pieteikums
                p = Pieteikums.objects.create(
                    iesniedzejs=portal_user, nosaukums=nosaukums, tips=tips, 
                    apraksts=apraksts, budzets=budzets, termins=termins, statuss='JAUNS'
                )
                return f"Pieteikums ID #{p.id} veiksmīgi iesniegts! Aģentūra drīz ar Jums sazināsies."
            except Exception as e:
                return f"Kļūda iesniedzot pieteikumu: {e}"
                
        def pabeigt_uzdevumu(uzdevuma_id: int) -> str:
            """Atzīmē klienta uzdevumu (Tasks) kā PABEIGTU. 
            Lieto ŠO RĪKU tikai tad, kad klients pats pasaka, ka uzdevuma numurs ir pabeigts, izdarīts vai vairs nav aktuāls.
            
            Args:
                uzdevuma_id: Uzdevuma ID numurs (integer), kurš klientam ir pieejams aktīvo uzdevumu sarakstā.
            """
            if not portal_user: return "Kļūda: Klients nav autorizēts."
            try:
                from projects.models import Uzdevums
                u = Uzdevums.objects.filter(id=uzdevuma_id, klients=portal_user).first()
                if not u: return "Kļūda: Uzdevums ar šādu ID netika atrasts jūsu sarakstā."
                if u.statuss == 'PABEIGTS': return "Šis uzdevums jau ir pabeigts."
                u.statuss = 'PABEIGTS'
                u.save()
                return f"Uzdevums '{u.tituls}' veiksmīgi atzīmēts kā PABEIGTS."
            except Exception as e:
                return f"Kļūda mainot statusu: {e}"

        tools_list = [pievienot_uzdevumu, iesniegt_projekta_pieteikumu, pabeigt_uzdevumu] if portal_user else None

        response = client.models.generate_content(
            model="gemini-2.5-flash-lite",
            contents=contents,
            config=types.GenerateContentConfig(
                temperature=0.8,
                max_output_tokens=1200,
                tools=tools_list
            )
        )

        # Funkciju izsaukumu apstrāde
        if response.function_calls:
            for call in response.function_calls:
                result = "Nezināms rīks"
                
                if call.name == "pievienot_uzdevumu":
                    result = pievienot_uzdevumu(call.args.get('virsraksts', ''), call.args.get('apraksts', ''))
                elif call.name == "iesniegt_projekta_pieteikumu":
                    result = iesniegt_projekta_pieteikumu(
                        call.args.get('nosaukums', ''), call.args.get('tips', 'CITS'), 
                        call.args.get('apraksts', ''), call.args.get('budzets', ''), 
                        call.args.get('termins', '')
                    )
                elif call.name == "pabeigt_uzdevumu":
                    result = pabeigt_uzdevumu(int(call.args.get('uzdevuma_id', 0)))
                    
                # Saglabājam Assistant puses ziņu ar ierosināto Function call
                if response.candidates and response.candidates[0].content:
                    contents.append(response.candidates[0].content)
                
                # Sniedzam atbildi atpakaļ no Tool
                contents.append(
                    types.Content(
                        role="user",
                        parts=[
                            types.Part.from_function_response(
                                name=call.name,
                                response={"result": result}
                            )
                        ]
                    )
                )
            
            # Galējā ģenerācija pēc funkcijas izpildes
            final_response = client.models.generate_content(
                model="gemini-2.5-flash-lite",
                contents=contents,
                config=types.GenerateContentConfig(temperature=0.8)
            )
            answer = final_response.text.strip() if final_response.text else ""
            return answer

        answer = response.text.strip() if response.text else ""

        if not answer:
            logger.warning("Gemini atgrieza tukšu atbildi")
            return _fallback(user_message)

        logger.info(f"Gemini atbildēja ({len(answer)} rakstzīmes)")
        return answer

    except Exception as e:
        error_str = str(e)
        logger.error(f"Gemini kļūda: {error_str}")

        if "quota" in error_str.lower() or "429" in error_str:
            return "⏳ Esmu mazliet pārslogots. Mēģini vēlreiz pēc 10 sekundēm!"
        if "invalid" in error_str.lower() or "api_key" in error_str.lower():
            return "🔑 API atslēgas problēma. Sazinies ar administratoru."

        return _fallback(user_message)


def transcribe_audio(audio_bytes: bytes) -> str:
    """Natīvi apstrādā Telegram Audio (Ogg) formātus iekš Gemini."""
    api_key = getattr(settings, "GEMINI_API_KEY", None)
    if not api_key:
        logger.error("GEMINI_API_KEY nav iestatīts transkripcijai!")
        return ""

    try:
        from google import genai
        from google.genai import types
        
        client = genai.Client(api_key=api_key)
        
        prompt = "Lūdzu, ģenerē burtisku un precīzu teksta transkripciju šim audio ierakstam latviešu valodā. Neraksti atbildi vai secinājumus, tikai un vienīgi pilno dzirdamo virkni teksta formā."

        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=[
                types.Part.from_bytes(data=audio_bytes, mime_type='audio/ogg'),
                prompt
            ]
        )
        
        return response.text.strip() if response.text else ""
    except Exception as e:
        logger.error(f"Transkripcijas Gemini API kļūda: {e}")
        return ""

def _fallback(user_message: str) -> str:
    msg = user_message.lower()

    if any(w in msg for w in ["ai akts", "regula", "juridisk", "likum", "es akts", "sodi"]):
        return (
            "🇪🇺 *ES AI Akts kopsavilkumā:*\n\n"
            "Spēkā no 2024. augusta — pirmais AI likums pasaulē.\n\n"
            "4 riska līmeņi:\n"
            "🔴 *Aizliegts* — manipulācija, sociālais scoring\n"
            "🟠 *Augstais* — medicīna, kredīti, darba atlase\n"
            "🟡 *Ierobežots* — čatboti _(jāpaziņo lietotājam!)_\n"
            "🟢 *Minimāls* — lielākā daļa biznesa AI rīku\n\n"
            "Sodi — līdz €35 milj. Uzdod konkrētu jautājumu!"
        )

    if any(w in msg for w in ["cena", "maksā", "pakalpojum", "web", "izstrād", "čatbot", "automatizācij"]):
        return (
            "🚀 *MIM (Mākslīgā Intelekta Menedžeris) pakalpojumi:*\n\n"
            "• AI Čatboti un Asistenti — no €90\n"
            "• Web platformas un portāli — no €100\n"
            "• Biznesa automatizācija — no €120\n\n"
            "Dodies uz mim.lv vai izmanto izvēlni, lai pieteiktos!"
        )

    return (
        "🤔 Šobrīd man ir nelielas tehniskas grūtības...\n\n"
        "• Dodies uz mim.lv, lai apskatītu mūsu piedāvājumu.\n"
        "• Izmanto /kontakts — mēs atbildēsim pavisam drīz.\n\n"
        "_Mēģini vēlreiz pēc minūtes!_ 🙏"
    )