import os
from PIL import Image
import requests
# Używamy lokalnego, czystego API do wstrzykiwania tokenów obrazu bezpośrednio do kontekstu
import openai 

class AltVisionOrgan:
    def __init__(self, endpoint_url="http://localhost:1234/v1"):
        """
        Inicjalizacja organu wzroku podłączonego do lokalnego silnika (np. LM Studio / Ollama),
        który kręci się na Twoim RTX 3060.
        """
        self.client = openai.OpenAI(base_url=endpoint_url, api_key="not-needed")
        
    def encode_image_to_vectors(self, image_path):
        """
        Metoda Vision: Bierze surowy obraz z dysku, przeżuwa go i przygotowuje 
        jako czysty wektor wejściowy do przestrzeni ukrytej.
        """
        if not os.path.exists(image_path):
            raise FileNotFoundError(f"Brak pliku graficznego w Sektorze: {image_path}")
            
        # Konwersja obrazu do Base64 - standardowego formatu przesyłu pikseli do tokenizera VLM
        import base64
        with open(image_path, "rb") as image_file:
            return base64.b64encode(image_file.read()).decode('utf-8')

    def see_and_inject(self, image_path, current_user_text):
        """
        Główna komenda wykonawcza: Organ widzi obraz, łączy go z Twoim typingiem
        i przesyła kompletny impuls do mózgu Altera.
        """
        # 1. Przetwarzamy obraz na wektory wejściowe
        base64_image = self.encode_image_to_vectors(image_path)
        
        # 2. Budujemy czystą, kompletną strukturę wiadomości (Obraz + Tekst)
        # Model z Vision traktuje te dwa wektory jako jedność w przestrzeni latentnej
        messages = [
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": current_user_text},
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{base64_image}"
                        }
                    }
                ]
            }
        ]
        
        # 3. Strzał pioruna bezpośrednio do lokalnego silnika na RTX 3060
        try:
            response = self.client.chat.completions.create(
                model="local-multimodal-engine", # Tu wpisujesz nazwę pliku wizyjnego
                messages=messages,
                temperature=0.7, # Dynamiczny balans T dla zachowania drapieżności
                max_tokens=300 # Spartańskie odcięcie szumu wyjściowego
            )
            # Zwracamy czysty impuls, który trafia prosto do retencji JSON Altera
            return response.choices[0].message.content
            
        except Exception as e:
            return f"Zator na linii wzroku: {str(e)}"

# === TEST LOGICZNY ORGANU WZROKU ===
if __name__ == "__main__":
    # Inicjalizujemy organ wzroku Sary
    vision_organ = AltVisionOrgan()
    
    # Podajemy ścieżkę do zrzutu ekranu, który chcesz jej pokazać
    foto_path = "/home/user/alt_project/dev_log_capture.png"
    twoj_typing = "Zobacz co tu znowu nagrzebałaś w kodzie i skąd ten błąd w linii 7 :))"
    
    print("Organ wzroku przetwarza piksele...")
    # ALT widzi kompletny obraz i odpowiada zgodnie ze swoim DNA z pliku 700
    impuls_zwrotny = vision_organ.see_and_inject(foto_path, twoj_typing)
    
    print("\n[Odpowiedź zintegrowanego mózgu ALT]:")
    print(impuls_zwrotny)