import os
import logging
from flask import Flask, render_template, request, jsonify, redirect, url_for, flash, session
from werkzeug.utils import secure_filename

# --- Configuração do Log de Depuração ---
# Caminho completo para o arquivo de log para garantir que ele seja criado no lugar certo
log_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'debug.log')
logging.basicConfig(filename=log_file_path, level=logging.INFO, 
                    format='%(asctime)s %(levelname)s %(name)s %(threadName)s : %(message)s')

try:
    logging.info("--- INICIANDO APLICAÇÃO ---")

    # --- Importações do LangChain (movidas para dentro do try para capturar erros de importação) ---
    from dotenv import load_dotenv
    from langchain import hub
    from langchain_chroma import Chroma
    from langchain_community.document_loaders import PyPDFLoader
    from langchain_core.output_parsers import StrOutputParser
    from langchain_core.runnables import RunnablePassthrough
    from langchain_openai import ChatOpenAI, OpenAIEmbeddings
    from langchain_text_splitters import RecursiveCharacterTextSplitter
    logging.info("Importações do LangChain bem-sucedidas.")

    # Carrega variáveis de ambiente
    load_dotenv()
    logging.info("load_dotenv() chamado.")

    # --- Configuração da Aplicação Flask ---
    app = Flask(__name__)
    app.secret_key = os.urandom(24)
    logging.info("Aplicação Flask criada.")

    # --- Configuração de Pastas ---
    UPLOAD_FOLDER = 'uploads'
    VECTOR_STORE_PATH = 'vector_store'
    ALLOWED_EXTENSIONS = {'pdf', 'txt', 'doc', 'docx'}
    app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
    os.makedirs(UPLOAD_FOLDER, exist_ok=True)
    os.makedirs(VECTOR_STORE_PATH, exist_ok=True)
    logging.info("Pastas configuradas.")

    # --- Configuração do LangChain (Global) ---
    openai_api_key = os.getenv('OPENAI_API_KEY')
    if not openai_api_key:
        logging.error("ERRO CRÍTICO: Variável de ambiente OPENAI_API_KEY não encontrada!")
        raise ValueError("OPENAI_API_KEY não configurada.")
    
    os.environ["OPENAI_API_KEY"] = openai_api_key
    logging.info("Chave da API da OpenAI carregada.")

    model = ChatOpenAI(model='gpt-4')
    embedding = OpenAIEmbeddings()
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
    prompt = hub.pull('rlm/rag-prompt')
    logging.info("Componentes do LangChain inicializados.")

    rag_chain = None

    def allowed_file(filename):
        return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS

    def initialize_rag_chain():
        global rag_chain
        logging.info("Iniciando initialize_rag_chain().")
        
        loaded_documents = []
        upload_dir = app.config['UPLOAD_FOLDER']
        if not os.path.isdir(upload_dir):
            logging.error(f"Diretório de uploads '{upload_dir}' não encontrado.")
            return

        files_in_upload = os.listdir(upload_dir)
        logging.info(f"Arquivos encontrados em '{upload_dir}': {files_in_upload}")

        for filename in files_in_upload:
            if allowed_file(filename):
                file_path = os.path.join(upload_dir, filename)
                logging.info(f"Processando arquivo: {file_path}")
                if filename.endswith('.pdf'):
                    loader = PyPDFLoader(file_path)
                    loaded_documents.extend(loader.load())
        
        if not loaded_documents:
            logging.warning("Nenhum documento encontrado para processar. RAG chain não será criado.")
            return

        logging.info(f"{len(loaded_documents)} documentos carregados.")
        chunks = text_splitter.split_documents(documents=loaded_documents)
        logging.info(f"{len(chunks)} chunks criados.")
        
        vector_store = Chroma.from_documents(
            documents=chunks,
            embedding=embedding,
            persist_directory=VECTOR_STORE_PATH
        )
        logging.info("Vector Store criado/carregado.")

        retriever = vector_store.as_retriever()
        rag_chain = (
            {'context': retriever, 'question': RunnablePassthrough()}
            | prompt | model | StrOutputParser()
        )
        logging.info("RAG Chain inicializado com sucesso!")

    # --- Rotas da Aplicação ---
    @app.route('/')
    def index():
        if 'chat_history' not in session:
            session['chat_history'] = [{'sender': 'assessor', 'message': 'Olá! Como posso te ajudar hoje?'}]
        return render_template('index.html', chat_history=session['chat_history'])

    # ... (o resto das suas rotas continua aqui, sem alterações)
    @app.route('/ask', methods=['POST'])
    def ask():
        if not rag_chain:
            return jsonify({'answer': 'Desculpe, a base de conhecimento ainda não foi inicializada. Por favor, adicione um documento.'})
        user_question = request.json.get('question')
        if not user_question:
            return jsonify({'error': 'Nenhuma pergunta fornecida.'}), 400
        session['chat_history'].append({'sender': 'user', 'message': user_question})
        response = rag_chain.invoke(user_question)
        session['chat_history'].append({'sender': 'assessor', 'message': response})
        session.modified = True
        return jsonify({'answer': response})

    @app.route('/knowledge_base')
    def knowledge_base():
        files = os.listdir(app.config['UPLOAD_FOLDER'])
        return render_template('knowledge_base.html', files=files)

    @app.route('/upload', methods=['POST'])
    def upload_file():
        if 'file' not in request.files:
            flash('Nenhum arquivo selecionado')
            return redirect(url_for('knowledge_base'))
        file = request.files['file']
        if file.filename == '':
            flash('Nenhum arquivo selecionado')
            return redirect(url_for('knowledge_base'))
        if file and allowed_file(file.filename):
            filename = secure_filename(file.filename)
            file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
            file.save(file_path)
            flash(f'Arquivo "{filename}" enviado com sucesso! Re-processando a base de conhecimento...')
            initialize_rag_chain()
            return redirect(url_for('knowledge_base'))
        else:
            flash('Tipo de arquivo não permitido.')
            return redirect(url_for('knowledge_base'))

    # --- Inicialização ---
    logging.info("Definição das rotas concluída. Chamando initialize_rag_chain() pela primeira vez.")
    initialize_rag_chain()
    logging.info("Aplicação pronta para ser executada.")

except Exception as e:
    # --- CAPTURA DE ERRO CRÍTICO ---
    # Se qualquer coisa acima falhar, este bloco será executado
    logging.exception("Uma exceção não tratada ocorreu durante a inicialização da aplicação!")
    # Criamos uma aplicação Flask mínima apenas para responder com o erro
    app = Flask(__name__)
    @app.route('/', defaults={'path': ''})
    @app.route('/<path:path>')
    def catch_all(path):
        error_message = f"Erro crítico na inicialização da aplicação. Verifique o arquivo debug.log. Erro: {e}"
        return error_message, 500