import requests
from django.shortcuts import render, redirect, get_object_or_404
from .models import Projeto
import logging
from requests.utils import quote
from django.db import connection
from django.contrib.auth.decorators import login_required




# Chaves das APIs
GEOAPIFY_API_KEY = '3d8dccff4c994354a239d91df4427437'
OPEN_METEO_API_URL = "https://api.open-meteo.com/v1/elevation"


def obter_coordenadas(cidade):

    try:
        # Codificar a cidade corretamente para a URL
        cidade_formatada = quote(f"{cidade}, Brasil")
        
        # URL de geocodificação com Geoapify
        url = f"https://api.geoapify.com/v1/geocode/search?text={cidade_formatada}&apiKey={GEOAPIFY_API_KEY}"
        logging.info(f"URL enviada para Geoapify: {url}")
        
        # Fazer a requisição
        response = requests.get(url)
        
        # Verifica se a resposta é bem-sucedida (código de status 200)
        if response.status_code == 200:
            data = response.json()

            # Verifica se existem resultados e se os dados têm o formato esperado
            if 'features' in data and len(data['features']) > 0:
                coordenadas = data['features'][0]['geometry']['coordinates']
                logging.info(f"Coordenadas obtidas para {cidade}: {coordenadas}")
                return coordenadas[1], coordenadas[0]  # Retorna latitude (coordenadas[1]) e longitude (coordenadas[0])
            else:
                logging.error(f"Não foram encontradas coordenadas para a cidade: {cidade}")
        else:
            logging.error(f"Erro ao acessar a API Geoapify: Código de status {response.status_code}. Resposta: {response.text}")

    except Exception as e:
        logging.exception(f"Erro ao obter coordenadas para {cidade}: {e}")
    
    return None, None


def obter_altitude(latitude, longitude):
    """
    Usa a API Open-Meteo para obter a altitude com base nas coordenadas de latitude e longitude.
    """
    try:
        url = f"{OPEN_METEO_API_URL}?latitude={latitude}&longitude={longitude}"
        response = requests.get(url)

        # Verifica se a resposta é bem-sucedida
        if response.status_code == 200:
            data = response.json()
            if 'elevation' in data:
                return data['elevation'][0] if isinstance(data['elevation'], list) else data['elevation']
            else:
                logging.error("Não foi possível obter a elevação da resposta.")
        else:
            logging.error(f"Erro ao acessar a API Open-Meteo: Código de status {response.status_code}. Resposta: {response.text}")

    except Exception as e:
        logging.exception(f"Erro ao obter altitude para as coordenadas ({latitude}, {longitude}): {e}")
    
    return None

# Função para cadastrar um novo projeto com coordenadas e altitude
from django.shortcuts import render, redirect
from django.contrib import messages
from .models import Projeto
from django.db import connection

from django.shortcuts import render, redirect
from django.contrib import messages
from django.db import connection

from django.contrib.auth.decorators import login_required
@login_required
def cadastrar_projeto(request):
    if request.method == 'POST':
        nome_projeto = request.POST['nome_projeto']
        cidade = request.POST['cidade']

        # Obter as coordenadas da cidade usando a API Geoapify
        latitude, longitude = obter_coordenadas(cidade)
        
        # Verificar se as coordenadas foram obtidas
        if latitude is None or longitude is None:
            return render(request, 'projeto/erro.html', {'erro': 'Não foi possível obter as coordenadas da cidade.'})

        # Obter a altitude com as coordenadas obtidas
        altitude = obter_altitude(latitude, longitude)

        # Certifique-se de que o schema correto está configurado antes de criar o projeto
        tenant_schema = request.user.tenant.schema_name
        connection.set_schema(tenant_schema)

        # Criar o projeto com as coordenadas e altitude
        projeto = Projeto.objects.create(
            nome_projeto=nome_projeto,
            cidade=cidade,
            latitude=latitude,
            longitude=longitude,
            altitude=altitude  # Salva a altitude no projeto
        )
        return redirect('lista_projetos')
    return render(request, 'projeto/cadastrar_projeto.html')




# Função para listar os projetos cadastrados
from django.db import connection
@login_required
def lista_projetos(request):
    # Garantir que o schema correto esteja sendo usado
    if request.user.is_authenticated and request.user.tenant:
        connection.set_schema(request.user.tenant.schema_name)

    projetos = Projeto.objects.all()  # Agora a consulta deve ocorrer no schema correto
    return render(request, 'projeto/lista_projetos.html', {'projetos': projetos})


from django.db import connection
from django.shortcuts import get_object_or_404, redirect
from .models import Projeto
@login_required
def deletar_projeto(request, projeto_id):
    # Verifica se o usuário está autenticado e tem um tenant
    if request.user.is_authenticated and request.user.tenant: 
        # Define o schema do tenant atual para a consulta
        connection.set_schema(request.user.tenant.schema_name)
    
    # Recupera o projeto com base no ID fornecido
    projeto = get_object_or_404(Projeto, id=projeto_id)
    
    # Deleta o projeto
    projeto.delete()
    
    # Redireciona para a lista de projetos
    return redirect('lista_projetos')


from django.db import connection
from django.shortcuts import get_object_or_404, render
from .models import Projeto
@login_required
def detalhes_projeto(request, projeto_id):
    # Verifica se o usuário está autenticado e tem um tenant
    if request.user.is_authenticated and request.user.tenant:
        # Define o schema do tenant atual para a consulta
        connection.set_schema(request.user.tenant.schema_name)
    
    # Recupera o projeto com base no ID fornecido
    projeto = get_object_or_404(Projeto, id=projeto_id)
    
    # Renderiza a página de detalhes do projeto
    return render(request, 'projeto/detalhes_projeto.html', {'projeto': projeto})

from django.shortcuts import render

def sobre_este_app(request):
    return render(request, 'projeto/sobre_este_app.html')  # Certifique-se de que o template tenha este nome e esteja no diretório correto


# projeto/views.py
from django.contrib.sessions.models import Session
from django.utils import timezone
from django.contrib.auth import get_user_model

# projeto/views.py
from django.contrib.sessions.models import Session
from django.utils import timezone
from django.contrib.auth import get_user_model

from django.contrib.sessions.models import Session
from django.utils import timezone
from django.core.cache import cache
from django.contrib.auth import get_user_model

@login_required
def lista_projetos(request):
    if request.user.tenant:
        connection.set_schema(request.user.tenant.schema_name)

    active_sessions = Session.objects.filter(expire_date__gte=timezone.now())
    currently_online = []
    
    for session in active_sessions:
        last_activity = cache.get(f'user_activity_{session.session_key}')
        if last_activity:
            time_threshold = timezone.now().timestamp() - 300  # 5 minutos
            if last_activity > time_threshold:
                uid = session.get_decoded().get('_auth_user_id')
                if uid:
                    User = get_user_model()
                    try:
                        user = User.objects.get(id=uid)
                        if user != request.user and user.tenant == request.user.tenant:
                            currently_online.append({
                                'username': user.username,
                                'tenant': user.tenant.name
                            })
                    except User.DoesNotExist:
                        continue

    projetos = Projeto.objects.all()
    return render(request, 'projeto/lista_projetos.html', {
        'projetos': projetos,
        'currently_online': currently_online
    })



@login_required
def assistente_grfgraph_view(request):
    return render(request, 'projeto/assistente_grfgraph.html')


from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from django.http import JsonResponse
from django.db import connection
from django.contrib.auth.decorators import login_required
from .agent import (
    responder_pergunta_termo_ia,
    resposta_fixa_se_houver,
    resposta_coeficiente_parede,
    buscar_resposta_rapida
)
from .respostas_rapidas import  resposta_treinamento_aplicativo
def formatar_para_html(texto):
    """Formata texto plano com \n\n em parágrafos HTML."""
    return "".join(f"<p>{par.strip()}</p>" for par in texto.split("\n\n"))


@csrf_exempt
@require_POST
@login_required
def chat_assistente_view(request):
    if request.user.tenant:
        connection.set_schema(request.user.tenant.schema_name)

    mensagem = request.POST.get("mensagem")

    if not mensagem:
        return JsonResponse({"erro": "Mensagem não informada."}, status=400)

    if "chat_history" not in request.session:
        request.session["chat_history"] = []

    request.session["chat_history"].append({
        "role": "user",
        "content": mensagem
    })
    request.session.modified = True

    try:
        resposta = resposta_fixa_se_houver(mensagem)

        if not resposta:
            resposta = buscar_resposta_rapida(mensagem)

        if not resposta:
            resposta = resposta_coeficiente_parede(mensagem)

        if not resposta:
            resposta = responder_pergunta_termo_ia(request, request.session["chat_history"])

        # Aplica formatação se for o texto completo de treinamento
        if resposta == resposta_treinamento_aplicativo:
            resposta = formatar_para_html(resposta)

    except Exception as e:
        resposta = f"[Erro ao processar mensagem]: {str(e)}"

    request.session["chat_history"].append({
        "role": "assistant",
        "content": resposta
    })
    request.session.modified = True

    return JsonResponse({"resposta": resposta})





# from .agent import responder_pergunta_termo_ia, #executar_acao_projeto  # <-- certifique-se desse import

# @csrf_exempt
# @require_POST
# @login_required
# def chat_assistente_view(request):
#     if request.user.tenant:
#         connection.set_schema(request.user.tenant.schema_name)

#     mensagem = request.POST.get("mensagem")

#     if not mensagem:
#         return JsonResponse({"erro": "Mensagem não informada."}, status=400)

#     if "chat_history" not in request.session:
#         request.session["chat_history"] = []

#     request.session["chat_history"].append({
#         "role": "user",
#         "content": mensagem
#     })
#     request.session.modified = True

#     try:
#         # 🔍 Verifica se é um comando para criar projeto
#         acao_projeto = executar_acao_projeto(request.user, mensagem)

#         if acao_projeto:  # Se for uma ação real de criação
#             resposta = acao_projeto
#         else:
#             # Caso contrário, segue com o modelo IA normal
#             resposta = responder_pergunta_termo_ia(request, request.session["chat_history"])

#     except Exception as e:
#         resposta = f"[Erro ao processar mensagem]: {str(e)}"

#     request.session["chat_history"].append({
#         "role": "assistant",
#         "content": resposta
#     })
#     request.session.modified = True

#     return JsonResponse({"resposta": resposta})



# views.py (ou onde estiver sua view de TTS)
# views.py (ou onde estiver sua view de TTS)
from django.views.decorators.csrf import csrf_exempt
from django.http import JsonResponse, HttpResponseBadRequest, HttpResponse
from django.conf import settings
import json
import os
import re
import uuid

from openai import OpenAI
client = OpenAI(api_key=settings.OPENAI_API_KEY)

@csrf_exempt
def tts_openai(request):
    if request.method != "POST":
        return HttpResponseBadRequest("Método inválido.")

    try:
        data = json.loads(request.body)
        texto = data.get("texto", "").strip()
        pergunta = data.get("pergunta", "").strip()

        if not texto or not pergunta:
            return HttpResponseBadRequest("Texto ou pergunta ausente.")

        # Usar a pergunta para nomear o arquivo
        nome_base = re.sub(r'\W+', '_', pergunta[:50])  # Limpa e limita a pergunta
        nome_arquivo = f"{nome_base}_{uuid.uuid4().hex[:8]}.mp3"

        # Caminho completo
        caminho_pasta = "/var/www/html/cag/projeto/audios_gerados_ia"
        os.makedirs(caminho_pasta, exist_ok=True)
        caminho_completo = os.path.join(caminho_pasta, nome_arquivo)

        # Geração do áudio
        response = client.audio.speech.create(
            model="tts-1",
            voice="echo",
            input=texto,
        )

        # Salvar o mp3
        with open(caminho_completo, "wb") as f:
            f.write(response.content)

        return HttpResponse(response.content, content_type='audio/mpeg')

    except Exception as e:
        print("Erro ao gerar áudio:", str(e))
        return HttpResponseBadRequest("Erro ao gerar áudio.")




# def criar_projeto_por_ia(usuario, nome_projeto, cidade):
#     latitude, longitude = obter_coordenadas(cidade)
#     if latitude is None or longitude is None:
#         return None, "Não foi possível obter as coordenadas da cidade."

#     altitude = obter_altitude(latitude, longitude)

#     # Define o schema
#     from django.db import connection
#     connection.set_schema(usuario.tenant.schema_name)

#     projeto = Projeto.objects.create(
#         nome_projeto=nome_projeto,
#         cidade=cidade,
#         latitude=latitude,
#         longitude=longitude,
#         altitude=altitude
#     )
#     return projeto, f"Projeto '{nome_projeto}' criado com sucesso!"