Update app.py

app.py

@@ -12,25 +12,13 @@ from reportlab.lib import colors
 from reportlab.lib.pagesizes import letter
 
 # ==========================================
-# 1. CONFIGURAÇÕES E CONSTANTES
+# CONFIGURAÇÃO GERAL
 # ==========================================
-st.set_page_config(page_title="SGP - Gestão de Embalagem v13.1", layout="wide", page_icon="🏭")
+st.set_page_config(page_title="SGP - Gestão de Embalagem v12.1", layout="wide", page_icon="🏭")
 
-# Configurações de Negócio
 PESO_IDEAL_MIN = 970
 PESO_IDEAL_MAX = 1080
 PESO_LIMITE_SEGURANCA = 1200
-DENSIDADE_ACO = 7.85e-6
-
-# Tolerâncias e Margens
-TOLERANCIA_DIMENSAO = 0.1     # mm (para match exato)
-TOLERANCIA_BUSCA_GEO = 5.0    # mm (para busca por similaridade)
-MARGEM_FITA = 1.10            # 10% de margem para fita
-
-# Dimensões de Insumos
-MADEIRA_H = 6.60
-MADEIRA_W = 48.20
-MADEIRAS_PADRAO = [370, 400, 500]
 
 FITAS = [
     {"nome": "Fita 1.20", "tamanho": 1.20}, {"nome": "Fita 1.40", "tamanho": 1.40},
@@ -41,233 +29,196 @@ FITAS = [
     {"nome": "Fita 3.50", "tamanho": 3.50}, {"nome": "Fita 4.00", "tamanho": 4.00}
 ]
 
+MADEIRAS_PADRAO = [370, 400, 500, 600, 800, 1000]
+
 DB_FILE = 'catalogo.json'
 
-# ==========================================
-# 2. GERENCIAMENTO DE DADOS
-# ==========================================
 @st.cache_data
-def load_db() -> dict:
-    if not os.path.exists(DB_FILE):
-        return {"IT13": {}, "IT14": {}}
-    try:
-        with open(DB_FILE, 'r') as f:
-            return json.load(f)
-    except json.JSONDecodeError:
-        st.error("Erro: O arquivo catalogo.json está corrompido.")
-        return {"IT13": {}, "IT14": {}}
-    except Exception as e:
-        st.error(f"Erro desconhecido ao carregar DB: {e}")
-        return {"IT13": {}, "IT14": {}}
-
-def save_db(new_db: dict):
+def load_db():
+    if not os.path.exists(DB_FILE): return {"IT13": {}, "IT14": {}}
     try:
-        with open(DB_FILE, 'w') as f:
-            json.dump(new_db, f, indent=4)
-        st.cache_data.clear()
-    except Exception as e:
-        st.error(f"Erro ao salvar DB: {e}")
+        with open(DB_FILE, 'r') as f: return json.load(f)
+    except: return {"IT13": {}, "IT14": {}}
+
+def save_db(new_db):
+    with open(DB_FILE, 'w') as f: json.dump(new_db, f, indent=4)
+    st.cache_data.clear()
 
 DB = load_db()
 
 # ==========================================
-# 3. MOTOR DE CÁLCULO (REFATORADO)
+# LÓGICA DE CÁLCULO
 # ==========================================
 
 class PackageCalculator:
-    def _parse_layout(self, layout_str: str) -> list:
+    def _parse_layout(self, layout_str):
         try:
             return [int(x) for x in layout_str.split('-') if x.strip().isdigit()]
         except:
             return []
 
-    def _validar_inputs(self, l: float, a: float, e: float, c: float, tipo: str) -> list:
-        """Valida inputs e retorna lista de erros."""
-        erros = []
-        if l <= 0 or e <= 0 or c <= 0:
-            erros.append("Dimensões devem ser positivas")
-        if tipo != "Redondo" and a <= 0:
-            erros.append("Altura deve ser positiva para perfis não-redondos")
-        if tipo == "Redondo" and e >= l/2:
-            erros.append("Espessura não pode ser maior ou igual ao raio")
-        return erros
-
-    def _get_physical_props(self, tipo: str, l: float, a: float, e: float, c: float, aba: float = 0) -> tuple:
-        """Calcula Área da Seção e Peso Unitário de forma centralizada."""
-        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:  # Quadrado/Retangular
-            area = (l + 2*a - 2*e) * e
-        
-        peso_unitario = area * c * DENSIDADE_ACO
-        return area, peso_unitario
-
-    def _find_smart_neighbor(self, tipo: str, l: float, a: float, e: float):
-        """Busca inteligente com tolerâncias definidas."""
+    def _find_smart_neighbor(self, tipo, l, a, e):
         best_item = None
-        min_diff_thickness = float('inf')
-        min_dist_geo = float('inf')
+        min_diff = float('inf')
         target_db = DB["IT13"] if tipo == "Redondo" else DB["IT14"]
         
         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]
-                    # Prioridade 1: Mesmo Diâmetro (Tolerância definida)
-                    if abs(l - db_l) < TOLERANCIA_DIMENSAO: 
-                        diff_e = abs(e - db_e)
-                        if diff_e < min_diff_thickness:
-                            min_diff_thickness = diff_e
-                            best_item = item
-                    # Prioridade 2: Geometria próxima
-                    elif min_diff_thickness == float('inf'):
-                        dist = math.sqrt((l - db_l)**2 + (e - db_e)**2)
-                        if dist < min_dist_geo and dist < TOLERANCIA_BUSCA_GEO:
-                            min_dist_geo = dist
+                    # Mesmo diametro, espessura diferente
+                    if abs(l - parts[0]) < 0.1:
+                        diff = abs(e - parts[1])
+                        if diff < min_diff:
+                            min_diff = diff
                             best_item = item
                 else:
-                    db_l, db_a, db_e = parts[0], parts[1], parts[2]
-                    is_same_dims = (abs(l - db_l) < TOLERANCIA_DIMENSAO and abs(a - db_a) < TOLERANCIA_DIMENSAO) or \
-                                   (abs(l - db_a) < TOLERANCIA_DIMENSAO and abs(a - db_l) < TOLERANCIA_DIMENSAO)
-                    if is_same_dims:
-                        diff_e = abs(e - db_e)
-                        if diff_e < min_diff_thickness:
-                            min_diff_thickness = diff_e
-                            best_item = item
-                    elif min_diff_thickness == float('inf'):
-                        dist = math.sqrt((l - db_l)**2 + (a - db_a)**2)
-                        if dist < min_dist_geo and dist < (TOLERANCIA_BUSCA_GEO * 2): # Tolerância maior para retangulos
-                            min_dist_geo = dist
+                    # Mesma geometria
+                    if (abs(l - parts[0]) < 0.1 and abs(a - parts[1]) < 0.1) or \
+                       (abs(l - parts[1]) < 0.1 and abs(a - parts[0]) < 0.1):
+                        diff = abs(e - parts[2])
+                        if diff < min_diff:
+                            min_diff = diff
                             best_item = item
-            except:
-                continue
+            except: continue
         return best_item
 
-    def _apply_giga_rules(self, is_galv: bool, tipo: str, e: float):
-        if is_galv and tipo != "Redondo":
-            if e <= 1.25:
-                return 10, "Regra GI/GA (<=1.25mm)"
-            elif 1.55 <= e <= 1.95:
-                return 8, "Regra GI/GA (1.55-1.95mm)"
-        return 0, ""
-
-    def _resolve_layout(self, item, tipo, peso_unit):
-        """Define a geometria do pacote."""
-        layout = None
-        is_sext = False
-        gl, ga = 0, 0
-        num_pecas = 0
-        layout_str = ""
+    def _escolher_fita(self, perimetro_m):
+        perimetro_com_margem = perimetro_m * 1.10 
+        for f in FITAS:
+            if f["tamanho"] >= perimetro_com_margem:
+                return f["nome"], f["tamanho"], perimetro_com_margem
+        return "Sob Medida", perimetro_com_margem, perimetro_com_margem
 
-        if item:
-            num_pecas = item['qtde']
-            
-            if item.get('sextavado') and 'padrao' in item:
-                layout = self._parse_layout(item.get('padrao', ''))
-                is_sext, gl, ga = True, 0, len(layout)
-                layout_str = item.get('padrao', '')
-            
-            elif tipo == "Redondo":
-                # Conversão Grade -> Ninho
-                base_width = item.get('ml', 0)
-                if base_width == 0: base_width = int(math.sqrt(num_pecas))
-                layout = []
-                rem = num_pecas
-                curr_w = base_width
-                while rem > 0:
-                    take = min(rem, curr_w)
-                    layout.append(take)
-                    rem -= take
-                    curr_w = base_width - 1 if curr_w == base_width else base_width
-                is_sext, gl, ga = True, 0, len(layout)
-                layout_str = "-".join(map(str, layout))
-            
-            else:
-                is_sext, gl, ga = False, item.get('ml', 0), item.get('ma', 0)
-        
-        else:
-            # Matemático
-            peso_alvo = 1000
-            num_pecas = int(peso_alvo / peso_unit) if peso_unit > 0 else 1
-            
-            if tipo == "Redondo":
-                side = int(math.sqrt(num_pecas/3))
-                base = side + 2
-                layout = []
-                curr = 0
-                for i in range(50):
-                    cols = base if i%2==0 else base-1
-                    layout.append(cols); curr+=cols
-                    if curr>=num_pecas: num_pecas=curr; break
-                is_sext, gl, ga = True, 0, len(layout)
-                layout_str = "-".join(map(str, layout))
-            else:
-                is_sext, gl, ga = False, int(math.sqrt(num_pecas)), 0
-                if gl > 0: ga = math.ceil(num_pecas/gl)
-                else: gl, ga = 1, 1
-        
-        return num_pecas, layout, is_sext, gl, ga, layout_str
+    def _escolher_madeira(self, largura_pacote_mm):
+        for m in MADEIRAS_PADRAO:
+            if m >= largura_pacote_mm: return m
+        return MADEIRAS_PADRAO[-1] 
 
     def calculate(self, modo, meta, l, a, e, c, tipo, acabamento, aba=0):
-        # 1. Validação
-        if erros := self._validar_inputs(l, a, e, c, tipo):
-            return {"erro": f"Entrada Inválida: {', '.join(erros)}"}
-
-        # 2. Normalização e Chaves
         l, a, e = float(l), float(a), float(e)
         is_galv = (acabamento == "Galvanizado (GI/GA)")
-        wood_h = MADEIRA_H if is_galv else 0.0
-        
+        wood_h = 6.60 if is_galv else 0.0
+        wood_w = 48.20 
+
         key_red = f"{l:.2f}_{e:.2f}"
         key_met = f"{l:.2f}_{a:.2f}_{e:.2f}"
         key_met_inv = f"{a:.2f}_{l:.2f}_{e:.2f}"
-        
+
         item = None
         if tipo == "Redondo":
             item = DB["IT13"].get(key_red)
         else:
             item = DB["IT14"].get(key_met) or DB["IT14"].get(key_met_inv)
 
-        # 3. Propriedades Físicas
-        area, peso_unit = self._get_physical_props(tipo, l, a, e, c, aba)
+        densidade = 7.85e-6
+        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
 
-        # 4. Decisão de Estrutura (Fluxo Corrigido)
-        forced_gl, rule_origem = self._apply_giga_rules(is_galv, tipo, e)
-        
+        override_rule = False
+        gl, ga = 0, 0
+        is_sext = False
+        layout = None
         origem = ""
-        
-        if forced_gl > 0:
-            # Prioridade Máxima: Regra GI/GA
-            origem = rule_origem
-            gl = forced_gl
-            target_weight = 1000
-            total_pcs_pkg = int(target_weight / peso_unit) if peso_unit > 0 else 1
-            ga = math.ceil(total_pcs_pkg / gl)
-            num_pecas = gl * ga
-            is_sext = False
-            layout = None
-            layout_str = ""
-        else:
-            # Fluxo Padrão
+        layout_str = ""
+
+        # Regra GI/GA
+        if is_galv and tipo != "Redondo":
+            forced_gl = 0
+            if e <= 1.25: forced_gl = 10; origem = "Regra GI/GA (<=1.25mm)"
+            elif 1.55 <= e <= 1.95: forced_gl = 8; origem = "Regra GI/GA (1.55-1.95mm)"
+            
+            if forced_gl > 0:
+                override_rule = True
+                gl = forced_gl
+                target_weight = 1000
+                total_pcs_pkg = int(target_weight / peso_unit) if peso_unit > 0 else 1
+                ga = math.ceil(total_pcs_pkg / gl)
+                num_pecas = gl * ga
+                is_sext = False
+
+        if not override_rule:
             if item:
                 origem = "Catálogo (Norma)"
+                num_pecas = item['qtde']
+                
+                # --- CORREÇÃO CRÍTICA AQUI ---
+                # Verifica se é um Redondo que se comporta como GRADE (Retangular)
+                # Ex: 25.40 -> ml=15, ma=16, total=240. 15*16 = 240. Isso é grade.
+                is_grid_match = False
+                if item.get('ml') and item.get('ma'):
+                    if item['ml'] * item['ma'] == item['qtde']:
+                        is_grid_match = True
+
+                if item.get('sextavado') and 'padrao' in item:
+                    # Sextavado Explicito
+                    layout = self._parse_layout(item.get('padrao', ''))
+                    is_sext, gl, ga = True, 0, len(layout)
+                    layout_str = item.get('padrao', '')
+                elif tipo == "Redondo" and not is_grid_match:
+                    # Redondo Sem Grade Definida -> Força Ninho
+                    base_width = item.get('ml', 0)
+                    if base_width == 0: base_width = int(math.sqrt(num_pecas))
+                    layout = []
+                    rem = num_pecas
+                    curr_w = base_width
+                    while rem > 0:
+                        take = min(rem, curr_w)
+                        layout.append(take)
+                        rem -= take
+                        curr_w = base_width - 1 if curr_w == base_width else base_width
+                    is_sext, gl, ga = True, 0, len(layout)
+                    layout_str = "-".join(map(str, layout))
+                else:
+                    # É Metalon ou Redondo com Grade Definida (240 pçs = 15x16)
+                    layout = None
+                    is_sext = False
+                    gl, ga = item.get('ml', 0), item.get('ma', 0)
+            
             else:
-                # Tenta encontrar vizinho
-                item = self._find_smart_neighbor(tipo, l, a, e)
-                if item:
+                # Fallback Engenharia
+                # Tenta vizinho primeiro
+                neighbor = self._find_smart_neighbor(tipo, l, a, e)
+                if neighbor:
                     origem = "Engenharia (Similar)"
+                    # Copia estrutura do vizinho
+                    if neighbor.get('sextavado'):
+                         layout = self._parse_layout(neighbor.get('padrao', ''))
+                         is_sext, gl, ga = True, 0, len(layout)
+                         num_pecas = sum(layout)
+                    else:
+                         is_sext = False
+                         gl, ga = neighbor.get('ml', 0), neighbor.get('ma', 0)
+                         num_pecas = gl * ga
                 else:
-                    origem = "Engenharia (Cálculo Matemático)"
-
-            # Resolve layout com o item encontrado (seja exato ou vizinho) ou None (para matemático)
-            num_pecas, layout, is_sext, gl, ga, layout_str = self._resolve_layout(item, tipo, peso_unit)
+                    # Calculo Puro
+                    origem = "Engenharia (Cálculo)"
+                    peso_alvo = 1000
+                    num_pecas = int(peso_alvo / peso_unit) if peso_unit > 0 else 1
+                    
+                    if tipo == "Redondo":
+                        # Redondo calculado sempre sugere Ninho para segurança
+                        side = int(math.sqrt(num_pecas/3))
+                        base = side + 2
+                        layout = []
+                        curr = 0
+                        for i in range(50):
+                            cols = base if i%2==0 else base-1
+                            layout.append(cols); curr+=cols
+                            if curr>=num_pecas: num_pecas=curr; break
+                        is_sext, gl, ga = True, 0, len(layout)
+                    else:
+                        is_sext = False
+                        gl = int(math.sqrt(num_pecas))
+                        ga = math.ceil(num_pecas/gl) if gl>0 else 1
 
         peso_pct = num_pecas * peso_unit
 
-        # 5. Totais
         if modo == "Toneladas":
             total_pcs = int((meta * 1000) / peso_unit) if peso_unit > 0 else 0
         else:
@@ -276,8 +227,7 @@ class PackageCalculator:
         qtd_pcts = total_pcs // num_pecas if num_pecas > 0 else 0
         sobra = total_pcs % num_pecas
 
-        # 6. Construção dos Objetos
-        main_pkg = self._build_pkg_obj(l, a, e, c, tipo, aba, num_pecas, peso_pct, origem, is_sext, layout, gl, ga, False, is_galv, wood_h, layout_str)
+        main = self._build_pkg(l, a, e, c, tipo, aba, num_pecas, peso_pct, origem, is_sext, layout, gl, ga, False, is_galv, wood_h, wood_w, layout_str)
         
         sobra_pkg = None
         if sobra > 0:
@@ -288,17 +238,17 @@ class PackageCalculator:
                     cols = base if k%2==0 else base-1
                     take = min(rem, cols); s_layout.append(take); rem-=take
                     if rem<=0: break
-                sobra_pkg = self._build_pkg_obj(l, a, e, c, tipo, aba, sobra, sobra*peso_unit, "Sobra", True, s_layout, 0, len(s_layout), True, is_galv, wood_h, "Sobra")
+                sobra_pkg = self._build_pkg(l, a, e, c, tipo, aba, sobra, sobra*peso_unit, "Sobra", True, s_layout, 0, len(s_layout), True, is_galv, wood_h, "Sobra")
             else:
                 s_ga = math.ceil(sobra / gl) if gl>0 else 1
-                sobra_pkg = self._build_pkg_obj(l, a, e, c, tipo, aba, sobra, sobra*peso_unit, "Sobra", False, None, gl, s_ga, True, is_galv, wood_h, "")
+                sobra_pkg = self._build_pkg(l, a, e, c, tipo, aba, sobra, sobra*peso_unit, "Sobra", False, None, gl, s_ga, True, is_galv, wood_h, "")
 
         return {
-            "main": main_pkg, "sobra": sobra_pkg,
+            "main": main, "sobra": sobra_pkg,
             "total_pcts": qtd_pcts, "peso_total": (qtd_pcts * peso_pct) + (sobra_pkg['peso'] if sobra_pkg else 0)
         }
 
-    def _build_pkg_obj(self, l, a, e, c, tipo, aba, num, peso, orig, sext, layout, gl, ga, is_rem, is_galv, wood_h, layout_str):
+    def _build_pkg(self, l, a, e, c, tipo, aba, num, peso, orig, sext, layout, gl, ga, is_rem, is_galv, wood_h, layout_str):
         info = {
             "l": l, "a": a, "e": e, "c": c, "tipo": tipo, "aba": aba,
             "num": num, "peso": peso, "origem": orig, 
@@ -307,66 +257,56 @@ class PackageCalculator:
             "layout_str": layout_str
         }
         
-        # Dimensões e Madeiras
+        qtd_madeiras = 0
         if sext:
             rows = layout or []
             max_c = max(rows) if rows else 1
             info["larg_total"] = max_c * l
             h_geo = l + (len(rows) - 1) * l * math.sin(math.radians(60))
             if is_galv:
-                camadas_mad = max(0, len(rows) - 1)
-                info["alt_total"] = h_geo + (camadas_mad * wood_h)
-                info["qtd_madeiras"] = camadas_mad * 5
+                camadas_madeira = max(0, len(rows) - 1)
+                h_wood = camadas_madeira * wood_h 
+                qtd_madeiras = camadas_madeira * 5
             else:
-                info["alt_total"] = h_geo
-                info["qtd_madeiras"] = 0
+                h_wood = 0
+            info["alt_total"] = h_geo + h_wood
         else:
+            # Grade (Retangular)
             info["larg_total"] = gl * l
             if tipo == "Enrijecido": info["larg_total"] += aba
             
-            h_base = ga * a
-            # Correção Redondo em Grade (Encaixe)
-            if tipo == "Redondo":
-                h_base = l + (ga - 1) * l * math.sin(math.radians(60))
+            # Altura: Se for Redondo em Grade, ele fica um sobre o outro (altura = N * diam)
+            # Pois "Embalagem Retangular" sugere alinhamento
+            h_base = ga * a if tipo != "Redondo" else ga * l
 
             if is_galv:
-                camadas_mad = max(0, ga - 1)
-                info["alt_total"] = h_base + (camadas_mad * wood_h)
-                info["qtd_madeiras"] = camadas_mad * 5
+                camadas_madeira = max(0, ga - 1)
+                h_wood = camadas_madeira * wood_h 
+                qtd_madeiras = camadas_madeira * 5
             else:
-                info["alt_total"] = h_base
-                info["qtd_madeiras"] = 0
+                h_wood = 0
+            info["alt_total"] = h_base + h_wood
 
-        # Escolha Madeira Real (apenas se galv)
         if is_galv:
-            for m in MADEIRAS_PADRAO:
-                if m >= info["larg_total"]:
-                    info["madeira_real"] = m
-                    break
-            else:
-                info["madeira_real"] = MADEIRAS_PADRAO[-1]
+            info["madeira_comprimento_real"] = self._escolher_madeira(info["larg_total"])
         else:
-            info["madeira_real"] = 0
+            info["madeira_comprimento_real"] = 0
 
-        # Fitas
-        perim = (info["larg_total"] + info["alt_total"]) * 2 / 1000
-        for f in FITAS:
-            if f["tamanho"] >= perim * MARGEM_FITA:
-                info["fita_nome"] = f["nome"]
-                info["fita_tam"] = f["tamanho"]
-                break
-        else:
-            info["fita_nome"], info["fita_tam"] = "Sob Medida", perim * MARGEM_FITA
+        info["qtd_madeiras"] = qtd_madeiras
 
-        # Fita Meio
-        info["fita_meio_nome"], info["fita_meio_tam"] = "N/A", 0
+        perim_total = (info["larg_total"] + info["alt_total"]) * 2 / 1000
+        nome_fita, tam_fita, real_fita = self._escolher_fita(perim_total)
+        info["fita_nome"] = nome_fita
+        info["fita_tamanho"] = tam_fita
+
+        info["fita_meio_nome"] = "N/A"
+        info["fita_meio_tamanho"] = 0
+        
         if not is_galv:
-            p_meio = (info["larg_total"] + (info["alt_total"]/2)) * 2 / 1000
-            for f in FITAS:
-                if f["tamanho"] >= p_meio * MARGEM_FITA:
-                    info["fita_meio_nome"] = f["nome"]
-                    info["fita_meio_tam"] = f["tamanho"]
-                    break
+            perim_meio = (info["larg_total"] + (info["alt_total"] / 2)) * 2 / 1000
+            n_meio, t_meio, r_meio = self._escolher_fita(perim_meio)
+            info["fita_meio_nome"] = n_meio
+            info["fita_meio_tamanho"] = t_meio
             info["desc_fitas"] = "4 Fitas Totais + 1 Fita Meio"
         else:
             info["desc_fitas"] = "5 Fitas Totais (Pacote Completo)"
@@ -374,21 +314,22 @@ class PackageCalculator:
         return info
 
 # ==========================================
-# 4. VISUALIZAÇÃO E GRÁFICOS
+# VISUALIZAÇÃO
 # ==========================================
 
 def plot_cross_section(info):
     fig, ax = plt.subplots(figsize=(10, 8))
     l, a, e = info['l'], info['a'], info['e']
-    wood_h = info['wood_h']
+    wood_h, wood_w = info['wood_h'], info['wood_w']
     is_galv = info['is_galv']
-    wood_len = info.get("madeira_real", 0)
+    wood_len = info.get("madeira_comprimento_real", 0)
     
     fc = 'lightblue' if not info['is_rem'] else 'lightcoral'
     ec = 'black'
     total_w_pkg = info['larg_total']
     
     if info['sext']:
+        # SEXTAVADO
         rows = info['layout']
         radius = l / 2
         dy = l * 0.866
@@ -398,48 +339,50 @@ def plot_cross_section(info):
             y_base = radius + i * dy + (i * wood_h)
             if is_galv and i > 0:
                 wy = y_base - radius - wood_h
-                wood_x = (total_w_pkg - wood_len) / 2
-                ax.add_patch(patches.Rectangle((wood_x, wy), wood_len, wood_h, fc='peru', ec='brown'))
+                wood_x_start = (total_w_pkg - wood_len) / 2
+                ax.add_patch(patches.Rectangle((wood_x_start, wy), wood_len, wood_h, fc='peru', ec='brown'))
             for k in range(count):
                 cx = x0 + k * l + radius
                 ax.add_patch(patches.Circle((cx, y_base), radius, fc=fc, ec=ec))
                 ax.add_patch(patches.Circle((cx, y_base), radius-e, fc='white', ec=ec, lw=0.5))
     else:
+        # GRADE RETANGULAR (Corrigido para alinhar Redondo)
         gl, ga = info['gl'], info['ga']
         drawn = 0
-        radius = l / 2
-        dy = l * 0.866 
+        
         for i in range(ga):
+            # Cálculo de Y (Baseado na camada)
             if info['tipo'] == "Redondo":
-                y = radius + i * dy + (i * wood_h)
+                y = i * (l + wood_h)
+                # Centro do círculo será y + raio
+                cy = y + (l/2)
             else:
                 y = i * (a + wood_h)
-            if is_galv and i > 0: 
-                wy = y - radius - wood_h if info['tipo'] == "Redondo" else y - wood_h
-                wood_x = (total_w_pkg - wood_len) / 2
-                ax.add_patch(patches.Rectangle((wood_x, wy), wood_len, wood_h, fc='peru', ec='brown'))
-                tube_y = y + wood_h if info['tipo'] != "Redondo" else y
-            else:
-                tube_y = y
+                cy = y # Metalon desenha do canto
+            
+            # Madeira
+            if is_galv and i > 0:
+                wy = y - wood_h
+                wood_x_start = (total_w_pkg - wood_len) / 2
+                ax.add_patch(patches.Rectangle((wood_x_start, wy), wood_len, wood_h, fc='peru', ec='brown'))
 
             for j in range(gl):
                 if drawn >= info['num']: break
+                
+                x = j * l
                 if info['tipo'] == "Redondo":
-                    if i % 2 == 0: x = j * l
-                    else: x = j * l + radius
-                    cx = x + radius
-                    cy = y 
-                    ax.add_patch(patches.Circle((cx, cy), radius, fc=fc, ec=ec))
-                    ax.add_patch(patches.Circle((cx, cy), radius-e, fc='white', ec=ec, lw=0.5))
+                    # Redondo em Grade -> Um sobre o outro (alinhado)
+                    cx = x + (l/2)
+                    ax.add_patch(patches.Circle((cx, cy), l/2, fc=fc, ec=ec))
+                    ax.add_patch(patches.Circle((cx, cy), (l/2)-e, fc='white', ec=ec, lw=0.5))
                 else:
-                    x = j * l
                     if info['tipo'] == "Enrijecido":
-                        ax.add_patch(patches.Rectangle((x, tube_y), l, a, fc='lightcyan', ec=ec))
-                        ax.add_patch(patches.Rectangle((x+e, tube_y+a/2), info['aba'], e, fc='gray'))
+                        ax.add_patch(patches.Rectangle((x, y), l, a, fc='lightcyan', ec=ec))
+                        ax.add_patch(patches.Rectangle((x+e, y+a/2), info['aba'], e, fc='gray'))
                     else:
-                        ax.add_patch(patches.Rectangle((x, tube_y), l, a, fc=fc, ec=ec))
+                        ax.add_patch(patches.Rectangle((x, y), l, a, fc=fc, ec=ec))
                         inset = min(l, a)*0.1
-                        ax.add_patch(patches.Rectangle((x+inset, tube_y+inset), l-2*inset, a-2*inset, fc='white', ec=ec, lw=0.5))
+                        ax.add_patch(patches.Rectangle((x+inset, y+inset), l-2*inset, a-2*inset, fc='white', ec=ec, lw=0.5))
                 drawn += 1
 
     L_tot, A_tot = info['larg_total'], info['alt_total']
@@ -449,13 +392,13 @@ def plot_cross_section(info):
     ax.add_patch(patches.Rectangle((-2, -2), L_tot+4, A_tot+4, fill=False, ec='red', ls='--', lw=1.5, label='Limite'))
     
     if not info['sext']:
-        ax.text(L_tot/2, A_tot+margin*0.1, f"BASE: {info['gl']} PEÇAS", ha='center', va='bottom', color='blue', fontweight='bold', bbox=dict(facecolor='white', ec='blue', boxstyle='round,pad=0.2'))
-        ax.text(-margin*0.1, A_tot/2, f"ALTURA: {info['ga']} CAMADAS", ha='right', va='center', color='blue', fontweight='bold', rotation=90, bbox=dict(facecolor='white', ec='blue', boxstyle='round,pad=0.2'))
+        ax.text(L_tot/2, A_tot + margin*0.1, f"BASE: {info['gl']} PEÇAS", ha='center', va='bottom', fontweight='bold', color='blue', fontsize=12, bbox=dict(facecolor='white', edgecolor='blue', boxstyle='round,pad=0.3'))
+        ax.text(-margin*0.1, A_tot/2, f"ALTURA: {info['ga']} CAMADAS", ha='right', va='center', fontweight='bold', color='blue', fontsize=12, rotation=90, bbox=dict(facecolor='white', edgecolor='blue', boxstyle='round,pad=0.3'))
     else:
         txt = info.get('layout_str') or f"Sextavado ({len(info['layout'])} camadas)"
-        ax.text(L_tot/2, A_tot+margin*0.1, txt, ha='center', va='bottom', color='green', fontweight='bold', bbox=dict(facecolor='white', ec='green', boxstyle='round,pad=0.2'))
+        ax.text(L_tot/2, A_tot + margin*0.1, txt, ha='center', va='bottom', color='green', fontweight='bold', bbox=dict(facecolor='white', ec='green', boxstyle='round,pad=0.2'))
 
-    ax.text(L_tot/2, -margin/2, f"L: {L_tot:.1f} mm", ha='center', va='center', fontweight='bold')
+    ax.text(L_tot/2, -margin/2, f"L Tubos: {L_tot:.1f} mm", ha='center', va='center', fontweight='bold')
     ax.text(-margin/2, A_tot/2, f"A: {A_tot:.1f} mm", ha='center', va='center', fontweight='bold', rotation=90)
     
     if is_galv:
@@ -479,24 +422,29 @@ def plot_side_view(info):
     
     if is_galv:
         layers = info['ga'] if not info['sext'] else len(info['layout'])
-        pos_wood = [0.1, 0.3, 0.5, 0.7, 0.9]
+        positions_wood = [0.1, 0.3, 0.5, 0.7, 0.9]
         for i in range(1, layers):
-            if info['sext'] or info['tipo'] == "Redondo":
-                rad = info['l']/2
-                y_wood = (rad + i*info['l']*0.866 + i*wood_h) - rad - wood_h
+            if info['sext']:
+                radius = info['l'] / 2
+                dy = info['l'] * 0.866
+                y_wood = (radius + i * dy + (i * wood_h)) - radius - wood_h
             else:
-                y_wood = i*(info['a'] + wood_h) - wood_h
-            
-            for p in pos_wood:
-                ax.add_patch(patches.Rectangle((c*p - wood_w/2, y_wood), wood_w, wood_h, fc='peru', ec='brown'))
+                # Grade
+                y_wood = i * (info['a'] + wood_h) - wood_h
+                if info['tipo'] == "Redondo": # Redondo grade tem altura D
+                    y_wood = i * (info['l'] + wood_h) - wood_h
+
+            for p in positions_wood:
+                wx = (c * p) - (wood_w / 2)
+                ax.add_patch(patches.Rectangle((wx, y_wood), wood_w, wood_h, fc='peru', ec='brown'))
 
-    pos_fita = [0.1, 0.3, 0.5, 0.7, 0.9]
-    for idx, p in enumerate(pos_fita):
+    positions_fita = [0.1, 0.3, 0.5, 0.7, 0.9]
+    for idx, p in enumerate(positions_fita):
         x = c * p
         if not is_galv and idx == 2:
-             ax.plot([x, x], [0, h/2], color='orange', lw=3, ls='--')
+            ax.plot([x, x], [0, h/2], color='orange', lw=3, ls='--')
         else:
-             ax.plot([x, x], [0, h], color='purple', lw=3)
+            ax.plot([x, x], [0, h], color='purple', lw=3)
 
     ax.text(c/2, -h*0.2, f"Comp: {c:.0f} mm", ha='center', va='top', fontweight='bold')
     ax.set_xlim(-c*0.05, c*1.05); ax.set_ylim(-h*0.3, h*1.1); ax.axis('off')
@@ -518,10 +466,10 @@ def generate_pdf(res):
     story.append(Paragraph(f"Ficha: {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 (48.2x6.6mm) | Ref: {m.get('madeira_real', 'N/A')}mm" if m['is_galv'] else "N/A"
+    fita = f"4x {m['fita_nome']} ({m['fita_tamanho']}m)"
+    if m['fita_meio_tamanho'] > 0: fita += f" + 1x {m['fita_meio_nome']} ({m['fita_meio_tamanho']}m)"
+    else: fita = f"5x {m['fita_nome']} ({m['fita_tamanho']}m)"
+    wood = f"{m['qtd_madeiras']} pçs (48.2x6.6mm) | Ref: {m.get('madeira_comprimento_real', 'N/A')}mm" if m['is_galv'] else "N/A"
     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)]))
@@ -543,62 +491,51 @@ def generate_csv(res):
     m = res['main']
     writer.writerow(["Tipo", "L", "A", "E", "Comp", "Acabamento", "Qtd Pacotes", "Pecas/Pct", "Peso Total", "Fita Principal", "Fita Meio", "Qtd Madeira", "Tam Madeira"])
     acab = "GI/GA" if m['is_galv'] else "Normal"
-    writer.writerow([m['tipo'], m['l'], m['a'], m['e'], m['c'], acab, res['total_pcts'], m['num'], f"{res['peso_total']:.2f}", m['fita_nome'], m['fita_meio_nome'], m['qtd_madeiras'], m.get('madeira_real', 0)])
+    writer.writerow([m['tipo'], m['l'], m['a'], m['e'], m['c'], acab, res['total_pcts'], m['num'], f"{res['peso_total']:.2f}", m['fita_nome'], m['fita_meio_nome'], m['qtd_madeiras'], m.get('madeira_comprimento_real', 0)])
     return output.getvalue()
 
-# ==========================================
-# INTERFACE
-# ==========================================
-
-aba_calc, aba_admin = st.tabs(["🏭 Calculadora", "⚙️ Admin"])
-
-with aba_calc:
-    with st.sidebar:
-        st.header("Parâmetros")
-        tipo = st.selectbox("Perfil", ["Quadrado/Retangular", "Redondo", "U/Enrijecido"])
-        acabamento = st.radio("Acabamento", ["Preto (Normal)", "Galvanizado (GI/GA)"])
-        c1, c2 = st.columns(2)
-        l = c1.number_input("L/Diam", value=50.0)
-        a = c2.number_input("Altura", value=50.0, disabled=(tipo=="Redondo"))
-        c3, c4 = st.columns(2)
-        e = c3.number_input("Espessura", value=2.00)
-        c = c4.number_input("Comp", value=6000)
-        aba = st.number_input("Aba (U)", value=0.0, disabled=(tipo!="U/Enrijecido"))
-        st.markdown("---")
-        meta = st.number_input("Meta", value=1000)
-        modo = st.selectbox("Unidade", ["Peças", "Toneladas"])
-        btn = st.button("CALCULAR", type="primary")
-
-    if btn:
-        calc = PackageCalculator()
-        t_map = "Enrijecido" if tipo == "U/Enrijecido" else tipo
-        if tipo == "Quadrado/Retangular": t_map = "Quadrado/Retangular"
-        res = calc.calculate(modo, meta, l, a, e, c, t_map, acabamento, aba)
-        
-        if "erro" in res:
-            st.error(res["erro"])
-        else:
-            m = res['main']
-            if "Engenharia" in m['origem']: st.warning(f"⚠️ {m['origem']}")
-            else: st.success(f"✅ {m['origem']}")
-            
-            k1, k2, k3, k4 = st.columns(4)
-            k1.metric("Pacotes", res['total_pcts'])
-            k2.metric("Pçs/Pct", m['num'])
-            k3.metric("Peso Total", f"{res['peso_total']:.0f}kg")
-            k4.metric("Fita", f"{m['fita_tam']}m")
-            
-            t1, t2 = st.tabs(["Visual", "Downloads"])
-            with t1:
-                c_g, c_s = st.columns([1,1])
-                with c_g: st.pyplot(plot_cross_section(m))
-                with c_s: st.pyplot(plot_side_view(m))
-            with t2:
-                st.download_button("📄 PDF", generate_pdf(res), "relatorio.pdf", "application/pdf")
-                st.download_button("📊 CSV", generate_csv(res), "dados.csv", "text/csv")
-
-with aba_admin:
-    st.info("Edição de Catálogo JSON")
+st.title("🏭 Calculadora Formadoras v12.1")
+with st.sidebar:
+    st.header("Parâmetros")
+    tipo = st.selectbox("Perfil", ["Quadrado/Retangular", "Redondo", "U/Enrijecido"])
+    acabamento = st.radio("Acabamento", ["Preto (Normal)", "Galvanizado (GI/GA)"])
+    c1, c2 = st.columns(2)
+    l = c1.number_input("L/Diam", value=50.0)
+    a = c2.number_input("Altura", value=50.0, disabled=(tipo=="Redondo"))
+    c3, c4 = st.columns(2)
+    e = c3.number_input("Espessura", value=2.00)
+    c = c4.number_input("Comp", value=6000)
+    aba = st.number_input("Aba (U)", value=0.0, disabled=(tipo!="U/Enrijecido"))
+    meta = st.number_input("Meta", value=1000)
+    modo = st.selectbox("Unidade", ["Peças", "Toneladas"])
+    btn = st.button("CALCULAR", type="primary")
+
+if btn:
+    calc = PackageCalculator()
+    t_map = "Enrijecido" if tipo == "U/Enrijecido" else tipo
+    if tipo == "Quadrado/Retangular": t_map = "Quadrado/Retangular"
+    res = calc.calculate(modo, meta, l, a, e, c, t_map, acabamento, aba)
+    m = res['main']
+    
+    if "Engenharia" in m['origem']: st.warning(f"⚠️ {m['origem']}")
+    else: st.success(f"✅ {m['origem']}")
+    
+    k1, k2, k3, k4 = st.columns(4)
+    k1.metric("Pacotes", res['total_pcts'])
+    k2.metric("Pçs/Pct", m['num'])
+    k3.metric("Peso Total", f"{res['peso_total']:.0f}kg")
+    k4.metric("Fita", f"{m['fita_tamanho']}m")
+    
+    t1, t2 = st.tabs(["Visual", "Downloads"])
+    with t1:
+        c_g, c_s = st.columns([1,1])
+        with c_g: st.pyplot(plot_cross_section(m))
+        with c_s: st.pyplot(plot_side_view(m))
+    with t2:
+        st.download_button("📄 PDF", generate_pdf(res), "relatorio.pdf", "application/pdf")
+        st.download_button("📊 CSV", generate_csv(res), "dados.csv", "text/csv")
+
+with st.expander("Admin"):
     col_a, col_b = st.columns(2)
     with col_a:
         adm_tipo = st.selectbox("Norma", ["IT14", "IT13"])
@@ -610,7 +547,6 @@ with aba_admin:
         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}"