Update app.py

app.py

@@ -14,7 +14,7 @@ from reportlab.lib.pagesizes import letter
 # ==========================================
 # CONFIGURAÇÃO GERAL
 # ==========================================
-st.set_page_config(page_title="SGP - Gestão de Embalagem v19.0", layout="wide", page_icon="🏭")
+st.set_page_config(page_title="SGP - Gestão de Embalagem v20.0", layout="wide", page_icon="🏭")
 
 FITAS = [
     {"nome": "Fita 1.20", "tamanho": 1.20}, {"nome": "Fita 1.40", "tamanho": 1.40},
@@ -63,10 +63,6 @@ class PackageCalculator:
         return MADEIRAS_PADRAO[-1]
 
     def _buscar_no_banco(self, tipo, l, a, e):
-        """
-        Busca robusta numérica (ignora formatação de string "15" vs "15.00")
-        Retorna: (item_exato, item_vizinho)
-        """
         target_db = DB["IT13"] if tipo == "Redondo" else DB["IT14"]
         melhor_vizinho = None
         menor_distancia = float('inf')
@@ -74,148 +70,158 @@ class PackageCalculator:
         for key, item in target_db.items():
             try:
                 parts = [float(x) for x in key.split('_')]
-                
                 if tipo == "Redondo":
                     db_l, db_e = parts[0], parts[1]
-                    # Match Exato (com pequena tolerância de float)
-                    if math.isclose(l, db_l, abs_tol=0.1) and math.isclose(e, db_e, abs_tol=0.05):
-                        return item, None # Encontrou exato!
-                    
-                    # Vizinho (Mesmo diametro, espessura diferente)
+                    if math.isclose(l, db_l, abs_tol=0.1) and math.isclose(e, db_e, abs_tol=0.05): return item, None
                     if math.isclose(l, db_l, abs_tol=0.1):
                         dist = abs(e - db_e)
-                        if dist < menor_distancia:
-                            menor_distancia = dist
-                            melhor_vizinho = item
-
+                        if dist < menor_distancia: menor_distancia, melhor_vizinho = dist, item
                 else:
-                    # Metalon (Tenta LxA e AxL)
                     db_l, db_a, db_e = parts[0], parts[1], parts[2]
-                    
-                    match_normal = math.isclose(l, db_l, abs_tol=0.1) and math.isclose(a, db_a, abs_tol=0.1)
-                    match_inv = math.isclose(l, db_a, abs_tol=0.1) and math.isclose(a, db_l, abs_tol=0.1)
-                    
-                    if (match_normal or match_inv) and math.isclose(e, db_e, abs_tol=0.05):
-                        return item, None # Encontrou exato!
-                    
-                    # Vizinho (Mesma geometria, espessura diferente)
-                    if (match_normal or match_inv):
+                    match_n = math.isclose(l, db_l, abs_tol=0.1) and math.isclose(a, db_a, abs_tol=0.1)
+                    match_i = math.isclose(l, db_a, abs_tol=0.1) and math.isclose(a, db_l, abs_tol=0.1)
+                    if (match_n or match_i) and math.isclose(e, db_e, abs_tol=0.05): return item, None
+                    if (match_n or match_i):
                         dist = abs(e - db_e)
-                        if dist < menor_distancia:
-                            menor_distancia = dist
-                            melhor_vizinho = item
-
+                        if dist < menor_distancia: menor_distancia, melhor_vizinho = dist, item
             except: continue
-            
         return None, melhor_vizinho
 
+    def simulate_wood_scenarios(self, l, a, e, c, tipo, peso_unit):
+        """Gera 3 cenários forçando cada tamanho de madeira"""
+        scenarios = {}
+        
+        for madeira_size in MADEIRAS_PADRAO:
+            # 1. Quantas peças cabem na largura?
+            if tipo == "Redondo":
+                # Ninho: Base = madeira // diametro
+                base = int(madeira_size / l)
+            else:
+                # Grade: Colunas = madeira // largura
+                base = int(madeira_size / l)
+            
+            if base < 1:
+                scenarios[madeira_size] = None # Não cabe nem uma peça
+                continue
+
+            # 2. Calcula altura para ~1000kg
+            qtd_alvo = int(1000 / peso_unit) if peso_unit > 0 else 1
+            
+            if tipo == "Redondo":
+                # Monta ninho
+                layout = []
+                curr = 0
+                while curr < qtd_alvo:
+                    take = base if len(layout)%2==0 else base-1
+                    if (qtd_alvo - curr) < take: take = qtd_alvo - curr
+                    layout.append(take); curr += take
+                
+                pkg = self._build_pkg(l, a, e, c, tipo, 0, curr, curr*peso_unit, f"Simulação {madeira_size}", True, layout, 0, 0, False, True, 6.60)
+                # Força a madeira escolhida para visualização
+                pkg['madeira_real'] = madeira_size
+            
+            else:
+                # Monta grade
+                ga = math.ceil(qtd_alvo / base)
+                num = base * ga
+                pkg = self._build_pkg(l, a, e, c, tipo, 0, num, num*peso_unit, f"Simulação {madeira_size}", False, None, base, ga, False, True, 6.60)
+                pkg['madeira_real'] = madeira_size
+            
+            scenarios[madeira_size] = pkg
+            
+        return scenarios
+
     def calculate(self, modo, meta, l, a, e, c, tipo, acabamento, aba=0):
         l, a, e = float(l), float(a), float(e)
         is_galv = (acabamento == "Galvanizado (GI/GA)")
         wood_h = 6.60 if is_galv else 0.0
         
-        # Busca Inteligente
         item_exato, item_vizinho = self._buscar_no_banco(tipo, l, a, e)
         
-        # Física
         if tipo == "Redondo": area = math.pi * ((l/2)**2 - (l/2-e)**2)
         elif tipo == "Enrijecido": area = (l + 2*a + 2*aba - 4*e) * e
         else: area = (l + 2*a - 2*e) * e
         peso_unit = area * c * DENSIDADE_ACO
-        peso_metro = area * 1000 * DENSIDADE_ACO
 
-        # --- CENÁRIO 1: NORMA (Referência) ---
+        # --- CENÁRIO 1: NORMA ---
         pkg_norma = None
         item_ref = item_exato or item_vizinho
-        
         if item_ref:
-            origem_ref = "Catálogo (Exato)" if item_exato else "Catálogo (Vizinho Próximo)"
-            # Se for vizinho, recalculamos a quantidade baseado no peso, mas mantemos o layout
-            # Se for exato, usamos a quantidade da norma
-            
+            origem_ref = "Catálogo (Exato)" if item_exato else "Catálogo (Vizinho)"
             num_ref = item_ref['qtde']
-            
             if item_ref.get('sextavado'):
                 layout_n = self._parse_layout(item_ref['padrao'])
                 pkg_norma = self._build_pkg(l, a, e, c, tipo, aba, num_ref, num_ref*peso_unit, origem_ref, True, layout_n, 0, 0, False, is_galv, wood_h)
+            elif tipo == "Redondo":
+                gl, ga = item_ref.get('ml', 0), item_ref.get('ma', 0)
+                pkg_norma = self._build_pkg(l, a, e, c, tipo, aba, num_ref, num_ref*peso_unit, origem_ref, False, None, gl, ga, False, is_galv, wood_h)
             else:
-                # Grade
                 gl, ga = item_ref.get('ml', 0), item_ref.get('ma', 0)
                 pkg_norma = self._build_pkg(l, a, e, c, tipo, aba, num_ref, num_ref*peso_unit, origem_ref, False, None, gl, ga, False, is_galv, wood_h)
 
-        # --- CENÁRIO 2: IDEAL (Otimizado) ---
-        # Aqui aplicamos a lógica de madeira e estabilidade
+        # --- CENÁRIO 2: IDEAL (Melhor Madeira) ---
+        base_ideal = 0
+        override_base = False
         
-        # Base de cálculo: Começa pela norma se tiver, senão calcula
         target_pecas = pkg_norma['num'] if pkg_norma else int(1000/peso_unit)
         if target_pecas == 0: target_pecas = 1
 
-        # Regras de Madeira GI/GA (Prioridade sobre a norma para o Ideal)
-        base_ideal = 0
-        override_base = False
-        
         if is_galv and tipo != "Redondo":
              if e <= 1.25: base_ideal, override_base = 10, True
              elif 1.55 <= e <= 1.95: base_ideal, override_base = 8, True
 
-        # Se não tiver regra de espessura, verifica limite fisico 500mm
         if is_galv and not override_base:
-            if (math.sqrt(target_pecas) * l) > 500:
-                base_ideal = int(500 / l)
-                override_base = True
-
-        if not override_base:
-            # Sem restrição, tenta seguir a norma ou quadrado
+            # Escolhe a maior base que cabe na maior madeira (500)
+            base_ideal = int(500 / l)
+        elif not override_base:
             if pkg_norma and pkg_norma['gl'] > 0: base_ideal = pkg_norma['gl']
             else: base_ideal = int(math.sqrt(target_pecas))
         
         if base_ideal < 1: base_ideal = 1
 
-        # Montagem Ideal
         if tipo == "Redondo":
-            # Ninho sempre
-            layout_ideal = []
-            curr, cw = 0, base_ideal
+            layout_ideal, curr = [], 0
             while curr < target_pecas:
                 take = base_ideal if len(layout_ideal)%2==0 else base_ideal-1
                 if (target_pecas - curr) < take: take = target_pecas - curr
                 layout_ideal.append(take); curr += take
-            
             pkg_ideal = self._build_pkg(l, a, e, c, tipo, aba, curr, curr*peso_unit, "Ideal (Físico)", True, layout_ideal, 0, 0, False, is_galv, wood_h)
         else:
-            # Grade
             gl_ideal = base_ideal
             ga_ideal = math.ceil(target_pecas / gl_ideal)
             num_ideal = gl_ideal * ga_ideal
             pkg_ideal = self._build_pkg(l, a, e, c, tipo, aba, num_ideal, num_ideal*peso_unit, "Ideal (Físico)", False, None, gl_ideal, ga_ideal, False, is_galv, wood_h)
 
-        # Totais (Usando Ideal como base de produção)
+        # --- SIMULAÇÕES EXTRAS (Se Galv) ---
+        simulations = {}
+        if is_galv:
+            simulations = self.simulate_wood_scenarios(l, a, e, c, tipo, peso_unit)
+
+        # Totais
+        main_ref = pkg_ideal
         if modo == "Toneladas": total_pcs = int((meta*1000)/peso_unit) if peso_unit>0 else 0
         else: total_pcs = int(meta)
         
-        qtd_pcts = total_pcs // pkg_ideal['num'] if pkg_ideal['num'] > 0 else 0
-        sobra = total_pcs % pkg_ideal['num'] if pkg_ideal['num'] > 0 else 0
+        qtd_pcts = total_pcs // main_ref['num'] if main_ref['num'] > 0 else 0
+        sobra = total_pcs % main_ref['num'] if main_ref['num'] > 0 else 0
         
         sobra_pkg = None
         if sobra > 0:
-            # Gera sobra baseada no layout ideal
-            if pkg_ideal['sext']:
-                rem, s_lay = sobra, []
-                b = pkg_ideal['layout'][0] if pkg_ideal['layout'] else 5
-                while rem > 0:
-                    tk = min(rem, b if len(s_lay)%2==0 else b-1)
-                    s_lay.append(tk); rem-=tk
-                sobra_pkg = self._build_pkg(l, a, e, c, tipo, aba, sobra, sobra*peso_unit, "Sobra", True, s_lay, 0, 0, True, is_galv, wood_h)
-            else:
-                s_ga = math.ceil(sobra/pkg_ideal['gl'])
-                sobra_pkg = self._build_pkg(l, a, e, c, tipo, aba, sobra, sobra*peso_unit, "Sobra", False, None, pkg_ideal['gl'], s_ga, True, is_galv, wood_h)
+             if pkg_ideal['sext']:
+                 rem, s_lay = sobra, []
+                 b = pkg_ideal['layout'][0] if pkg_ideal['layout'] else 5
+                 while rem > 0:
+                     tk = min(rem, b if len(s_lay)%2==0 else b-1)
+                     s_lay.append(tk); rem -= tk
+                 sobra_pkg = self._build_pkg(l, a, e, c, tipo, aba, sobra, sobra*peso_unit, "Sobra", True, s_lay, 0, 0, True, is_galv, wood_h)
+             else:
+                 s_ga = math.ceil(sobra/pkg_ideal['gl'])
+                 sobra_pkg = self._build_pkg(l, a, e, c, tipo, aba, sobra, sobra*peso_unit, "Sobra", False, None, pkg_ideal['gl'], s_ga, True, is_galv, wood_h)
 
         return {
-            "norma": pkg_norma,
-            "ideal": pkg_ideal,
-            "sobra": sobra_pkg,
-            "total_pcts": qtd_pcts,
-            "peso_total": (qtd_pcts * pkg_ideal['peso']) + (sobra_pkg['peso'] if sobra_pkg else 0)
+            "norma": pkg_norma, "ideal": pkg_ideal, "sobra": sobra_pkg,
+            "simulations": simulations,
+            "total_pcts": qtd_pcts, "peso_total": (qtd_pcts * main_ref['peso']) + (sobra_pkg['peso'] if sobra_pkg else 0)
         }
 
     def _build_pkg(self, l, a, e, c, tipo, aba, num, peso, orig, sext, layout, gl, ga, is_rem, is_galv, wood_h):
@@ -245,7 +251,6 @@ class PackageCalculator:
             info["layout_str"] = f"{gl} x {ga}"
 
         info["madeira_real"] = self._escolher_madeira(info["larg_total"]) if is_galv else 0
-        
         pt = (info["larg_total"] + info["alt_total"])*2/1000
         info["fita_nome"], info["fita_tam"] = self._escolher_fita(pt)
         
@@ -254,9 +259,7 @@ class PackageCalculator:
             pm = (info["larg_total"] + info["alt_total"]/2)*2/1000
             info["fita_meio_nome"], info["fita_meio_tam"] = self._escolher_fita(pm)
             info["desc_fitas"] = "4 Fitas + 1 Meio"
-        else:
-            info["desc_fitas"] = "5 Fitas Totais"
-        
+        else: info["desc_fitas"] = "5 Fitas Totais"
         return info
 
 # ==========================================
@@ -264,7 +267,7 @@ class PackageCalculator:
 # ==========================================
 
 def plot_cross_section(info):
-    fig, ax = plt.subplots(figsize=(8, 6))
+    fig, ax = plt.subplots(figsize=(6, 5)) # Reduzi um pouco para caber 3 na tela
     l, a, e = info['l'], info['a'], info['e']
     wood_h = info['wood_h']
     is_galv = info['is_galv']
@@ -290,7 +293,7 @@ def plot_cross_section(info):
     else:
         gl, ga = info['gl'], info['ga']
         drawn = 0
-        rad = l/2; dy = l*0.866
+        rad = l/2
         for i in range(ga):
             if info['tipo']=="Redondo": y = i*(l+wood_h); cy = y + l/2
             else: y = i*(a+wood_h); tube_y = y
@@ -316,41 +319,27 @@ def plot_cross_section(info):
     ax.add_patch(patches.Rectangle((-2, -2), total_w+4, info['alt_total']+4, fill=False, ec='red', ls='--', lw=1))
     
     if not info['sext']:
-        ax.text(total_w/2, info['alt_total']+margin*0.2, f"BASE: {info['gl']}", ha='center', color='blue', weight='bold', fontsize=12)
-        ax.text(-margin*0.2, info['alt_total']/2, f"ALT: {info['ga']}", ha='right', va='center', color='blue', weight='bold', rotation=90, fontsize=12)
+        ax.text(total_w/2, info['alt_total']+margin*0.2, f"BASE: {info['gl']}", ha='center', color='blue', weight='bold', fontsize=10)
+        ax.text(-margin*0.2, info['alt_total']/2, f"ALT: {info['ga']}", ha='right', va='center', color='blue', weight='bold', rotation=90, fontsize=10)
     
-    ax.text(total_w/2, -margin/2, f"L: {total_w:.1f}mm", ha='center')
-    ax.text(-margin/2, info['alt_total']/2, f"A: {info['alt_total']:.1f}mm", ha='center', rotation=90)
-    if is_galv: ax.text(total_w/2, -margin, f"Madeira: {wood_len}mm", ha='center', color='brown', weight='bold')
+    # Se a madeira for curta, alerta
+    if is_galv and wood_len < total_w:
+         ax.text(total_w/2, info['alt_total']/2, "MADEIRA CURTA!", ha='center', color='red', weight='bold', fontsize=14, rotation=45)
 
     ax.set_xlim(-margin, total_w+margin); ax.set_ylim(-margin, info['alt_total']+margin)
     ax.set_aspect('equal'); ax.axis('off')
-    plt.title(f"{info['origem']} | {info['num']} Pçs | {info['peso']:.1f}kg", fontsize=10)
     return fig
 
 def plot_side_view(info):
     fig, ax = plt.subplots(figsize=(8, 2))
     c, h = info['c'], info['alt_total']
     ax.add_patch(patches.Rectangle((0,0), c, h, fc='lightgray', ec='black'))
-    
-    if info['is_galv']:
-        lays = info['ga'] if not info['sext'] else len(info['layout'])
-        for i in range(1, lays):
-            if info['sext']: y = i*(info['l']*0.866 + info['wood_h']) - info['wood_h']
-            else: 
-                y = i*(info['l']+info['wood_h']) - info['wood_h'] if info['tipo']=="Redondo" else i*(info['a']+info['wood_h']) - info['wood_h']
-            
-            for p in [0.1, 0.3, 0.5, 0.7, 0.9]:
-                ax.add_patch(patches.Rectangle((c*p-24, y), 48, info['wood_h'], fc='peru'))
-                
     for idx, p in enumerate([0.1, 0.3, 0.5, 0.7, 0.9]):
         col = 'orange' if (not info['is_galv'] and idx==2) else 'purple'
         ls = '--' if col=='orange' else '-'
         to_h = h/2 if col=='orange' else h
         ax.plot([c*p, c*p], [0, to_h], color=col, lw=2, ls=ls)
-
     ax.set_xlim(-c*0.05, c*1.05); ax.set_ylim(0, h*1.2); ax.axis('off')
-    plt.title("Vista Lateral", fontsize=8)
     return fig
 
 def fig_to_img(fig, w=400, h=300):
@@ -364,50 +353,25 @@ def generate_pdf(res):
     doc = SimpleDocTemplate(buffer, pagesize=letter)
     styles = getSampleStyleSheet()
     story = []
-    
-    # Pacote Ideal é o padrão de produção
     m = res['ideal']
-    
     story.append(Paragraph(f"Ficha Técnica: {m['tipo']} {m['l']}x{m['a']} #{m['e']}", styles['Title']))
     story.append(Spacer(1, 12))
-    
     acab = "Galvanizado (Com Madeira)" if m['is_galv'] else "Preto (Normal)"
     fita = f"4x {m['fita_nome']} ({m['fita_tam']}m)"
     if m['fita_meio_tam'] > 0: fita += f" + 1x {m['fita_meio_nome']} ({m['fita_meio_tam']}m)"
     else: fita = f"5x {m['fita_nome']} ({m['fita_tam']}m)"
     wood = f"{m['qtd_madeiras']} pçs (Ref: {m.get('madeira_real', 'N/A')}mm)" if m['is_galv'] else "N/A"
-
-    # Dados do Pacote Ideal
-    data = [
-        ["Item", f"{m['l']}x{m['a']} #{m['e']}mm"], 
-        ["Acabamento", acab], 
-        ["Produção", f"{res['total_pcts']} pct + {1 if res['sobra'] else 0} sobra"], 
-        ["Peso Total", f"{res['peso_total']:.2f} kg"], 
-        ["Cintas", fita], 
-        ["Madeiras", wood]
-    ]
+    data = [["Item", f"{m['l']}x{m['a']} #{m['e']}mm"], ["Acabamento", acab], ["Produção", f"{res['total_pcts']} pct + {1 if res['sobra'] else 0} sobra"], ["Peso Total", f"{res['peso_total']:.2f} kg"], ["Cintas", fita], ["Madeiras", wood]]
     t = Table(data, colWidths=[150, 300])
     t.setStyle(TableStyle([('GRID', (0,0), (-1,-1), 1, colors.black), ('BACKGROUND', (0,0), (0,-1), colors.lightgrey)]))
     story.append(t); story.append(Spacer(1, 20))
-    
-    story.append(Paragraph("Visualização Pacote Ideal (Produção)", styles['Heading2']))
+    story.append(Paragraph(f"1. Pacote Padrão ({m['num']} pçs)", styles['Heading2']))
     story.append(fig_to_img(plot_cross_section(m)))
-    story.append(fig_to_img(plot_side_view(m), h=150))
-    
-    # Comparativo com Norma (se existir)
-    if res['norma']:
-        story.append(PageBreak())
-        norma = res['norma']
-        story.append(Paragraph(f"Comparativo: Norma Técnica ({norma['origem']})", styles['Heading2']))
-        story.append(Paragraph(f"Atenção: A norma indica {norma['num']} peças, mas para segurança e estabilidade recomendamos o layout Ideal.", styles['Normal']))
-        story.append(Spacer(1, 10))
-        story.append(fig_to_img(plot_cross_section(norma)))
-
+    story.append(fig_to_img(plot_side_view(m)))
     if res['sobra']:
         story.append(PageBreak())
-        story.append(Paragraph(f"Pacote de Sobra ({res['sobra']['num']} pçs)", styles['Heading2']))
+        story.append(Paragraph(f"2. Pacote de Sobra ({res['sobra']['num']} pçs)", styles['Heading2']))
         story.append(fig_to_img(plot_cross_section(res['sobra'])))
-
     doc.build(story)
     buffer.seek(0)
     return buffer
@@ -424,7 +388,7 @@ def generate_csv(res):
 # ==========================================
 # INTERFACE
 # ==========================================
-st.title("🏭 SGP - Gestão de Embalagem v19.0")
+st.title("🏭 SGP - Gestão de Embalagem v20.0")
 
 with st.sidebar:
     st.header("Parâmetros")
@@ -447,52 +411,47 @@ if btn:
     if tipo == "Quadrado/Retangular": t_map = "Quadrado/Retangular"
     res = calc.calculate(modo, meta, l, a, e, c, t_map, acabamento, aba)
     
+    # 1. Se tiver Norma, avisa
     if res['norma']:
-        st.info("ℹ️ Item de Norma encontrado! Exibindo versão Ideal e Norma.")
-        t1, t2, t3 = st.tabs(["✨ Ideal (Físico)", "📋 Norma (Tabela)", "📄 Downloads"])
-        with t2:
-            m = res['norma']
-            st.write(f"**Norma:** {m['num']} peças | {m['peso']:.1f}kg")
-            c1, c2 = st.columns([1,1])
-            with c1: st.pyplot(plot_cross_section(m))
-            with c2: st.pyplot(plot_side_view(m))
-    else:
-        t1, t3 = st.tabs(["✨ Ideal (Calculado)", "📄 Downloads"])
-    
-    with t1:
-        m = res['ideal']
-        k1, k2, k3, k4 = st.columns(4)
-        k1.metric("Pacotes", res['total_pcts'])
-        k2.metric("Pçs/Pct", m['num'])
-        k3.metric("Peso", f"{m['peso']:.0f}kg")
-        k4.metric("Madeiras", m['qtd_madeiras'])
+        st.info("ℹ️ Encontrado na Norma. A seguir, o cálculo Ideal (Físico).")
+
+    # 2. Painel Principal (Recomendado)
+    st.subheader("✅ Configuração Recomendada")
+    m = res['ideal']
+    k1, k2, k3, k4 = st.columns(4)
+    k1.metric("Pacotes", res['total_pcts'])
+    k2.metric("Pçs/Pct", m['num'])
+    k3.metric("Peso", f"{m['peso']:.0f}kg")
+    k4.metric("Madeira", f"{m.get('madeira_real', 0)}mm" if m['is_galv'] else "N/A")
+
+    c_main, c_side = st.columns([1,1])
+    with c_main: st.pyplot(plot_cross_section(m))
+    with c_side: 
+        st.pyplot(plot_side_view(m))
+        if res['sobra']: st.warning(f"Sobra: {res['sobra']['num']} pçs"); st.pyplot(plot_cross_section(res['sobra']))
+
+    # 3. SIMULADOR DE MADEIRAS (A Cereja do Bolo 🍒)
+    if m['is_galv']:
+        st.markdown("---")
+        st.subheader("🪵 Simulador por Tamanho de Madeira")
+        st.write("Compare como o pacote ficaria forçando cada tamanho de madeira disponível:")
         
-        c1, c2 = st.columns([1,1])
-        with c1: st.pyplot(plot_cross_section(m))
-        with c2: 
-            st.pyplot(plot_side_view(m))
-            if res['sobra']: st.warning(f"Sobra: {res['sobra']['num']} pçs"); st.pyplot(plot_cross_section(res['sobra']))
-
-    with t3:
-        st.download_button("📄 Baixar PDF (Completo)", generate_pdf(res), "relatorio.pdf", "application/pdf")
-        st.download_button("📊 Baixar CSV", generate_csv(res), "dados.csv", "text/csv")
-
-with st.expander("Admin - Catálogo"):
-    col_a, col_b = st.columns(2)
-    with col_a:
-        adm_tipo = st.selectbox("Norma", ["IT14", "IT13"])
-        adm_l = st.number_input("L", value=0.0)
-        adm_a = st.number_input("A", value=0.0, disabled=(adm_tipo=="IT13"))
-        adm_e = st.number_input("E", value=0.0)
-    with col_b:
-        adm_qtde = st.number_input("Qtd", value=0)
-        adm_peso = st.number_input("Peso", value=0.0)
-        adm_ml = st.number_input("Colunas", value=0)
-        adm_ma = st.number_input("Linhas", value=0)
-    if st.button("Salvar"):
-        new = {"ml": int(adm_ml), "ma": int(adm_ma), "qtde": int(adm_qtde), "peso": float(adm_peso)}
-        key = f"{adm_l:.2f}_{adm_e:.2f}" if adm_tipo == "IT13" else f"{adm_l:.2f}_{adm_a:.2f}_{adm_e:.2f}"
-        if adm_tipo == "IT13": new["tipo"] = "Redondo"
-        DB[adm_tipo][key] = new
-        save_db(DB)
-        st.success("Salvo!")
+        cols = st.columns(3)
+        sims = res['simulations']
+        
+        for i, mad_size in enumerate(MADEIRAS_PADRAO):
+            with cols[i]:
+                st.markdown(f"### Madeira {mad_size}mm")
+                scenario = sims.get(mad_size)
+                
+                if scenario:
+                    st.caption(f"{scenario['num']} Pçs | {scenario['peso']:.0f}kg | {scenario['gl']}x{scenario['ga']}")
+                    st.pyplot(plot_cross_section(scenario))
+                else:
+                    st.error("❌ Não cabe (Peça maior que a madeira)")
+
+    # 4. Downloads
+    st.markdown("---")
+    c1, c2 = st.columns(2)
+    c1.download_button("📄 PDF Relatório", generate_pdf(res), "relatorio.pdf", "application/pdf")
+    c2.download_button("📊 CSV Dados", generate_csv(res), "dados.csv", "text/csv")