from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from django.db import connection
from .models import Produto, Pedido, Mensagem
from .models import Produto, Mensagem, Pedido, ProprietarioEstabelecimento

@login_required
def painel_dono(request):
    if not hasattr(request.user, 'tenant') or not request.user.tenant:
        return render(request, 'erros/sem_tenant.html')

    connection.set_schema(request.user.tenant.schema_name)

    produtos = Produto.objects.all()
    mensagens = Mensagem.objects.order_by('-data')[:10]
    pedidos = Pedido.objects.order_by('-data')[:10]

    # Contagens por status
    novos_count = Pedido.objects.filter(status='confirmado').count()
    andamento_count = Pedido.objects.filter(status__in=['preparo', 'entrega']).count()
    entregues_count = Pedido.objects.filter(status='entregue').count()

    # Tenta obter dados do proprietário se existirem
    perfil = ProprietarioEstabelecimento.objects.filter(user=request.user).first()

    return render(request, 'atendimento/painel_dono.html', {
        'produtos': produtos,
        'mensagens': mensagens,
        'pedidos': pedidos,
        'novos_count': novos_count,
        'andamento_count': andamento_count,
        'entregues_count': entregues_count,
        'perfil': perfil,
    })


########################################################################################

from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from django.db import connection
from .forms import ProdutoForm

@login_required
def cadastrar_produto(request):
    if not hasattr(request.user, 'tenant') or not request.user.tenant:
        return render(request, 'erros/sem_tenant.html')

    connection.set_schema(request.user.tenant.schema_name)

    if request.method == 'POST':
        form = ProdutoForm(request.POST, request.FILES)
        if form.is_valid():
            form.save()
            return redirect('atendimento:painel_dono')
    else:
        form = ProdutoForm()

    return render(request, 'atendimento/cadastrar_produto.html', {'form': form})


########################################################################################

from django.shortcuts import render, get_object_or_404, redirect
from django.contrib.auth.decorators import login_required
from django.db import connection
from .models import Produto
from .forms import ProdutoForm

@login_required
def editar_produto(request, pk):
    connection.set_schema(request.user.tenant.schema_name)
    produto = get_object_or_404(Produto, pk=pk)

    if request.method == 'POST':
        form = ProdutoForm(request.POST, request.FILES, instance=produto)
        if form.is_valid():
            form.save()
            return redirect('atendimento:listar_produtos')
    else:
        form = ProdutoForm(instance=produto)

    return render(request, 'atendimento/editar_produto.html', {'form': form, 'produto': produto})



########################################################################################


@login_required
def excluir_produto(request, pk):
    connection.set_schema(request.user.tenant.schema_name)
    produto = get_object_or_404(Produto, pk=pk)
    produto.delete()
    return redirect('atendimento:listar_produtos')


########################################################################################

from django.contrib.auth.decorators import login_required
from django.db import connection
from django.shortcuts import render
from .models import Produto, IdentidadeRestaurante

@login_required
def listar_produtos(request):
    connection.set_schema(request.user.tenant.schema_name)
    produtos = Produto.objects.all().order_by('categoria', 'nome')
    identidade = IdentidadeRestaurante.objects.first()

    return render(request, 'atendimento/produtos_list.html', {
        'produtos': produtos,
        'identidade': identidade,
    })


########################################################################################

from .models import Produto

def cardapio_digital(request):
    connection.set_schema(request.user.tenant.schema_name)

    produtos = Produto.objects.filter(disponivel=True).order_by('categoria', 'nome')
    categorias = sorted(set(produtos.values_list('categoria', flat=True)))
    return render(request, 'atendimento/cardapio.html', {
        'produtos': produtos,
        'categorias': categorias,
    })

########################################################################################

from .models import IdentidadeRestaurante
from .forms import IdentidadeRestauranteForm

@login_required
def editar_identidade(request):
    connection.set_schema(request.user.tenant.schema_name)
    identidade, _ = IdentidadeRestaurante.objects.get_or_create(id=1)

    if request.method == 'POST':
        form = IdentidadeRestauranteForm(request.POST, request.FILES, instance=identidade)
        if form.is_valid():
            form.save()
            return redirect('atendimento:listar_produtos')
    else:
        form = IdentidadeRestauranteForm(instance=identidade)

    return render(request, 'atendimento/editar_identidade.html', {'form': form})


########################################################################################

from weasyprint import HTML
from django.template.loader import render_to_string
from django.http import HttpResponse
from .models import Produto, IdentidadeRestaurante

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

    produtos = Produto.objects.filter(disponivel=True).order_by('categoria', 'nome')
    identidade = IdentidadeRestaurante.objects.first()

    logo_url = identidade.logotipo.url if identidade and identidade.logotipo else None
    nome_restaurante = identidade.nome if identidade else "Cardápio"
    endereco = getattr(identidade, 'endereco', '')
    telefone = getattr(identidade, 'telefone', '')

    html = render_to_string('atendimento/cardapio_pdf.html', {
        'produtos': produtos,
        'logo_url': request.build_absolute_uri(logo_url) if logo_url else None,
        'nome_restaurante': nome_restaurante,
        'endereco': endereco,
        'telefone': telefone,
    })

    pdf = HTML(string=html, base_url=request.build_absolute_uri()).write_pdf()

    response = HttpResponse(pdf, content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="cardapio_{nome_restaurante}.pdf"'
    return response

########################################################################################

from django.shortcuts import render, get_object_or_404
from atendimento.models import Produto, IdentidadeRestaurante
from tenant_management.models import Client
from django.http import HttpResponseNotFound
from django_tenants.utils import schema_context

def cardapio_publico(request, slug):
    # Busca a identidade que tem esse slug (em todos os tenants)
    from tenant_management.models import Client
    from django_tenants.utils import schema_context

    # Procurar em todos os tenants quem tem uma identidade com esse slug
    for tenant in Client.objects.exclude(schema_name='public'):
        with schema_context(tenant.schema_name):
            identidade = IdentidadeRestaurante.objects.filter(slug=slug).first()
            if identidade:
                produtos = Produto.objects.filter(disponivel=True).order_by('categoria', 'nome')
                return render(request, 'atendimento/cardapio_publico.html', {
                    'identidade': identidade,
                    'produtos': produtos,
                    'logo_url': identidade.logotipo.url if identidade.logotipo else None,
                    'nome_restaurante': identidade.nome,
                    'endereco': identidade.endereco,
                    'telefone': identidade.telefone,
                })

    # Se nenhum tenant tiver esse slug
    return render(request, 'atendimento/cardapio_indisponivel.html', {
        'mensagem': 'Página não disponível para este endereço.'
    })


##########################################################################33

def pedido_publico(request, slug):
    from tenant_management.models import Client
    from atendimento.models import IdentidadeRestaurante, Produto
    from django_tenants.utils import schema_context

    for tenant in Client.objects.exclude(schema_name='public'):
        with schema_context(tenant.schema_name):
            identidade = IdentidadeRestaurante.objects.filter(slug=slug).first()
            if identidade:
                produtos = Produto.objects.filter(disponivel=True).order_by('categoria', 'nome')
                return render(request, 'atendimento/pedido_publico.html', {
                    'slug': slug,
                    'identidade': identidade,
                    'produtos': produtos,
                    'logo_url': identidade.logotipo.url if identidade.logotipo else None,
                    'nome_restaurante': identidade.nome,
                    'endereco': identidade.endereco,
                    'telefone': identidade.telefone,
                })

    return render(request, 'atendimento/cardapio_indisponivel.html', {
        'mensagem': 'Restaurante não encontrado.'
    })


##########################################################################

from django.shortcuts import render, redirect
from tenant_management.models import Client
from atendimento.models import IdentidadeRestaurante, Produto, Pedido
from django_tenants.utils import schema_context
from decimal import Decimal

def enviar_pedido_publico(request, slug):
    if request.method != "POST":
        return redirect('atendimento:pedido_publico', slug=slug)

    # Procurar tenant que contenha a identidade com o slug
    for tenant in Client.objects.exclude(schema_name='public'):
        with schema_context(tenant.schema_name):
            identidade = IdentidadeRestaurante.objects.filter(slug=slug).first()
            if identidade:
                nome = request.POST.get("nome")
                telefone = request.POST.get("telefone")
                endereco = request.POST.get("endereco")
                pagamento = request.POST.get("pagamento")
                observacoes = request.POST.get("observacoes", "").strip()
                itens_pedido = []
                total = Decimal("0.00")
                produtos = Produto.objects.filter(disponivel=True)

                for produto in produtos:
                    qtd = int(request.POST.get(f"quantidade_{produto.id}", "0"))
                    if qtd > 0:
                        itens_pedido.append(f"{qtd}x {produto.nome}")
                        total += produto.preco * qtd

                if not itens_pedido:
                    return render(request, 'atendimento/pedido_confirmacao.html', {
                        "mensagem": "Nenhum item foi selecionado.",
                        "sucesso": False,
                        "slug": slug
                    })

                pedido = Pedido.objects.create(
                    nome=nome,
                    telefone=telefone,
                    endereco=endereco,
                    itens=", ".join(itens_pedido),
                    total=total,
                    pagamento=pagamento,
                    observacoes=observacoes,
                    status="confirmado"
                )

                return render(request, 'atendimento/pedido_confirmacao.html', {
                    "mensagem": "Pedido enviado com sucesso!",
                    "sucesso": True,
                    "pedido": pedido,
                    "slug": slug
                })

    return render(request, 'atendimento/pedido_confirmacao.html', {
        "mensagem": "Restaurante não encontrado.",
        "sucesso": False,
        "slug": slug
    })


##########################################################################

from django.contrib.auth.decorators import login_required
from django.shortcuts import get_object_or_404, redirect
from django.db import connection
from .models import Pedido

@login_required
def atualizar_status_pedido(request, pk, novo_status):
    connection.set_schema(request.user.tenant.schema_name)
    pedido = get_object_or_404(Pedido, pk=pk)
    pedido.status = novo_status
    pedido.save()
    # se entregou, leva para vendas registradas
    if novo_status == 'entregue':
        return redirect('atendimento:vendas_registradas')
    return redirect('atendimento:painel_dono')


##########################################################################

from django.shortcuts import render
from tenant_management.models import Client
from django_tenants.utils import schema_context
from atendimento.models import Pedido, IdentidadeRestaurante

def acompanhar_pedido(request, slug, codigo):
    for tenant in Client.objects.exclude(schema_name='public'):
        with schema_context(tenant.schema_name):
            identidade = IdentidadeRestaurante.objects.filter(slug=slug).first()
            pedido = Pedido.objects.filter(codigo=codigo).first()
            if identidade and pedido:
                return render(request, 'atendimento/acompanhamento.html', {
                    'pedido': pedido,
                    'identidade': identidade,
                })

    return render(request, 'atendimento/pedido_confirmacao.html', {
        'mensagem': 'Pedido não encontrado.',
        'sucesso': False,
        'slug': slug
    })

##########################################################################

from django.http import JsonResponse
from .models import Pedido

def contagem_pedidos(request):
    novos = Pedido.objects.filter(status="confirmado").count()
    andamento = Pedido.objects.filter(status__in=["preparo", "entrega"]).count()
    entregues = Pedido.objects.filter(status="entregue").count()
    return JsonResponse({
        "novos": novos,
        "andamento": andamento,
        "entregues": entregues
    })

##########################################################################

from django.contrib.auth.decorators import login_required
from django.db.models import Sum
from django.db.models.functions import TruncDate
from django.shortcuts import render
from django.db import connection
from .models import Pedido, Produto

@login_required
def vendas_registradas(request):
    if not hasattr(request.user, 'tenant') or not request.user.tenant:
        return render(request, 'erros/sem_tenant.html')

    connection.set_schema(request.user.tenant.schema_name)

    pedidos = Pedido.objects.filter(status='entregue')

    # Gráfico de linha - total de vendas por dia
    vendas_por_dia = (
        pedidos
        .annotate(dia=TruncDate('data'))
        .values('dia')
        .annotate(total=Sum('total'))
        .order_by('dia')
    )
    dias = [v['dia'].strftime("%d/%m") for v in vendas_por_dia]
    totais = [float(v['total']) for v in vendas_por_dia]

    # Gráfico de pizza - soma por categoria
    categorias = []
    valores_categorias = []
    produtos = Produto.objects.all()

    # Mapeia categorias com totais
    mapa_categoria = {}
    for pedido in pedidos:
        for produto in produtos:
            if produto.nome.lower() in pedido.itens.lower():
                cat = produto.categoria or 'Sem Categoria'
                mapa_categoria[cat] = mapa_categoria.get(cat, 0) + float(pedido.total)

    categorias = list(mapa_categoria.keys())
    valores_categorias = list(mapa_categoria.values())

    # Produtos únicos encontrados nos itens dos pedidos
    nomes_produtos = set()
    for pedido in pedidos:
        for produto in produtos:
            if produto.nome.lower() in pedido.itens.lower():
                nomes_produtos.add(produto.nome)
    nomes_produtos = sorted(nomes_produtos)

    return render(request, 'atendimento/vendas_registradas.html', {
        'pedidos_entregues': pedidos.order_by('-data'),
        'dias': dias,
        'totais': totais,
        'categorias': categorias,
        'valores_categorias': valores_categorias,
        'nomes_produtos': nomes_produtos,
    })


##########################################################################


from django.http import JsonResponse
from django.db.models.functions import TruncDate
from django.db.models import Sum
from .models import Pedido, Produto

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

    produto_nome = request.GET.get('produto')
    pedidos = Pedido.objects.filter(status='entregue')

    titulo = "Total de Vendas (R$)"

    if produto_nome and produto_nome != "todos":
        pedidos = [p for p in pedidos if produto_nome.lower() in p.itens.lower()]
        titulo = f"Vendas de {produto_nome} (R$)"

        # transformar em queryset-like para annotate
        from collections import defaultdict
        mapa = defaultdict(float)
        for p in pedidos:
            dia = p.data.date()
            mapa[dia] += float(p.total)

        labels = [d.strftime("%d/%m") for d in sorted(mapa)]
        valores = [mapa[d] for d in sorted(mapa)]
    else:
        vendas_por_dia = (
            Pedido.objects
            .filter(status='entregue')
            .annotate(dia=TruncDate('data'))
            .values('dia')
            .annotate(total=Sum('total'))
            .order_by('dia')
        )
        labels = [v['dia'].strftime("%d/%m") for v in vendas_por_dia]
        valores = [float(v['total']) for v in vendas_por_dia]

    return JsonResponse({
        'labels': labels,
        'valores': valores,
        'titulo': titulo,
    })


##########################################################################


from django.http import JsonResponse
from django.contrib.auth.decorators import login_required
from django.db.models.functions import TruncDate
from django.db import connection
from .models import Pedido, Produto
from collections import defaultdict
from datetime import datetime

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

    tipo = request.GET.get("tipo", "total")
    pedidos = Pedido.objects.filter(status="entregue")
    produtos = Produto.objects.all()

    # Normalizar produtos (nome -> categoria e preço)
    mapa_produto = {p.nome.lower(): {"categoria": p.categoria or "Outros", "preco": p.preco} for p in produtos}

    # Inicializadores
    agrupamento_diario = defaultdict(float)
    agrupamento_pizza = defaultdict(float)

    for pedido in pedidos:
        data = pedido.data.date().strftime("%d/%m")
        itens = pedido.itens.lower().split(",")

        for item in itens:
            item = item.strip()
            qtd = 1

            # Tenta extrair quantidade
            if "x " in item:
                try:
                    qtd_str, nome_item = item.split("x ", 1)
                    qtd = int(qtd_str.strip())
                    nome_item = nome_item.strip()
                except:
                    nome_item = item
            else:
                nome_item = item

            info = mapa_produto.get(nome_item.lower())

            if info:
                valor_total = qtd * float(info["preco"])
                categoria = info["categoria"]

                if tipo == "produto":
                    agrupamento_diario[(data, nome_item)] += valor_total
                    agrupamento_pizza[nome_item] += valor_total
                elif tipo == "categoria":
                    agrupamento_diario[(data, categoria)] += valor_total
                    agrupamento_pizza[categoria] += valor_total
                else:  # total
                    agrupamento_diario[data] += float(pedido.total)
                    agrupamento_pizza["Total Geral"] += float(pedido.total)
                    break  # total só uma vez por pedido

    # Processar gráfico de linha
    if tipo == "total":
        dias = sorted(set(agrupamento_diario.keys()))
        valores_linha = [agrupamento_diario[d] for d in dias]
        titulo_linha = "Total de Vendas (R$)"
        labels_linha = dias
    else:
        agrupado = defaultdict(float)
        for (dia, chave), valor in agrupamento_diario.items():
            agrupado[dia] += valor
        dias = sorted(set(d for (d, _) in agrupamento_diario))
        labels_linha = dias
        valores_linha = [agrupado[d] for d in dias]
        titulo_linha = "Vendas por " + ("Produto" if tipo == "produto" else "Categoria")

    # Gráfico pizza
    labels_pizza = list(agrupamento_pizza.keys())
    valores_pizza = [agrupamento_pizza[k] for k in labels_pizza]

    return JsonResponse({
        "labels": labels_linha,
        "valores_linha": valores_linha,
        "titulo_linha": titulo_linha,
        "labels_pizza": labels_pizza,
        "valores_pizza": valores_pizza,
    })

##########################################################################


from django.views.decorators.http import require_POST


@login_required
@require_POST
def save_user_info(request):
    if not hasattr(request.user, 'tenant') or not request.user.tenant:
        return render(request, 'erros/sem_tenant.html')

    # Garante uso do schema correto
    connection.set_schema(request.user.tenant.schema_name)

    # Dados do formulário
    full_name = request.POST.get("full_name")
    identidade = request.POST.get("identity")
    telefone = request.POST.get("phone")
    endereco = request.POST.get("address")

    # Atualiza nome do usuário (caso queira armazenar no Django User)
    request.user.first_name = full_name
    request.user.save()

    # Cria ou atualiza os dados do proprietário
    perfil, created = ProprietarioEstabelecimento.objects.get_or_create(user=request.user)
    perfil.identidade = identidade
    perfil.telefone = telefone
    perfil.endereco = endereco
    perfil.save()

    return redirect('atendimento:painel_dono')

##########################################################################