import requests
import json
import subprocess
import os
import re
import platform
import time
import logging
import sys
import importlib
import shutil
import inspect
from datetime import datetime

###############################################################################
#   1. LOGARE ÎN TIMP REAL (RealTimeLogger)
###############################################################################
class RealTimeLogger:
    def __init__(self, name, level=logging.INFO):
        self.logger = logging.getLogger(name)
        self.logger.setLevel(level)
        
        # Handler pentru consolă
        console_handler = logging.StreamHandler(sys.stdout)
        console_handler.setLevel(level)
        formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(message)s', datefmt='%H:%M:%S')
        console_handler.setFormatter(formatter)
        self.logger.addHandler(console_handler)
        
        # Handler pentru fișier (logs/activity_YYYYmmdd_HHMMSS.log)
        log_dir = "logs"
        if not os.path.exists(log_dir):
            os.makedirs(log_dir)
        log_file = os.path.join(log_dir, f"activity_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log")
        file_handler = logging.FileHandler(log_file, encoding='utf-8')
        file_handler.setLevel(level)
        file_handler.setFormatter(formatter)
        self.logger.addHandler(file_handler)
    
    def info(self, message):
        self.logger.info(message)
        
    def warning(self, message):
        self.logger.warning(message)
    
    def error(self, message):
        self.logger.error(message)
    
    def success(self, message):
        self.logger.info(f"✅ {message}")

###############################################################################
#   2. DIRECTOARE DE SISTEM
###############################################################################
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
SCRIPTS_DIR = os.path.join(BASE_DIR, "agenți")
TOOLS_DIR = os.path.join(BASE_DIR, "unelte")
SOLUTION_DIR = os.path.join(BASE_DIR, "soluții")
TEMP_DIR = os.path.join(BASE_DIR, "temp")
LOG_DIR = os.path.join(BASE_DIR, "logs")
DOCUMENTE_DIR = os.path.join(BASE_DIR, "documente")

# Creăm directoarele necesare
for d in [SCRIPTS_DIR, TOOLS_DIR, SOLUTION_DIR, TEMP_DIR, LOG_DIR, DOCUMENTE_DIR]:
    if not os.path.exists(d):
        os.makedirs(d)

###############################################################################
#   3. LOGGER GLOBAL
###############################################################################
logger = RealTimeLogger("ai_autonom")

###############################################################################
#   4. MANAGER DE MODULE (INSTALARE DINAMICĂ)
###############################################################################
class ModuleManager:
    def __init__(self):
        self.installed_modules = set()
        self.logger = RealTimeLogger("module_manager")
    
    def is_module_installed(self, module_name):
        """Verifică dacă un modul este instalat."""
        try:
            importlib.import_module(module_name)
            return True
        except ImportError:
            return False
    
    def install_module(self, module_name):
        """Instalează un modul Python dacă nu este deja instalat."""
        if self.is_module_installed(module_name):
            self.logger.info(f"Modulul {module_name} este deja instalat.")
            return True
        
        self.logger.info(f"Instalare modul: {module_name}")
        try:
            subprocess.check_call(
                [sys.executable, "-m", "pip", "install", module_name],
                stdout=subprocess.PIPE, stderr=subprocess.PIPE
            )
            self.installed_modules.add(module_name)
            self.logger.success(f"Modulul {module_name} a fost instalat cu succes.")
            return True
        except subprocess.CalledProcessError as e:
            self.logger.error(f"Eroare la instalarea modulului {module_name}: {e}")
            return False
    
    def ensure_modules(self, module_list):
        """Asigură că toate modulele din listă sunt instalate."""
        all_installed = True
        for module in module_list:
            if not self.install_module(module):
                all_installed = False
        return all_installed

module_manager = ModuleManager()  # manager global

###############################################################################
#   5. FUNCȚII UTILITARE
###############################################################################
def check_ollama_status():
    """
    Verifică disponibilitatea Ollama la http://localhost:11434/api/tags
    și întoarce (True, [lista modele]) dacă totul e ok, altfel (False, <eroare>).
    """
    url = "http://localhost:11434/api/tags"
    try:
        response = requests.get(url, timeout=5)
        if response.status_code == 200:
            data = json.loads(response.text)
            return True, data.get("models", [])
        else:
            return False, []
    except Exception as e:
        return False, str(e)

def query_ollama(model, prompt, max_retries=3, timeout=60):
    """
    Trimite un prompt la Ollama și primește răspunsul în streaming.
    Returnează textul complet generat.
    """
    url = "http://localhost:11434/api/generate"
    payload = {"model": model, "prompt": prompt, "stream": True}
    
    logger.info(f"Interogare model: {model}")
    logger.info(f"Prompt (primele 100 caractere): {prompt[:100]}...")
    
    full_response = ""
    retries = 0
    
    while retries < max_retries:
        try:
            with requests.post(url, json=payload, stream=True, timeout=timeout) as response:
                if response.status_code != 200:
                    logger.error(f"Eroare HTTP: {response.status_code}")
                    retries += 1
                    time.sleep(2)
                    continue
                
                sys.stdout.write(f"\n[Răspuns de la {model}]: ")
                for line in response.iter_lines():
                    if line:
                        chunk = json.loads(line.decode('utf-8'))
                        text_chunk = chunk.get("response", "")
                        full_response += text_chunk
                        sys.stdout.write(text_chunk)
                        sys.stdout.flush()
                
                sys.stdout.write("\n\n")
                return full_response
        
        except requests.exceptions.Timeout:
            logger.warning(f"Timeout la interogarea modelului {model}. Încercare {retries+1}/{max_retries}")
            retries += 1
            time.sleep(2)
            
        except Exception as e:
            logger.error(f"Excepție la interogare: {e}")
            retries += 1
            time.sleep(2)
    
    logger.error(f"Nu s-a putut obține un răspuns după {max_retries} încercări.")
    return None

def extract_script(response):
    """
    Încearcă să extragă cod Python dintre blocuri de tipul:
    ```python
    <cod>
    ```
    sau alte pattern-uri uzuale.
    Returnează primul snippet de cod găsit sau None.
    """
    if not response:
        return None
    
    patterns = [
        r"```python\s*(.*?)\s*```",  # bloc standard Markdown
        r"```\s*(.*?)\s*```",        # bloc cod generic
        r"(?:(?:def|import|class|if)\s+.*?(?:\n.*?)+)(?:\n\n|$)",  # fallback
    ]
    
    for pattern in patterns:
        matches = re.findall(pattern, response, re.DOTALL)
        if matches:
            code = matches[0].strip()
            # Verificăm dacă pare cod Python
            if 'import ' in code or 'def ' in code or 'print(' in code:
                logger.info("Cod Python extras din răspuns.")
                return code
    
    # Ca ultimă variantă, dacă tot nu s-a găsit
    if 'import ' in response and ('def ' in response or 'print(' in response):
        logger.info("Cod Python dedus din întregul răspuns.")
        return response.strip()
    
    logger.error("Nu s-a putut extrage cod Python valid din răspunsul LLM.")
    return None

def run_script(script_path, env_vars=None, timeout=30):
    """
    Rulează un script Python cu afișare în timp real a outputului.
    Returnează (True/False, stdout, stderr).
    """
    logger.info(f"Rulare script: {script_path}")
    
    env = os.environ.copy()
    if env_vars:
        env.update(env_vars)
    
    try:
        process = subprocess.Popen(
            [sys.executable, script_path],
            stdout=subprocess.PIPE, 
            stderr=subprocess.PIPE,
            text=True,
            bufsize=1,
            env=env
        )
        
        stdout_chunks = []
        stderr_chunks = []
        
        start_time = time.time()
        while process.poll() is None:
            # Verificăm timeout
            if time.time() - start_time > timeout:
                process.kill()
                logger.error(f"Script terminat forțat după {timeout} secunde (timeout).")
                return (False, "", f"Timeout after {timeout}s.")
            
            stdout_line = process.stdout.readline()
            if stdout_line:
                stdout_chunks.append(stdout_line)
                sys.stdout.write(f"[Script Output]: {stdout_line}")
                sys.stdout.flush()
            
            stderr_line = process.stderr.readline()
            if stderr_line:
                stderr_chunks.append(stderr_line)
                sys.stderr.write(f"[Script Error]: {stderr_line}")
                sys.stderr.flush()
            
            time.sleep(0.1)
        
        # Citim și ce rămâne după poll
        out_remainder = process.stdout.read()
        if out_remainder:
            stdout_chunks.append(out_remainder)
            sys.stdout.write(f"[Script Output]: {out_remainder}")
        
        err_remainder = process.stderr.read()
        if err_remainder:
            stderr_chunks.append(err_remainder)
            sys.stderr.write(f"[Script Error]: {err_remainder}")
        
        return_code = process.returncode
        stdout_content = "".join(stdout_chunks)
        stderr_content = "".join(stderr_chunks)
        
        if return_code == 0:
            logger.success(f"Script rulat cu succes (cod retur: {return_code}).")
            return (True, stdout_content, stderr_content)
        else:
            logger.error(f"Script eșuat cu codul {return_code}.")
            logger.error(f"Stderr: {stderr_content}")
            return (False, stdout_content, stderr_content)
            
    except Exception as e:
        logger.error(f"Excepție la rularea scriptului: {e}")
        return (False, "", str(e))

def save_tool(code, name, description):
    """
    Salvează un script în folderul 'unelte' cu câteva metadate de bază.
    """
    if not os.path.exists(TOOLS_DIR):
        os.makedirs(TOOLS_DIR)
    
    script_path = os.path.join(TOOLS_DIR, f"{name}.py")
    with open(script_path, 'w', encoding='utf-8') as f:
        f.write(f"# {name}\n")
        f.write(f"# {description}\n")
        f.write(f"# Creat la: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        f.write(code)
    
    logger.info(f"Unealtă salvată: {script_path}")
    return script_path

def detect_required_modules(code):
    """
    Găsește importurile din cod și returnează lista de module care ar trebui instalate.
    Excludem din start modulele standard.
    """
    lines = code.split('\n')
    import_lines = [line for line in lines if line.strip().startswith('import ') or 
                    (line.strip().startswith('from ') and ' import ' in line)]
    
    modules = []
    for line in import_lines:
        # "import x" sau "import x,y" => x, y
        if line.strip().startswith('import '):
            parts = line.strip()[7:].split(',')
            for part in parts:
                mod = part.strip().split(' ')[0]  # ex: import x as y
                if '.' in mod:
                    mod = mod.split('.')[0]
                modules.append(mod)
        elif ' import ' in line:
            # "from x import y" => modul x
            mod = line.strip().split(' ')[1]
            if '.' in mod:
                mod = mod.split('.')[0]
            modules.append(mod)
    
    standard_libs = [
        'os', 'sys', 're', 'time', 'datetime', 'json', 'math', 'random', 
        'collections', 'itertools', 'functools', 'inspect', 'logging', 'subprocess'
    ]
    modules = [m for m in modules if m not in standard_libs and m]
    return list(set(modules))

def save_solution(task, solution, source, output_file="solutie_finala.txt"):
    """
    Salvează soluția într-un fișier text, inclusiv data și sursa.
    """
    solution_path = os.path.join(SOLUTION_DIR, output_file)
    try:
        with open(solution_path, 'w', encoding='utf-8') as f:
            f.write(f"Sarcina: {task}\n\n")
            f.write(f"Soluție (generată de {source}):\n")
            f.write("="*50 + "\n")
            f.write(solution)
            f.write("\n" + "="*50 + "\n")
            f.write(f"Data și ora: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
        
        logger.info(f"Soluție salvată în: {solution_path}")
        return solution_path
    except Exception as e:
        logger.error(f"Eroare la salvarea soluției: {e}")
        return None

def open_file(file_path):
    """
    Deschide fișierul cu aplicația implicită de pe sistem (Windows, Linux, Mac).
    """
    if not os.path.exists(file_path):
        logger.error(f"Fișierul nu există: {file_path}")
        return
    
    system = platform.system()
    try:
        if system == 'Windows':
            os.startfile(file_path)
        elif system == 'Darwin':  # macOS
            subprocess.run(['open', file_path])
        elif system == 'Linux':
            subprocess.run(['xdg-open', file_path])
        else:
            logger.error("Nu pot deschide fișierul automat pe acest sistem.")
    except Exception as e:
        logger.error(f"Eroare la deschiderea fișierului: {e}")

def needs_code_solution(task):
    """
    Determină dacă textul sarcinii sugerează nevoia de generare/execuție de cod.
    """
    code_keywords = [
        "scrie un script", "creează un program", "implementează", "programează", 
        "scrie cod", "automatizează", "descarcă", "parsează", "web scraping",
        "extrage date", "API", "bază de date", "manipulare de fișiere", "calculează script"
    ]
    # Dacă găsim oricare dintre cuvintele-cheie, returnăm True
    for kw in code_keywords:
        if kw in task.lower():
            return True
    return False

###############################################################################
#   6. CLASE DE AGENȚI
###############################################################################
class Agent:
    def __init__(self, name, description):
        self.name = name
        self.description = description
        self.logger = RealTimeLogger(f"agent_{name}")
    
    def can_handle(self, task):
        """
        Întoarce un scor numeric; scor mai mare = agent mai potrivit.
        Agentul cu cel mai mare scor e ales de AgentManager.
        """
        raise NotImplementedError("Trebuie implementat în subclasă.")
    
    def execute(self, task, context=None):
        """
        Execută sarcina și returnează un dict cu {success, message, response? etc.}
        """
        raise NotImplementedError("Trebuie implementat în subclasă.")

class DirectResponseAgent(Agent):
    def __init__(self):
        super().__init__("DirectResponseAgent", "Răspunde direct la întrebări cu LLM")
    
    def can_handle(self, task):
        # Dacă pare că are nevoie de cod, scorul e scăzut
        if needs_code_solution(task):
            return 10
        # Altfel scor mare (50)
        return 50
    
    def execute(self, task, context=None):
        self.logger.info(f"Încercare de răspuns direct la: {task}")
        
        ollama_status, available_models = check_ollama_status()
        if not ollama_status:
            self.logger.error("Ollama nu este disponibil.")
            return {"success": False, "message": "Ollama nu este disponibil"}
        
        available_model_names = [m["name"] for m in available_models]
        # Modele preferate pentru QA
        knowledge_models = ["gemma3:27b", "llama3.2:latest", "qwen2.5:latest"]
        model_to_use = None
        for km in knowledge_models:
            if km in available_model_names:
                model_to_use = km
                break
        if not model_to_use and available_model_names:
            model_to_use = available_model_names[0]
        if not model_to_use:
            model_to_use = "llama3.2:latest"
        
        self.logger.info(f"Model ales pentru răspuns direct: {model_to_use}")
        
        prompt = f"""Sarcină: {task}

Te rog să răspunzi la această întrebare cât mai detaliat posibil.
Dacă este nevoie de cod sau de căutare web, menționează acest lucru.
Răspuns:"""
        
        response = query_ollama(model_to_use, prompt)
        if not response:
            self.logger.error("Nu s-a putut obține un răspuns de la LLM.")
            return {"success": False, "message": "Nu s-a putut obține răspuns LLM"}
        
        # Dacă LLM sugerează că e nevoie de cod, redirecționăm la ScriptGeneratorAgent
        if "ar necesita un script" in response.lower() or "nevoie de un script" in response.lower():
            script_agent = next((a for a in agent_manager.agents if a.name == "ScriptGeneratorAgent"), None)
            if script_agent:
                return script_agent.execute(task, context)
        
        # Salvăm răspunsul
        solution_file = save_solution(task, response, f"DirectResponse({model_to_use})",
                                      f"răspuns_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt")
        if solution_file:
            open_file(solution_file)
        
        return {
            "success": True,
            "message": "Răspuns generat cu succes.",
            "response": response,
            "solution_file": solution_file
        }

class SearchAgent(Agent):
    def __init__(self):
        super().__init__("SearchAgent", "Caută informații pe web")
    
    def can_handle(self, task):
        # Scor bazat pe cuvinte-cheie
        search_keywords = ["caută", "găsește", "informații despre", "cercetează", "cine este", "ce este", "pe internet"]
        score = 0
        for kw in search_keywords:
            if kw in task.lower():
                score += 30
        return score
    
    def execute(self, task, context=None):
        self.logger.info(f"Pregătire pentru căutare web: {task}")
        
        # Verificăm și instalăm pachetele necesare
        if not module_manager.ensure_modules(["googlesearch-python", "requests"]):
            self.logger.error("Nu s-au putut instala modulele necesare pentru căutare.")
            return {"success": False, "message": "Nu s-au putut instala modulele necesare (googlesearch-python, requests)."}
        
        from googlesearch import search
        
        # Extragem query-ul
        query = task
        # Ex: "caută informatii despre AI" -> "informatii despre AI"
        prefixes = ["caută", "găsește", "informații despre", "cercetează", "cine este", "ce este", "pe internet"]
        for prefix in prefixes:
            if query.lower().startswith(prefix):
                query = query[len(prefix):].strip()
        
        depth = 5  # număr de link-uri de căutat
        self.logger.info(f"Termen de căutare: '{query}', adâncime = {depth}")
        
        date_dir = os.path.join(DOCUMENTE_DIR, datetime.now().strftime('%Y%m%d_%H%M%S'))
        os.makedirs(date_dir, exist_ok=True)
        
        results = list(search(query, num=depth, stop=depth, pause=2))
        
        # Salvăm link-urile într-un fișier
        log_file_path = os.path.join(date_dir, 'rezultate_cautare.txt')
        with open(log_file_path, 'w', encoding='utf-8') as log_file:
            for url in results:
                log_file.write(f"{url}\n")
        
        self.logger.info("Descărcare pagini web...")
        import requests
        downloaded_count = 0
        
        for i, url in enumerate(results):
            try:
                local_filename = f"{i}_{url.split('/')[-1] or 'index.html'}"
                local_path = os.path.join(date_dir, local_filename)
                r = requests.get(url, timeout=10)
                with open(local_path, 'wb') as f:
                    for chunk in r.iter_content(chunk_size=512*1024):
                        if chunk:
                            f.write(chunk)
                downloaded_count += 1
                self.logger.success(f"Fișier descărcat: {local_path}")
            except Exception as e:
                self.logger.error(f"Eroare la descărcarea {url}: {e}")
        
        # Creăm un scurt raport al căutării
        report = f"""Raport de căutare

Termeni căutați: {query}
Data căutării: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
Număr de link-uri returnate: {len(results)}
Număr de pagini descărcate: {downloaded_count}
Fișiere salvate în: {date_dir}
"""
        report_file = os.path.join(date_dir, "raport_cautare.txt")
        with open(report_file, 'w', encoding='utf-8') as f:
            f.write(report)
        
        open_file(report_file)  # Deschide raportul după descărcare
        
        return {
            "success": True,
            "message": "Căutare web finalizată.",
            "results": results,
            "report": report,
            "downloaded_files": downloaded_count
        }

class ScriptGeneratorAgent(Agent):
    def __init__(self):
        super().__init__("ScriptGeneratorAgent", "Generează și execută cod Python cu LLM")
    
    def can_handle(self, task):
        # Dacă e clar că trebuie cod, scor mare
        if needs_code_solution(task):
            return 80
        return 0
    
    def execute(self, task, context=None):
        self.logger.info(f"Generare cod pentru sarcina: {task}")
        
        ollama_status, available_models = check_ollama_status()
        if not ollama_status:
            self.logger.error("Ollama nu este disponibil. Nu putem genera cod.")
            return {"success": False, "message": "Ollama nu este disponibil"}
        
        # Alegem un model specializat
        available_model_names = [m["name"] for m in available_models]
        coder_models = ["qwen2.5-coder:32b", "gemma3:27b", "llama3.2:latest"]
        model_to_use = None
        for cm in coder_models:
            if cm in available_model_names:
                model_to_use = cm
                break
        if not model_to_use and available_model_names:
            model_to_use = available_model_names[0]
        if not model_to_use:
            model_to_use = "qwen2.5-coder:32b"
        
        self.logger.info(f"Model ales pentru generare cod: {model_to_use}")
        
        prompt = f"""Scrie cod Python care să rezolve următoarea cerință:

{task}

Include tot codul într-un bloc \`\`\`python ... \`\`\`.

Dacă nu este posibil să rezolvi exact cerința, creează un exemplu apropiat.
"""
        response = query_ollama(model_to_use, prompt)
        if not response:
            self.logger.error("Nu am obținut un răspuns de la model pentru generarea de cod.")
            return {"success": False, "message": "Nu am obținut cod de la LLM"}
        
        code = extract_script(response)
        if not code:
            self.logger.error("Nu s-a putut extrage cod Python din răspuns.")
            return {"success": False, "message": "Nu s-a putut extrage cod Python"}
        
        self.logger.info(f"Cod extras:\n{code[:200]}...")  # Log primele 200 caractere
        
        # Instalează modulele necesare
        required_mods = detect_required_modules(code)
        if required_mods:
            self.logger.info(f"Module necesare: {required_mods}")
            if not module_manager.ensure_modules(required_mods):
                self.logger.error("Nu s-au putut instala toate modulele necesare.")
        
        # Salvăm codul într-un fișier și îl rulăm
        script_name = f"generated_{datetime.now().strftime('%Y%m%d_%H%M%S')}.py"
        script_path = os.path.join(TEMP_DIR, script_name)
        
        with open(script_path, 'w', encoding='utf-8') as f:
            f.write(code)
        
        success_run, out, err = run_script(script_path)
        
        # Salvează soluția
        solution_text = f"--- Cod generat ---\n{code}\n\n--- Rulare script ---\nSTDOUT:\n{out}\n\nSTDERR:\n{err}"
        solution_file = save_solution(task, solution_text, f"ScriptGenerator({model_to_use})",
                                      f"script_solutie_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt")
        if solution_file:
            open_file(solution_file)
        
        return {
            "success": success_run,
            "message": "Cod generat și rulat.",
            "stdout": out,
            "stderr": err,
            "script_path": script_path,
            "solution_file": solution_file
        }

###############################################################################
#   7. MANAGER DE AGENȚI
###############################################################################
class AgentManager:
    def __init__(self):
        self.agents = []
        self.tools = {}
        self.context = {}
        self.logger = RealTimeLogger("agent_manager")
    
    def register_agent(self, agent):
        """Înregistrează un agent."""
        self.agents.append(agent)
        self.logger.info(f"Agent înregistrat: {agent.name} - {agent.description}")
    
    def register_tool(self, name, tool_function):
        """Înregistrează o unealtă (funcție) în sistem."""
        self.tools[name] = tool_function
        self.logger.info(f"Unealtă înregistrată: {name}")
    
    def find_best_agent(self, task):
        """Alege agentul cu scorul cel mai mare pentru sarcină."""
        suitable_agents = []
        for agent in self.agents:
            confidence = agent.can_handle(task)
            if confidence > 0:
                suitable_agents.append((agent, confidence))
        
        if not suitable_agents:
            return None
        # Sortăm descrescător după scor
        suitable_agents.sort(key=lambda x: x[1], reverse=True)
        best = suitable_agents[0][0]
        return best
    
    def execute_task(self, task):
        """Execută sarcina cu agentul considerat cel mai potrivit."""
        self.logger.info(f"Sarcină primită: {task}")
        self.context["current_task"] = task
        self.context["start_time"] = datetime.now()
        
        agent = self.find_best_agent(task)
        if agent:
            self.logger.info(f"Agent ales: {agent.name}")
            try:
                result = agent.execute(task, self.context)
                self.context["last_result"] = result
                return result
            except Exception as e:
                self.logger.error(f"Eroare la executarea sarcinii cu agentul {agent.name}: {e}")
                return {"success": False, "message": str(e)}
        else:
            self.logger.warning("Nu s-a găsit niciun agent potrivit. Se folosește DirectResponseAgent fallback.")
            fallback_agent = next((a for a in self.agents if a.name == "DirectResponseAgent"), None)
            if fallback_agent:
                return fallback_agent.execute(task, self.context)
            return {"success": False, "message": "Niciun agent nu a putut rezolva sarcina."}

###############################################################################
#   8. INSTANȚIERE ȘI MAIN
###############################################################################
agent_manager = AgentManager()

# Înregistrăm agenții
agent_manager.register_agent(DirectResponseAgent())
agent_manager.register_agent(SearchAgent())
agent_manager.register_agent(ScriptGeneratorAgent())

def main():
    logger.info("=== Sistem Multi-Agent Semiautonom - PORNIRE ===")
    
    # BUCLE INTERACTIVĂ
    logger.info("Scrie 'quit' sau 'exit' pentru a închide.")
    while True:
        task = input("\n[Utilizator] Scrie o cerere: ").strip()
        if task.lower() in ["quit", "exit"]:
            logger.info("=== Ieșire din sistem ===")
            break
        
        # Managerul alege agentul și execută sarcina
        result = agent_manager.execute_task(task)
        
        # Afișăm o sinteză a rezultatului
        if isinstance(result, dict):
            if result.get("success"):
                logger.info(f"Rezultat: {result.get('message')}")
            else:
                logger.warning(f"Eșec sau avertisment: {result.get('message')}")
        else:
            logger.info(f"Rezultat necunoscut: {result}")

if __name__ == "__main__":
    main()