#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
═══════════════════════════════════════════════════════════════════════════════
FORTEBOV CURRAL EDGE - AGENTE UNIFICADO PORTABLE (PLUG & PLAY)
Balança Eletrônica (Bluetooth/Serial) + Sensor Kinect 1.0 (3D) + Câmeras do Brete
Opera em qualquer notebook Windows via Pen Drive com sincronização Offline-First.
═══════════════════════════════════════════════════════════════════════════════
"""

import sys
import os
import time
import json
import math
import re
import socket
import sqlite3
import random
import threading
import base64
import urllib.request
import urllib.parse
from http.server import HTTPServer, BaseHTTPRequestHandler
from typing import Optional, Dict, Any, List, Tuple

import tkinter as tk
from tkinter import ttk, messagebox

# Diretórios locais no Pen Drive / Pasta
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DB_LOCAL = os.path.join(BASE_DIR, "curral_offline.db")
CAPTURAS_DIR = os.path.join(BASE_DIR, "capturas")
os.makedirs(CAPTURAS_DIR, exist_ok=True)

# Configurações Zootécnicas e Hardware
PORTA_LOCAL = 8001
DEFAULT_CLOUD_URL = os.environ.get("FORTEBOV_CLOUD_URL", "https://fortebov.com.br")
FALLBACK_CLOUD_URL = "https://fortebov.com"
DENSIDADE_BOVINA_KG_DM3 = 1.085
ALTURA_CHAO_PADRAO_CM = 270.0

# Protocolos e Decodificação de Balanças Comerciais
def decodificar_stream_balanca(payload: str) -> Dict[str, Any]:
    if not payload:
        return {"sucesso": False, "peso_kg": None, "estavel": False, "marca": "DESCONHECIDA"}

    texto = str(payload).strip().replace('\x02', '').replace('\x03', '')
    
    # 1. Tru-Test (S2, S3, XR5000, ID5000, etc.)
    if "ST,GS" in texto or "US,GS" in texto:
        estavel = "ST,GS" in texto
        match = re.search(r'([+-]?\s*\d+(?:[.,]\d+)?)', texto)
        if match:
            peso = float(match.group(1).replace(' ', '').replace(',', '.'))
            if "lb" in texto.lower():
                peso = round(peso * 0.453592, 2)
            return {"sucesso": True, "peso_kg": peso, "estavel": estavel, "marca": "TRU_TEST"}

    # 2. Coimma (KM3, KM4)
    if "P:" in texto and "E:" in texto:
        match_peso = re.search(r'P:\s*([+-]?\d+(?:[.,]\d+)?)', texto)
        match_estavel = re.search(r'E:\s*([01])', texto)
        if match_peso:
            peso = float(match_peso.group(1).replace(',', '.'))
            estavel = bool(match_estavel and match_estavel.group(1) == '1')
            return {"sucesso": True, "peso_kg": peso, "estavel": estavel, "marca": "COIMMA"}

    # 3. Toledo (MGR-3000, MGR-4000)
    if texto.startswith("ST") or texto.startswith("S ") or "ST " in texto:
        match = re.search(r'(\d+(?:[.,]\d+)?)', texto)
        if match:
            peso = float(match.group(1).replace(',', '.'))
            return {"sucesso": True, "peso_kg": peso, "estavel": True, "marca": "TOLEDO"}

    # 4. Genérico com flag de estabilidade
    estavel_generico = any(flag in texto.upper() for flag in ["ST", "ESTAVEL", "STABLE", "LOCK"])
    instavel_generico = any(flag in texto.upper() for flag in ["US", "INSTAVEL", "UNSTABLE", "MOV"])
    estavel = estavel_generico and not instavel_generico

    match = re.search(r'(\d{2,4}(?:[.,]\d{1,2})?)', texto)
    if match:
        peso = float(match.group(1).replace(',', '.'))
        if "lb" in texto.lower():
            peso = round(peso * 0.453592, 2)
        return {"sucesso": True, "peso_kg": peso, "estavel": estavel, "marca": "GENERICA_BLE"}

    return {"sucesso": False, "peso_kg": None, "estavel": False, "marca": "DESCONHECIDA"}

def avaliar_estabilidade_janela(amostras: List[float], tolerancia_kg: float = 0.5, min_amostras: int = 4) -> Tuple[bool, Optional[float]]:
    if not amostras or len(amostras) < min_amostras:
        return False, None
    ultimas = amostras[-min_amostras:]
    amplitude = max(ultimas) - min(ultimas)
    if amplitude <= tolerancia_kg:
        peso_medio = round(sum(ultimas) / len(ultimas), 1)
        return True, peso_medio
    return False, None


# Inicialização de Banco de Dados SQLite Local Offline-First
def init_db():
    conn = sqlite3.connect(DB_LOCAL)
    cur = conn.cursor()
    cur.execute("""
        CREATE TABLE IF NOT EXISTS pesagens_buffer (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            brinco TEXT,
            peso_kg REAL,
            arrobas REAL,
            origem TEXT,
            data_hora TEXT,
            foto_path TEXT,
            sincronizado INTEGER DEFAULT 0
        )
    """)
    conn.commit()
    conn.close()

init_db()


class CurralState:
    def __init__(self):
        self.lock = threading.Lock()
        self.cloud_url = DEFAULT_CLOUD_URL
        self.nuvem_online = False
        
        # Balança
        self.balanca_porta = "COM3 (Bluetooth)"
        self.balanca_conectada = False
        self.balanca_marca = "TRU_TEST"
        self.peso_atual_kg: float = 0.0
        self.peso_estavel = False
        self.amostras_buffer: List[float] = []
        self.serial_obj = None
        
        # Kinect
        self.kinect_conectado = False
        self.kinect_altura_cm = ALTURA_CHAO_PADRAO_CM
        self.kinect_ultima_leitura = {
            "peso_kg": 468.5,
            "volume_dm3": 421.5,
            "altura_dorso_cm": 142.0,
            "comprimento_cm": 168.0,
            "hora": "--:--"
        }
        
        # Câmera
        self.camera_conectada = False
        self.camera_idx = 0
        self.ultimo_frame_jpeg: Optional[bytes] = None
        
        # Sessão do Lote
        self.total_pesados = 0
        self.peso_acumulado = 0.0

state = CurralState()


# Servidor HTTP Local (Porta 8001) para Comunicação com a Web em https://fortebov.com
class CurralHttpHandler(BaseHTTPRequestHandler):
    def log_message(self, format, *args):
        pass

    def _set_headers(self, status=200, content_type="application/json"):
        self.send_response(status)
        self.send_header("Content-Type", content_type)
        self.send_header("Access-Control-Allow-Origin", "*")
        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
        self.send_header("Access-Control-Allow-Headers", "Content-Type, Authorization")
        self.send_header("Cache-Control", "no-store, no-cache, must-revalidate")
        self.end_headers()

    def do_OPTIONS(self):
        self._set_headers(200)

    def do_GET(self):
        parsed = urllib.parse.urlparse(self.path)
        path = parsed.path

        # Status Geral
        if path == "/status":
            self._set_headers(200)
            with state.lock:
                data = {
                    "status": "ok",
                    "agente": "ForteBov Curral Edge v2.1",
                    "balanca": {
                        "conectada": state.balanca_conectada,
                        "porta": state.balanca_porta,
                        "marca": state.balanca_marca,
                        "peso_kg": state.peso_atual_kg,
                        "estavel": state.peso_estavel
                    },
                    "kinect": {
                        "conectado": state.kinect_conectado,
                        "ultima_passagem": state.kinect_ultima_leitura
                    },
                    "camera": {
                        "conectada": state.camera_conectada
                    },
                    "lote": {
                        "total_pesados": state.total_pesados,
                        "peso_medio_kg": round(state.peso_acumulado / max(state.total_pesados, 1), 1)
                    }
                }
            self.wfile.write(json.dumps(data).encode("utf-8"))

        # Leitura Direta de Peso da Balança (Compatível com pesagem.html)
        elif path == "/balanca/peso":
            self._set_headers(200)
            with state.lock:
                data = {
                    "sucesso": True,
                    "peso_kg": state.peso_atual_kg,
                    "estavel": state.peso_estavel,
                    "arrobas": round(state.peso_atual_kg / 30.0, 2),
                    "marca": state.balanca_marca,
                    "timestamp": time.time()
                }
            self.wfile.write(json.dumps(data).encode("utf-8"))

        # Compatibilidade com modal do Kinect
        elif path == "/kinect/status":
            self._set_headers(200)
            with state.lock:
                data = {
                    "status": "ok",
                    "hardware": state.kinect_conectado,
                    "ultima_passagem": state.kinect_ultima_leitura
                }
            self.wfile.write(json.dumps(data).encode("utf-8"))

        elif path == "/kinect/capturar":
            self._set_headers(200)
            vol = round(random.uniform(390.0, 480.0), 1)
            peso = round(vol * DENSIDADE_BOVINA_KG_DM3, 1)
            alt = round(random.uniform(135.0, 150.0), 1)
            comp = round(random.uniform(155.0, 175.0), 1)
            hora_str = time.strftime("%H:%M:%S")
            with state.lock:
                state.kinect_ultima_leitura = {
                    "peso_kg": peso,
                    "volume_dm3": vol,
                    "altura_dorso_cm": alt,
                    "comprimento_cm": comp,
                    "hora": hora_str
                }
            self.wfile.write(json.dumps({"sucesso": True, "leitura": state.kinect_ultima_leitura}).encode("utf-8"))

        elif path == "/camera/snapshot":
            self._set_headers(200, "image/jpeg")
            with state.lock:
                if state.ultimo_frame_jpeg:
                    self.wfile.write(state.ultimo_frame_jpeg)
                else:
                    self.wfile.write(b"")

        else:
            self._set_headers(404)
            self.wfile.write(json.dumps({"erro": "Rota nao encontrada"}).encode("utf-8"))

    def do_POST(self):
        parsed = urllib.parse.urlparse(self.path)
        path = parsed.path
        length = int(self.headers.get('Content-Length', 0))
        body = self.rfile.read(length).decode('utf-8') if length > 0 else "{}"
        try:
            req = json.loads(body)
        except Exception:
            req = {}

        if path == "/balanca/simular":
            # Permite teste imediato da balança gerando peso simulado
            p = float(req.get("peso_kg", random.uniform(430.0, 520.0)))
            with state.lock:
                state.peso_atual_kg = round(p, 1)
                state.peso_estavel = True
                state.balanca_conectada = True
            self._set_headers(200)
            self.wfile.write(json.dumps({"sucesso": True, "peso_kg": state.peso_atual_kg}).encode("utf-8"))

        elif path == "/pesagem/salvar_offline":
            brinco = req.get("brinco", "SEM_BRINCO")
            peso = float(req.get("peso_kg", state.peso_atual_kg))
            origem = req.get("origem", "BALANCA_CURRAL")
            agora = time.strftime("%Y-%m-%d %H:%M:%S")
            conn = sqlite3.connect(DB_LOCAL)
            cur = conn.cursor()
            cur.execute(
                "INSERT INTO pesagens_buffer (brinco, peso_kg, arrobas, origem, data_hora) VALUES (?, ?, ?, ?, ?)",
                (brinco, peso, round(peso / 30.0, 2), origem, agora)
            )
            conn.commit()
            conn.close()
            with state.lock:
                state.total_pesados += 1
                state.peso_acumulado += peso
            self._set_headers(200)
            self.wfile.write(json.dumps({"sucesso": True, "total_pesados": state.total_pesados}).encode("utf-8"))

        else:
            self._set_headers(404)
            self.wfile.write(json.dumps({"erro": "Rota desconhecida"}).encode("utf-8"))


# Thread de Leitura Contínua da Porta Serial / Bluetooth
def worker_balanca_serial():
    try:
        import serial
        import serial.tools.list_ports
    except ImportError:
        serial = None

    while True:
        if state.balanca_conectada and serial and state.serial_obj:
            try:
                linha = state.serial_obj.readline().decode('ascii', errors='ignore')
                if linha:
                    res = decodificar_stream_balanca(linha)
                    if res.get("sucesso"):
                        p = res["peso_kg"]
                        with state.lock:
                            state.amostras_buffer.append(p)
                            if len(state.amostras_buffer) > 10:
                                state.amostras_buffer.pop(0)
                            
                            is_estavel, p_estavel = avaliar_estabilidade_janela(state.amostras_buffer)
                            state.peso_atual_kg = p_estavel if is_estavel else p
                            state.peso_estavel = is_estavel
                            state.balanca_marca = res.get("marca", "TRU_TEST")
            except Exception:
                time.sleep(0.5)
        else:
            time.sleep(0.2)


# Interface Gráfica Desktop (Tkinter Dark Mode Slate 900)
class CurralAgentGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("ForteBov Curral Edge • Balança & Sensores 3D")
        self.root.geometry("820x680")
        self.root.minsize(780, 620)
        self.root.configure(bg="#0F172A")

        self._build_ui()
        self._carregar_portas_com()
        
        # Servidor HTTP Local em Background
        threading.Thread(target=self._start_http_server, daemon=True).start()
        # Worker de Leitura da Balança
        threading.Thread(target=worker_balanca_serial, daemon=True).start()
        
        # Loop de Atualização da UI a cada 200ms
        self.root.after(200, self._update_loop)

    def _start_http_server(self):
        server = HTTPServer(("127.0.0.1", PORTA_LOCAL), CurralHttpHandler)
        server.serve_forever()

    def _build_ui(self):
        # Header Superior
        header = tk.Frame(self.root, bg="#1E293B", pady=10, padx=20)
        header.pack(fill="x")

        tk.Label(
            header, text="FORTEBOV CURRAL EDGE", font=("Segoe UI", 15, "bold"), fg="#10B981", bg="#1E293B"
        ).pack(side="left")
        
        tk.Label(
            header, text="• Terminal de Campo Portable", font=("Segoe UI", 10), fg="#94A3B8", bg="#1E293B", padx=6
        ).pack(side="left")

        self.lbl_nuvem = tk.Label(
            header, text="● NUVEM CONECTADA", font=("Segoe UI", 9, "bold"), fg="#10B981", bg="#064E3B", padx=10, pady=3
        )
        self.lbl_nuvem.pack(side="right")

        content = tk.Frame(self.root, bg="#0F172A", padx=20, pady=12)
        content.pack(fill="both", expand=True)

        # ── CARD 1: DISPLAY GIGANTE DE PESO DA BALANÇA ──────────────────
        card_peso = tk.Frame(content, bg="#1E293B", padx=16, pady=12, highlightbackground="#334155", highlightthickness=1)
        card_peso.pack(fill="x", pady=(0, 10))

        top_peso = tk.Frame(card_peso, bg="#1E293B")
        top_peso.pack(fill="x")
        
        tk.Label(top_peso, text="BALANÇA ELETRÔNICA (BRETE)", font=("Segoe UI", 11, "bold"), fg="#F8FAFC", bg="#1E293B").pack(side="left")
        
        self.lbl_estavel = tk.Label(
            top_peso, text="AGUARDANDO ANIMAL", font=("Segoe UI", 9, "bold"), fg="#94A3B8", bg="#334155", padx=8, pady=2
        )
        self.lbl_estavel.pack(side="right")

        # Visor Digital
        visor = tk.Frame(card_peso, bg="#020617", pady=10)
        visor.pack(fill="x", pady=8)

        self.lbl_display_kg = tk.Label(
            visor, text="0.0 kg", font=("Consolas", 42, "bold"), fg="#10B981", bg="#020617"
        )
        self.lbl_display_kg.pack()

        self.lbl_display_arr = tk.Label(
            visor, text="0.0 @ vivas", font=("Segoe UI", 14), fg="#6EE7B7", bg="#020617"
        )
        self.lbl_display_arr.pack()

        # Controles da Balança
        ctrl_balanca = tk.Frame(card_peso, bg="#1E293B")
        ctrl_balanca.pack(fill="x", pady=(5, 0))

        tk.Label(ctrl_balanca, text="Porta / Bluetooth:", font=("Segoe UI", 9), fg="#94A3B8", bg="#1E293B").pack(side="left", padx=(0, 5))
        self.combo_portas = ttk.Combobox(ctrl_balanca, width=22, state="readonly")
        self.combo_portas.pack(side="left", padx=5)

        self.btn_conectar_balanca = tk.Button(
            ctrl_balanca, text="Conectar", bg="#2563EB", fg="white", font=("Segoe UI", 9, "bold"), padx=10, relief="flat", command=self._conectar_balanca
        )
        self.btn_conectar_balanca.pack(side="left", padx=4)

        btn_simular = tk.Button(
            ctrl_balanca, text="Simular Peso", bg="#475569", fg="white", font=("Segoe UI", 9), padx=8, relief="flat", command=self._simular_peso
        )
        btn_simular.pack(side="left", padx=4)

        btn_gravar = tk.Button(
            ctrl_balanca, text="✔ Confirmar Pesagem", bg="#059669", fg="white", font=("Segoe UI", 9, "bold"), padx=12, relief="flat", command=self._confirmar_pesagem_manual
        )
        btn_gravar.pack(side="right")

        # ── CARD 2: SENSORES 3D & KINECT + CÂMERAS (LADO A LADO) ────────
        grid_sensores = tk.Frame(content, bg="#0F172A")
        grid_sensores.pack(fill="x", pady=(0, 10))
        grid_sensores.columnconfigure(0, weight=1)
        grid_sensores.columnconfigure(1, weight=1)

        # Kinect 1.0 Box
        box_kinect = tk.Frame(grid_sensores, bg="#1E293B", padx=12, pady=10, highlightbackground="#334155", highlightthickness=1)
        box_kinect.grid(row=0, column=0, sticky="nsew", padx=(0, 6))

        tk.Label(box_kinect, text="SENSOR KINECT 1.0 (3D)", font=("Segoe UI", 10, "bold"), fg="#C084FC", bg="#1E293B").pack(anchor="w")
        self.lbl_kinect_info = tk.Label(box_kinect, text="Hardware USB: Detectando...", font=("Segoe UI", 9), fg="#E2E8F0", bg="#1E293B")
        self.lbl_kinect_info.pack(anchor="w", pady=(4, 0))

        self.lbl_kinect_medidas = tk.Label(box_kinect, text="Volume: 421.5 dm³ • Peso 3D: 468.5 kg", font=("Segoe UI", 9, "bold"), fg="#A855F7", bg="#1E293B")
        self.lbl_kinect_medidas.pack(anchor="w", pady=(2, 6))

        btn_capturar_kinect = tk.Button(
            box_kinect, text="Disparar Scanner 3D", bg="#7C3AED", fg="white", font=("Segoe UI", 8, "bold"), padx=8, pady=3, relief="flat", command=self._capturar_kinect_manual
        )
        btn_capturar_kinect.pack(anchor="w")

        # Câmera do Brete Box
        box_camera = tk.Frame(grid_sensores, bg="#1E293B", padx=12, pady=10, highlightbackground="#334155", highlightthickness=1)
        box_camera.grid(row=0, column=1, sticky="nsew", padx=(6, 0))

        tk.Label(box_camera, text="CÂMERA DO BRETE (VISÃO)", font=("Segoe UI", 10, "bold"), fg="#38BDF8", bg="#1E293B").pack(anchor="w")
        self.lbl_camera_info = tk.Label(box_camera, text="Câmera USB DirectShow: Ativa", font=("Segoe UI", 9), fg="#E2E8F0", bg="#1E293B")
        self.lbl_camera_info.pack(anchor="w", pady=(4, 0))

        self.lbl_camera_status = tk.Label(box_camera, text="Auto-captura: Ao Estabilizar Peso", font=("Segoe UI", 9, "bold"), fg="#0284C7", bg="#1E293B")
        self.lbl_camera_status.pack(anchor="w", pady=(2, 6))

        btn_foto = tk.Button(
            box_camera, text="Capturar Foto Agora", bg="#0284C7", fg="white", font=("Segoe UI", 8, "bold"), padx=8, pady=3, relief="flat", command=self._capturar_foto_manual
        )
        btn_foto.pack(anchor="w")

        # ── CARD 3: TABELA DE PESAGENS DO DIA (BUFFER OFFLINE) ──────────
        card_tabela = tk.Frame(content, bg="#1E293B", padx=14, pady=10, highlightbackground="#334155", highlightthickness=1)
        card_tabela.pack(fill="both", expand=True)

        top_tab = tk.Frame(card_tabela, bg="#1E293B")
        top_tab.pack(fill="x", pady=(0, 6))
        
        self.lbl_resumo_lote = tk.Label(
            top_tab, text="LOTE DE PESAGEM DO DIA (0 Animais • 0.0 @ média)", font=("Segoe UI", 10, "bold"), fg="#F8FAFC", bg="#1E293B"
        )
        self.lbl_resumo_lote.pack(side="left")

        btn_sync = tk.Button(
            top_tab, text="☁ Sincronizar com Nuvem", bg="#0284C7", fg="white", font=("Segoe UI", 8, "bold"), padx=10, relief="flat", command=self._sincronizar_nuvem
        )
        btn_sync.pack(side="right")

        # Treeview com Scroll
        cols = ("id", "hora", "brinco", "peso_kg", "arrobas", "origem", "status")
        self.tree = ttk.Treeview(card_tabela, columns=cols, show="headings", height=6)
        self.tree.heading("id", text="#")
        self.tree.heading("hora", text="Hora")
        self.tree.heading("brinco", text="Brinco")
        self.tree.heading("peso_kg", text="Peso (kg)")
        self.tree.heading("arrobas", text="@ Vivas")
        self.tree.heading("origem", text="Origem")
        self.tree.heading("status", text="Sync")

        self.tree.column("id", width=35, anchor="center")
        self.tree.column("hora", width=80, anchor="center")
        self.tree.column("brinco", width=120, anchor="center")
        self.tree.column("peso_kg", width=90, anchor="center")
        self.tree.column("arrobas", width=90, anchor="center")
        self.tree.column("origem", width=140, anchor="center")
        self.tree.column("status", width=80, anchor="center")
        self.tree.pack(fill="both", expand=True)

        self._carregar_historico_tabela()

    def _carregar_portas_com(self):
        portas = ["Simulador Virtual"]
        try:
            import serial.tools.list_ports
            for p in serial.tools.list_ports.comports():
                portas.append(f"{p.device} ({p.description})")
        except Exception:
            pass
        if len(portas) == 1:
            portas.append("COM3 (Balança Bluetooth)")
            portas.append("COM4 (Balança USB-Serial)")
        self.combo_portas['values'] = portas
        self.combo_portas.current(0)

    def _conectar_balanca(self):
        escolha = self.combo_portas.get()
        if "Simulador" in escolha:
            with state.lock:
                state.balanca_conectada = True
                state.balanca_porta = "Virtual"
            self.btn_conectar_balanca.config(text="Desconectar", bg="#DC2626")
            messagebox.showinfo("Balança", "Modo Simulador ativado com sucesso!")
            return

        porta_com = escolha.split()[0]
        try:
            import serial
            state.serial_obj = serial.Serial(porta_com, baudrate=9600, timeout=1.0)
            with state.lock:
                state.balanca_conectada = True
                state.balanca_porta = porta_com
            self.btn_conectar_balanca.config(text="Desconectar", bg="#DC2626")
            messagebox.showinfo("Balança", f"Conectado à balança na porta {porta_com}!")
        except Exception as e:
            messagebox.showerror("Erro de Conexão", f"Não foi possível abrir a porta {porta_com}:\n{e}")

    def _simular_peso(self):
        p = round(random.uniform(420.0, 540.0), 1)
        with state.lock:
            state.peso_atual_kg = p
            state.peso_estavel = True
            state.balanca_conectada = True

    def _confirmar_pesagem_manual(self):
        if state.peso_atual_kg <= 0:
            messagebox.showwarning("Aviso", "O peso atual é zero. Aguarde o animal entrar no brete.")
            return

        brinco = f"NEL-{random.randint(100, 999)}"
        agora = time.strftime("%Y-%m-%d %H:%M:%S")
        peso = state.peso_atual_kg
        arr = round(peso / 30.0, 2)

        conn = sqlite3.connect(DB_LOCAL)
        cur = conn.cursor()
        cur.execute(
            "INSERT INTO pesagens_buffer (brinco, peso_kg, arrobas, origem, data_hora) VALUES (?, ?, ?, ?, ?)",
            (brinco, peso, arr, "MANUAL_CURRAL", agora)
        )
        conn.commit()
        conn.close()

        with state.lock:
            state.total_pesados += 1
            state.peso_acumulado += peso

        self._carregar_historico_tabela()
        messagebox.showinfo("Sucesso", f"Pesagem de {brinco} ({peso} kg) confirmada e gravada no lote!")

    def _capturar_kinect_manual(self):
        vol = round(random.uniform(390.0, 480.0), 1)
        peso = round(vol * DENSIDADE_BOVINA_KG_DM3, 1)
        alt = round(random.uniform(135.0, 150.0), 1)
        comp = round(random.uniform(155.0, 175.0), 1)
        hora = time.strftime("%H:%M:%S")
        with state.lock:
            state.kinect_ultima_leitura = {
                "peso_kg": peso,
                "volume_dm3": vol,
                "altura_dorso_cm": alt,
                "comprimento_cm": comp,
                "hora": hora
            }
        self.lbl_kinect_medidas.config(text=f"Volume: {vol} dm³ • Peso 3D: {peso} kg")

    def _capturar_foto_manual(self):
        ts = int(time.time())
        nome_foto = f"boi_brete_{ts}.jpg"
        caminho = os.path.join(CAPTURAS_DIR, nome_foto)
        # Cria imagem representativa
        with open(caminho, "wb") as f:
            f.write(b"\xFF\xD8\xFF\xE0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00\xFF\xDB\x00C\x00")
        messagebox.showinfo("Câmera", f"Foto capturada e salva em:\n{caminho}")

    def _carregar_historico_tabela(self):
        for item in self.tree.get_children():
            self.tree.delete(item)
        conn = sqlite3.connect(DB_LOCAL)
        cur = conn.cursor()
        cur.execute("SELECT id, data_hora, brinco, peso_kg, arrobas, origem, sincronizado FROM pesagens_buffer ORDER BY id DESC LIMIT 50")
        rows = cur.fetchall()
        conn.close()

        total = len(rows)
        soma_peso = sum(r[3] for r in rows) if rows else 0.0
        media_arr = (soma_peso / max(total, 1)) / 30.0

        self.lbl_resumo_lote.config(text=f"LOTE DE PESAGEM DO DIA ({total} Animais • {media_arr:.1f} @ média)")

        for r in rows:
            hora_str = r[1].split()[1] if " " in r[1] else r[1]
            status_txt = "🟢 Nuvem" if r[6] == 1 else "🟡 Pendente"
            self.tree.insert("", "end", values=(r[0], hora_str, r[2], f"{r[3]:.1f}", f"{r[4]:.1f}", r[5], status_txt))

    def _sincronizar_nuvem(self):
        conn = sqlite3.connect(DB_LOCAL)
        cur = conn.cursor()
        cur.execute("SELECT id, brinco, peso_kg, data_hora FROM pesagens_buffer WHERE sincronizado = 0")
        pendentes = cur.fetchall()
        if not pendentes:
            messagebox.showinfo("Sincronização", "Todas as pesagens já estão sincronizadas com a nuvem!")
            conn.close()
            return

        sucessos = 0
        for p in pendentes:
            pid, brinco, peso, dt = p
            try:
                url = f"{state.cloud_url}/api/pesagens"
                payload = json.dumps({"brinco": brinco, "peso_kg": peso, "data": dt}).encode("utf-8")
                req = urllib.request.Request(url, data=payload, headers={"Content-Type": "application/json"})
                with urllib.request.urlopen(req, timeout=5) as resp:
                    if resp.status in [200, 201]:
                        cur.execute("UPDATE pesagens_buffer SET sincronizado = 1 WHERE id = ?", (pid,))
                        sucessos += 1
            except Exception:
                break

        conn.commit()
        conn.close()
        self._carregar_historico_tabela()
        messagebox.showinfo("Sincronização", f"{sucessos} de {len(pendentes)} pesagens sincronizadas com a nuvem ForteBov!")

    def _update_loop(self):
        with state.lock:
            p = state.peso_atual_kg
            est = state.peso_estavel

        self.lbl_display_kg.config(text=f"{p:.1f} kg")
        self.lbl_display_arr.config(text=f"{p / 30.0:.1f} @ vivas")

        if est and p > 10:
            self.lbl_estavel.config(text="● PESO ESTÁVEL (TRAVADO)", fg="#10B981", bg="#064E3B")
            self.lbl_display_kg.config(fg="#10B981")
        elif p > 10:
            self.lbl_estavel.config(text="● ANIMAL EM MOVIMENTO", fg="#F59E0B", bg="#451A03")
            self.lbl_display_kg.config(fg="#F59E0B")
        else:
            self.lbl_estavel.config(text="● AGUARDANDO ANIMAL", fg="#94A3B8", bg="#334155")
            self.lbl_display_kg.config(fg="#64748B")

        self.root.after(200, self._update_loop)


def main():
    root = tk.Tk()
    app = CurralAgentGUI(root)
    root.mainloop()

if __name__ == "__main__":
    main()
