#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import requests
import mysql.connector
from pathlib import Path
import sys

# UTF-8 handling
try:
    sys.stdout.reconfigure(encoding='utf-8')
except:
    pass

# === KONFIGURACE ===

# --- Medevio API ---
TOKEN_PATH = Path("token.txt")
GRAPHQL_URL = "https://api.medevio.cz/graphql"

# --- MySQL DB ---
DB_CONFIG = {
    "host": "192.168.1.76",
    "port": 3307,
    "user": "root",
    "password": "Vlado9674+",
    "database": "medevio",
}


# === Helpers ===

def read_token(p: Path) -> str:
    """Načte Bearer token z textového souboru."""
    t = p.read_text().strip()
    if t.startswith("Bearer "):
        return t.split(" ", 1)[1]
    return t


# === DB Funkce ===

def get_latest_open_request_id_from_db():
    """
    Získá ID, Titul, Jméno a Příjmení nejnovějšího otevřeného požadavku z MySQL.
    """
    print("🔍 Připojuji se k MySQL a hledám ID nejnovějšího otevřeného požadavku...")
    try:
        conn = mysql.connector.connect(**DB_CONFIG)
        cursor = conn.cursor()

        # SQL dotaz: Nyní vybíráme navíc jméno a příjmení pacienta
        query = """
        SELECT id, displayTitle, pacient_jmeno, pacient_prijmeni
        FROM pozadavky
        WHERE doneAt IS NULL
        ORDER BY updatedAt DESC
        LIMIT 1;
        """

        cursor.execute(query)
        result = cursor.fetchone()

        cursor.close()
        conn.close()

        if result:
            request_id, display_title, jmeno, prijmeni = result
            print(f"✅ Nalezen požadavek ID: {request_id} (Titul: {display_title})")
            print(f"    Pacient: **{prijmeni} {jmeno}**")  # Vypíšeme pro snadnou kontrolu
            return {
                "id": request_id,
                "displayTitle": display_title,
                "jmeno": jmeno,
                "prijmeni": prijmeni
            }

        print("❌ Nebyl nalezen žádný otevřený požadavek v DB.")
        return None

    except mysql.connector.Error as err:
        print(f"❌ Chyba při připojení/dotazu MySQL: {err}")
        return None


# === GraphQL Operace ===
# Tyto GraphQL dotazy jsou beze změny

QUERY_GET_NOTE = r"""
query ClinicRequestNotes_Get($patientRequestId: String!) {
  notes: getClinicPatientRequestNotes(requestId: $patientRequestId) {
    id
    content
  }
}
"""

MUTATION_UPDATE_NOTE = r"""
mutation ClinicRequestNotes_Update($noteInput: UpdateClinicPatientRequestNoteInput!) {
  updateClinicPatientRequestNote(noteInput: $noteInput) {
    id
  }
}
"""


def gql(query, variables, token):
    """Obecná funkce pro volání GraphQL endpointu."""
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
        "Accept": "application/json",
    }
    payload = {"query": query, "variables": variables}

    r = requests.post(GRAPHQL_URL, json=payload, headers=headers)
    r.raise_for_status()
    return r.json()


def get_internal_note(request_id, token):
    """Získá jedinou interní poznámku (obsah a ID) pro daný požadavek."""
    print(f"🔍 Načítám poznámku z Medevia k požadavku {request_id}...")
    data = gql(QUERY_GET_NOTE, {"patientRequestId": request_id}, token)
    notes = data.get("data", {}).get("notes", [])

    if notes:
        print("✅ Interní poznámka nalezena.")
        return notes[0]

    print(f"⚠️ Interní poznámka pro požadavek {request_id} neexistuje.")
    return None


def update_internal_note(note_id, new_content, token):
    """Aktualizuje obsah poznámky v Medeviu."""
    variables = {"noteInput": {"id": note_id, "content": new_content}}
    print(f"📝 Odesílám aktualizaci poznámky {note_id}...")
    return gql(MUTATION_UPDATE_NOTE, variables, token)


# === MAIN ===

def main():
    token = read_token(TOKEN_PATH)

    # 1. Zjistit ID a jméno pacienta z TVÉ DB
    latest_request = get_latest_open_request_id_from_db()
    if not latest_request:
        return

    request_id = latest_request["id"]

    # 2. Získat existující interní poznámku z Medevia
    note = get_internal_note(request_id, token)
    if not note:
        return

    note_id = note["id"]
    old_content = note["content"] or ""

    # 3. Vytvořit nový obsah (ID požadavku jako první řádek)
    # Text, který vložíme na začátek
    prepend_text = f"ID DB Synchronizace: {request_id}\n"
    new_content = prepend_text + old_content

    print("--- Nový obsah který odešlu (začátek) ---")
    print(f"-> {prepend_text.strip()}")
    print("------------------------------------------")

    # 4. Aktualizovat poznámku v Medeviu
    try:
        update_internal_note(note_id, new_content, token)
        print(f"\n✅ Úspěch! Poznámka {note_id} k požadavku {request_id} byla aktualizována v Medeviu.")
        print(f"   **Zkontroluj požadavek pacienta: {latest_request['prijmeni']} {latest_request['jmeno']}**")
    except requests.exceptions.HTTPError as e:
        print(f"\n❌ Chyba při aktualizaci Medevio API: {e}")
    except Exception as e:
        print(f"\n❌ Neočekávaná chyba: {e}")


if __name__ == "__main__":
    main()