import requests
import json
import openai
import datetime

# Configurări pentru OpenAI
openai.api_base = "http://localhost:11434/v1"
openai.api_key = "ollama"  # Aceasta este necesară, dar neutilizată
model_openai = "llama2"

# Lista pentru a stoca răspunsurile anterioare
previous_responses = []

# Funcție pentru a obține răspunsul de la modelul compatibil OpenAI
def get_response_from_openai(prompt):
    try:
        response = openai.ChatCompletion.create(
            model=model_openai,
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=150,
            temperature=0.7,
        )
        return response.choices[0].message['content'].strip()
    except Exception as e:
        error_message = f"Error fetching response from OpenAI: {e}"
        log_error(error_message)
        return error_message

# Funcție pentru a obține răspunsul de la modelul LLaMA folosind un apel API direct
def get_response_from_llama(prompt):
    try:
        payload = json.dumps({
            "model": "llama2",
            "messages": [
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": prompt}
            ]
        })
        response = requests.post(f"{openai.api_base}/chat/completions", data=payload, headers={"Content-Type": "application/json"})
        
        if response.status_code == 200:
            response_json = response.json()
            print(f"Response JSON from LLaMA: {response_json}")  # Debugging output
            return response_json['choices'][0]['message']['content'].strip()
        else:
            error_message = f"Error from LLaMA API: {response.status_code} - {response.text}"
            log_error(error_message)
            return error_message
    except Exception as e:
        error_message = f"Error fetching response from LLaMA: {e}"
        log_error(error_message)
        return error_message

# Funcție pentru a înregistra erorile
def log_error(message):
    with open("error_log.txt", "a", encoding="utf-8") as log_file:
        log_file.write(f"{datetime.datetime.now()} - {message}\n")

# Funcție care verifică răspunsurile anterioare
def check_previous_responses(previous_responses, current_response):
    for response in previous_responses:
        if response in current_response:
            return True
    return False

# Funcție care filtrează răspunsurile redundante
def filter_redundant_responses(previous_responses, current_response):
    if check_previous_responses(previous_responses, current_response):
        current_response += " - Aceasta este o idee deja discutată. Să explorăm alte opțiuni sau să clarificăm mai mult."
    return current_response

# Funcție care creează o sinteză a tuturor ideilor discutate până acum
def synthesize_responses(responses):
    synthesis = "Rezumatul ideilor discutate: \n"
    for response in responses:
        synthesis += "- " + response + "\n"
    synthesis += "Ce putem adăuga sau îmbunătăți la aceste puncte?"
    return synthesis

# Funcție care adaugă o întrebare pentru a stimula dialogul între AI-uri
def interactive_response(current_response):
    question = "Ce părere ai despre acest aspect? Ai altă idee de adăugat?"
    return current_response + " " + question

# Funcție care gestionează ciclul de comunicare între două AI-uri
def ai_communication_cycle(prompt):
    ai1_response = get_response_from_openai(prompt)
    ai2_response = get_response_from_llama(prompt)

    ai1_filtered = filter_redundant_responses(previous_responses, ai1_response)
    ai2_filtered = filter_redundant_responses(previous_responses, ai2_response)
    
    previous_responses.extend([ai1_filtered, ai2_filtered])
    
    synthesis = synthesize_responses(previous_responses)
    
    ai1_final = interactive_response(ai1_filtered)
    ai2_final = interactive_response(ai2_filtered)
    
    return ai1_final, ai2_final, synthesis

# Funcție pentru a salva discuția într-un fișier text
def save_discussion_to_file(prompt, ai1_final, ai2_final, synthesis):
    with open("discutie_ai.txt", "a", encoding="utf-8") as file:
        file.write(f"Tema: {prompt}\n")
        file.write(f"Răspuns AI 1: {ai1_final}\n")
        file.write(f"Răspuns AI 2: {ai2_final}\n")
        file.write(f"Sinteza: {synthesis}\n")
        file.write("-------------------------------\n\n")

# Funcție principală care permite utilizatorului să interacționeze cu AI-urile
def main():
    print("Introduceți tema de discuție sau scrieți 'exit' pentru a închide programul:")
    prompt = input("Tema: ")
    
    if prompt.lower() == 'exit':
        return
    
    try:
        num_cycles = int(input("Câte cicluri de discuție doriți să parcurgă AI-urile? "))
    except ValueError:
        print("Introduceți un număr valid!")
        return
    
    for cycle in range(num_cycles):
        print(f"\n--- Ciclul {cycle + 1} ---")
        ai1_final, ai2_final, synthesis = ai_communication_cycle(prompt)
        
        print("Răspuns AI 1:", ai1_final)
        print("Răspuns AI 2:", ai2_final)
        print("Sinteza:", synthesis)
        print("-------------------------------\n")
        
        # Salvează discuția într-un fișier text
        save_discussion_to_file(prompt, ai1_final, ai2_final, synthesis)

if __name__ == "__main__":
    main()