import openai
import os
import time
import pyodbc
import json
import re
from dotenv import load_dotenv
# Carregar variáveis de ambiente
load_dotenv()

# Configurar OpenAI
client = openai.OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

# Conectar à base de dados
def connect_db():
    try:
        conn = pyodbc.connect(
            "DRIVER={ODBC Driver 17 for SQL Server};"
            f"SERVER={os.getenv('DB_SERVER')};"
            f"DATABASE={os.getenv('DB_NAME')};"
            f"UID={os.getenv('DB_USER')};"
            f"PWD={os.getenv('DB_PASSWORD')};"
        )
        return conn
    except Exception as e:
        print(f"Erro ao conectar à base de dados: {e}")
        return None

def get_entry_by_position(position=1):
    conn = connect_db()
    if not conn:
        return "Erro: Não foi possível conectar à base de dados."

    try:
        with conn.cursor() as cursor:
            query = f"SELECT * FROM CUnitBills ORDER BY Id ASC OFFSET {position-1} ROWS FETCH NEXT 1 ROWS ONLY"
            cursor.execute(query)

            row = cursor.fetchone()
            if row:
                columns = [column[0] for column in cursor.description]
                formatted_data = "\n".join([f"- **{column}**: {value if value is not None else 'Não disponível'}" for column, value in zip(columns, row)])
                return formatted_data
            return "Nenhum dado encontrado."
    except Exception as e:
        return f"Erro ao buscar dados: {e}"
    finally:
        conn.close()

# Obter dados do SQL Server
def get_data(atributes=None, limit=20):
    conn = connect_db()
    if not conn:
        return "Erro: Não foi possível conectar à base de dados."

    try:
        with conn.cursor() as cursor:
            if atributes:
                query = f"SELECT TOP {limit} * FROM CUnitBills WHERE Number LIKE ? ORDER BY Id ASC"
                cursor.execute(query, (f"%{atributes}%",))
            else:
                query = f"SELECT TOP {limit} * FROM CUnitBills ORDER BY Id ASC "
                cursor.execute(query)

            columns = [column[0] for column in cursor.description]
            rows = [dict(zip(columns, row)) for row in cursor.fetchall()]
            
            if rows:
                formatted_rows = "\n\n".join([
                    "\n".join([f"- **{column}**: {row[column]}" for column in columns]) for row in rows
                ])
                return formatted_rows
            return "Nenhum dado encontrado."
    except Exception as e:
        return f"Erro ao buscar dados: {e}"
    finally:
        conn.close()

def get_filtered_data(cunit_id=None, date_billling_begin=None, date_billing_end=None, limit=2):
    conn = connect_db()
    if not conn:
        return "Erro: Não foi possível conectar à base de dados."

    try:
        with conn.cursor() as cursor:
            query = f"SELECT TOP {limit} * FROM CUnitBills"
            conditions = []
            params = []
            
            if cunit_id is not None:
                conditions.append("CUnitId = ?")
                params.append(cunit_id)

            if date_billling_begin :
                conditions.append("DateBilllingBegin >= ?")
                params.append(date_billling_begin)

            if date_billing_end :
                conditions.append("DateBillingEnd = ?")
                params.append(date_billing_end)

            if conditions:
                query += " WHERE " + " AND ".join(conditions)

            query += " ORDER BY Id ASC"

            print("Query Final:", query)  # Para debugging
            print("Parâmetros SQL:", params)

            cursor.execute(query, params)
            columns = [column[0] for column in cursor.description]
            rows = [dict(zip(columns, row)) for row in cursor.fetchall()]

            if rows:
                formatted_rows = "\n\n".join([
                    "\n".join([f"- **{column}**: {row[column]}" for column in columns]) for row in rows
                ])
                return formatted_rows
            return "Nenhum dado encontrado."
    except Exception as e:
        return "Erro ao buscar dados. Verifique os critérios e tente novamente."
    finally:
        conn.close()

def parse_user_input(user_input):
    cunit_id = None
    date_billling_begin = None
    date_billing_end = None

    match_cunit_id = re.search(r"CUnitId\s*(?:de)?\s*(\d+)", user_input, re.IGNORECASE)
    print(match_cunit_id)
    match_date_billling_begin = re.search(r"DateBilllingBegin\s*(?:maior que|>=)\s*([\d-]+)", user_input, re.IGNORECASE)
    match_date_billing_end = re.search(r"DateBillingEnd\s*(?:igual a|=)\s*([\d-]+)", user_input, re.IGNORECASE)

    if match_cunit_id:
        cunit_id = int(match_cunit_id.group(1))

    if match_date_billling_begin:
        date_billling_begin = match_date_billling_begin.group(1).strip()

    if match_date_billing_end:
        date_billing_end = match_date_billing_end.group(1).strip()


    return cunit_id, date_billling_begin, date_billing_end
    

# Chat com GPT
def chat_with_gpt(prompt, attempts=3):
    for i in range(attempts):
        try:
            response = client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[{"role": "user", "content": prompt}],
                max_tokens=300
            )
            return response.choices[0].message.content.strip()
        except openai.RateLimitError:
            if i < attempts - 1:
                print("Limite de requisições atingido! Tentando novamente...")
                time.sleep(10)
            else: 
                return "Erro: Limite de requisições atingido várias vezes. Tente novamente mais tarde."
        except Exception as e:
            return f"Erro na API OpenAI: {e}"
    
# Main
if __name__ == "__main__":
    # Testar conexão antes de iniciar o chatbot
    conn = connect_db()
    if conn:
        print("Conexão com a base de dados estabelecida com sucesso!")
        conn.close()
    else:
        print("Erro ao conectar à base de dados.")

    while True:
        user_input = input("Eu: ")
        if user_input.lower() in ["quit", "exit", "bye"]:
            break

        cunit_id, date_billling_begin, date_billing_end = parse_user_input(user_input)

        if cunit_id or date_billling_begin or date_billing_end:
            data = get_filtered_data(cunit_id, date_billling_begin, date_billing_end)

            if data:
                print(f"Chatbot: Aqui estão os dados encontrados:\n{data}")
            else:
                print("Chatbot: Nenhuma entrada encontrada para os critérios fornecidos.")
            continue

        if "dados" in user_input.lower():
            data = get_data()
            print(f"\nDados do SQL Server:\n{data}")
            continue

        response = chat_with_gpt(user_input)
        print("Chatbot: ", response)