import requests
import json
import subprocess
import os
import re
import platform
import time
import logging
import sys
import importlib
import shutil
import inspect
import shelve
import hashlib
import ast
import argparse
from datetime import datetime

###############################################################################
#   1. CONFIGURAȚIE INTERNĂ
###############################################################################
CONFIG = {
    'directories': {
        'scripts': 'agenți',
        'tools': 'unelte',
        'solutions': 'soluții',
        'temp': 'temp',
        'logs': 'logs',
        'documents': 'documente'
    },
    'ollama': {
        'url': 'http://localhost:11434',
        'timeout': 60,
        'max_retries': 3,
        'preferred_models': {
            'knowledge': ['gemma3:27b', 'llama3.2:latest', 'qwen2.5:latest'],
            'coder': ['qwen2.5-coder:32b', 'gemma3:27b', 'llama3.2:latest']
        }
    },
    'logging': {
        'level': 'INFO',
        'log_format': '%(asctime)s [%(levelname)s] %(message)s',
        'date_format': '%H:%M:%S'
    }
}

###############################################################################
#   2. LOGARE ÎN TIMP REAL (RealTimeLogger)
###############################################################################
class RealTimeLogger:
    def __init__(self, name, level=None):
        self.logger = logging.getLogger(name)
        log_level = level or CONFIG['logging']['level']
        self.logger.setLevel(getattr(logging, log_level))
        
        # Handler pentru consolă
        console_handler = logging.StreamHandler(sys.stdout)
        console_handler.setLevel(getattr(logging, log_level))
        formatter = logging.Formatter(
            CONFIG['logging']['log_format'],
            datefmt=CONFIG['logging']['date_format']
        )
        console_handler.setFormatter(formatter)
        self.logger.addHandler(console_handler)
        
        # Handler pentru fișier  Handler pentru fișier
        log_dir = LOG_DIR
        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(getattr(logging, log_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}")

###############################################################################
#   3. DIRECTOARE DE SISTEM
###############################################################################
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
SCRIPTS_DIR = os.path.join(BASE_DIR, CONFIG['directories']['scripts'])
TOOLS_DIR = os.path.join(BASE_DIR, CONFIG['directories']['tools'])
SOLUTION_DIR = os.path.join(BASE_DIR, CONFIG['directories']['solutions'])
TEMP_DIR = os.path.join(BASE_DIR, CONFIG['directories']['temp'])
LOG_DIR = os.path.join(BASE_DIR, CONFIG['directories']['logs'])
DOCUMENTE_DIR = os.path.join(BASE_DIR, CONFIG['directories']['documents'])

# 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)

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

###############################################################################
#   5. 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):
        try:
            importlib.import_module(module_name)
            return True
        except ImportError:
            return False
    
    def install_module(self, module_name):
        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):
        all_installed = True
        for module in module_list:
            if not self.install_module(module):
                all_installed = False
        return all_installed

module_manager = ModuleManager()

###############################################################################
#   6. FUNCȚII UTILITARE
###############################################################################
def check_ollama_status():
    url = CONFIG['ollama']['url'] + "/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 get_cache_key(model, prompt):
    """Generează o cheie unică pentru cache bazată pe model și prompt."""
    return hashlib.md5(f"{model}:{prompt}".encode('utf-8')).hexdigest()

def query_ollama(model, prompt, max_retries=None, timeout=None):
    """
    Trimite un prompt la Ollama și primește răspunsul în streaming.
    Returnează textul complet generat, folosind cache dacă e disponibil.
    """
    max_retries = max_retries or CONFIG['ollama']['max_retries']
    timeout = timeout or CONFIG['ollama']['timeout']
    url = CONFIG['ollama']['url'] + "/api/generate"
    payload = {"model": model, "prompt": prompt, "stream": True}
    
    # Verificăm cache-ul
    cache_key = get_cache_key(model, prompt)
    with shelve.open(os.path.join(TEMP_DIR, 'ollama_cache')) as cache:
        if cache_key in cache:
            logger.info(f"Răspuns găsit în cache pentru model: {model}")
            return cache[cache_key]
    
    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")
                
                # Salvăm în cache
                with shelve.open(os.path.join(TEMP_DIR, 'ollama_cache')) as cache:
                    cache[cache_key] = full_response
                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):
    if not response:
        return None
    
    patterns = [
        r"```python\s*(.*?)\s*```",
        r"```\s*(.*?)\s*```",
        r"(?:(?:def|import|class|if)\s+.*?(?:\n.*?)+)(?:\n\n|$)",
    ]
    
    for pattern in patterns:
        matches = re.findall(pattern, response, re.DOTALL)
        if matches:
            code = matches[0].strip()
            if 'import ' in code or 'def ' in code or 'print(' in code:
                logger.info("Cod Python extras din răspuns.")
                return code
    
    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 validate_code(code):
    """
    Validează sintaxa codului Python folosind ast.
    Returnează (True, []) dacă e ok, sau (False, [erori]) dacă sunt probleme.
    """
    try:
        ast.parse(code)
        logger.info("Validare cod: Sintaxă corectă.")
        return True, []
    except SyntaxError as e:
        logger.warning(f"Validare cod: Eroare de sintaxă: {e}")
        return False, [str(e)]
    except Exception as e:
        logger.error(f"Eroare la validarea codului: {e}")
        return False, [str(e)]

def run_script(script_path, env_vars=None, timeout=30):
    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:
            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)
        
        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):
    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):
    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:
        if line.strip().startswith('import '):
            parts = line.strip()[7:].split(',')
            for part in parts:
                mod = part.strip().split(' ')[0]
                if '.' in mod:
                    mod = mod.split('.')[0]
                modules.append(mod)
        elif ' import ' in line:
            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',
        'shelve', 'hashlib', 'ast', 'argparse'
    ]
    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"):
    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):
    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':
            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):
    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"
    ]
    for kw in code_keywords:
        if kw in task.lower():
            return True
    return False

def process_task_file(file_path):
    """Procesează sarcinile dintr-un fișier text, fiecare sarcină pe o linie."""
    tasks = []
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            tasks = [line.strip() for line in f if line.strip()]
        logger.info(f"Sarcini încărcate din fișier: {len(tasks)}")
        for task in tasks:
            logger.info(f"Procesare sarcină din fișier: {task}")
            result = agent_manager.execute_task(task)
            logger.info(f"Rezultat pentru '{task}': {result.get('message')}")
    except Exception as e:
        logger.error(f"Eroare la procesarea fișierului de sarcini: {e}")

###############################################################################
#   7. 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):
        raise NotImplementedError("Trebuie implementat în subclasă.")
    
    def execute(self, task, context=None):
        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):
        if needs_code_solution(task):
            return 10
        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]
        knowledge_models = CONFIG['ollama']['preferred_models']['knowledge']
        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"}
        
        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)
        
        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):
        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}")
        
        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."}
        
        from googlesearch import search
        
        query = task
        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
        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))
        
        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...")
        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}")
        
        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)
        
        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):
        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"}
        
        available_model_names = [m["name"] for m in available_models]
        coder_models = CONFIG['ollama']['preferred_models']['coder']
        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]}...")
        
        # Validăm codul
        is_valid, errors = validate_code(code)
        if not is_valid:
            self.logger.warning(f"Codul conține probleme de sintaxă: {errors}")
        
        # 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 ș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,
            "validation_errors": errors
        }

###############################################################################
#   8. 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):
        self.agents.append(agent)
        self.logger.info(f"Agent înregistrat: {agent.name} - {agent.description}")
    
    def register_tool(self, name, tool_function):
        self.tools[name] = tool_function
        self.logger.info(f"Unealtă înregistrată: {name}")
    
    def find_best_agent(self, task):
        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
        suitable_agents.sort(key=lambda x: x[1], reverse=True)
        return suitable_agents[0][0]
    
    def execute_task(self, task):
        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."}

###############################################################################
#   9. INSTANȚIERE ȘI MAIN
###############################################################################
agent_manager = AgentManager()
agent_manager.register_agent(DirectResponseAgent())
agent_manager.register_agent(SearchAgent())
agent_manager.register_agent(ScriptGeneratorAgent())

def main():
    parser = argparse.ArgumentParser(description="Sistem Multi-Agent Semiautonom")
    parser.add_argument('--task-file', type=str, help="Cale către un fișier cu sarcini (una pe linie)")
    args = parser.parse_args()
    
    logger.info("=== Sistem Multi-Agent Semiautonom - PORNIRE ===")
    
    if args.task_file:
        process_task_file(args.task_file)
        logger.info("=== Procesare fișier sarcini finalizată ===")
    else:
        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
            result = agent_manager.execute_task(task)
            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()