app.py

import pandas as pd
import numpy as np
import gradio as gr
import os
import io
import tempfile
import time
import pytz
from datetime import datetime

# Path to the CSV file
CSV_FILE_PATH = "./dados/input.csv"

# --- Helper functions (create_8_band_inputs, create_2_band_inputs) remain the same ---
def create_8_band_inputs(prefix, defaults_lim, defaults_aliq):
    inputs = []
    labels_lim = [f"{prefix} Limite {i+1} (UFM)" for i in range(7)]
    labels_aliq = [f"{prefix} Alíquota {i+1} (ex: 0.004 para 0.4%)" for i in range(8)]
    
    with gr.Row():
        inputs.append(gr.Number(label=labels_lim[0], value=defaults_lim[0], min_width=50))
        inputs.append(gr.Number(label=labels_aliq[0], value=defaults_aliq[0], min_width=50))
    with gr.Row():
        inputs.append(gr.Number(label=labels_lim[1], value=defaults_lim[1], min_width=50))
        inputs.append(gr.Number(label=labels_aliq[1], value=defaults_aliq[1], min_width=50))
    with gr.Row():
        inputs.append(gr.Number(label=labels_lim[2], value=defaults_lim[2], min_width=50))
        inputs.append(gr.Number(label=labels_aliq[2], value=defaults_aliq[2], min_width=50))
    with gr.Row():
        inputs.append(gr.Number(label=labels_lim[3], value=defaults_lim[3], min_width=50))
        inputs.append(gr.Number(label=labels_aliq[3], value=defaults_aliq[3], min_width=50))
    with gr.Row():
        inputs.append(gr.Number(label=labels_lim[4], value=defaults_lim[4], min_width=50))
        inputs.append(gr.Number(label=labels_aliq[4], value=defaults_aliq[4], min_width=50))
    with gr.Row():
        inputs.append(gr.Number(label=labels_lim[5], value=defaults_lim[5], min_width=50))
        inputs.append(gr.Number(label=labels_aliq[5], value=defaults_aliq[5], min_width=50))
    with gr.Row():
        inputs.append(gr.Number(label=labels_lim[6], value=defaults_lim[6], min_width=50))
        inputs.append(gr.Number(label=labels_aliq[6], value=defaults_aliq[6], min_width=50))
    with gr.Row():
        inputs.append(gr.Number(label=labels_aliq[7], value=defaults_aliq[7], min_width=50)) # Only aliquot for the last band
    return inputs

def create_2_band_inputs(prefix, default_lim, defaults_aliq):
    inputs = []
    with gr.Row():
        inputs.append(gr.Number(label=f"{prefix} Limite 1 (UFM)", value=default_lim, min_width=50))
        inputs.append(gr.Number(label=f"{prefix} Alíquota 1 (ex: 0.0)", value=defaults_aliq[0], min_width=50))
    with gr.Row():
        inputs.append(gr.Number(label=f"{prefix} Alíquota 2 (ex: 0.03)", value=defaults_aliq[1], min_width=50))
    return inputs

# --- Function to create parameters sheet ---
def create_parameters_sheet(valor_venal_choice, ufm_value, diferencia_estacionamentos_flag, diferencia_predios_flag, all_parameters):
    """Create a DataFrame with all parameters used in the calculation"""
    
    # Extract parameters from the list in the correct order
    params = all_parameters
    
    # Parameter mapping
    param_data = []
    
    # General parameters
    param_data.append(['CONFIGURAÇÕES GERAIS', '', ''])
    param_data.append(['Valor Venal Utilizado', valor_venal_choice, ''])
    param_data.append(['Valor da UFM', ufm_value, ''])
    param_data.append(['Diferenciar Estacionamentos por Uso', 'Sim' if diferencia_estacionamentos_flag else 'Não', ''])
    param_data.append(['Diferenciar Prédios por Uso', 'Sim' if diferencia_predios_flag else 'Não', ''])
    param_data.append(['', '', ''])
    
    # Predial Geral (PG) - 15 parameters
    param_data.append(['PREDIAL GERAL (PG)', '', ''])
    pg_params = params[0:15]
    param_data.extend([
        ['PG Limite 1 (UFM)', pg_params[0], ''],
        ['PG Alíquota 1', pg_params[1], f'{pg_params[1]*100:.3f}%' if pg_params[1] else ''],
        ['PG Limite 2 (UFM)', pg_params[2], ''],
        ['PG Alíquota 2', pg_params[3], f'{pg_params[3]*100:.3f}%' if pg_params[3] else ''],
        ['PG Limite 3 (UFM)', pg_params[4], ''],
        ['PG Alíquota 3', pg_params[5], f'{pg_params[5]*100:.3f}%' if pg_params[5] else ''],
        ['PG Limite 4 (UFM)', pg_params[6], ''],
        ['PG Alíquota 4', pg_params[7], f'{pg_params[7]*100:.3f}%' if pg_params[7] else ''],
        ['PG Limite 5 (UFM)', pg_params[8], ''],
        ['PG Alíquota 5', pg_params[9], f'{pg_params[9]*100:.3f}%' if pg_params[9] else ''],
        ['PG Limite 6 (UFM)', pg_params[10], ''],
        ['PG Alíquota 6', pg_params[11], f'{pg_params[11]*100:.3f}%' if pg_params[11] else ''],
        ['PG Limite 7 (UFM)', pg_params[12], ''],
        ['PG Alíquota 7', pg_params[13], f'{pg_params[13]*100:.3f}%' if pg_params[13] else ''],
        ['PG Alíquota 8', pg_params[14], f'{pg_params[14]*100:.3f}%' if pg_params[14] else ''],
        ['', '', '']
    ])
    
    # Predial Residencial (PR) - 15 parameters
    param_data.append(['PREDIAL RESIDENCIAL (PR)', '', ''])
    pr_params = params[15:30]
    param_data.extend([
        ['PR Limite 1 (UFM)', pr_params[0], ''],
        ['PR Alíquota 1', pr_params[1], f'{pr_params[1]*100:.3f}%' if pr_params[1] else ''],
        ['PR Limite 2 (UFM)', pr_params[2], ''],
        ['PR Alíquota 2', pr_params[3], f'{pr_params[3]*100:.3f}%' if pr_params[3] else ''],
        ['PR Limite 3 (UFM)', pr_params[4], ''],
        ['PR Alíquota 3', pr_params[5], f'{pr_params[5]*100:.3f}%' if pr_params[5] else ''],
        ['PR Limite 4 (UFM)', pr_params[6], ''],
        ['PR Alíquota 4', pr_params[7], f'{pr_params[7]*100:.3f}%' if pr_params[7] else ''],
        ['PR Limite 5 (UFM)', pr_params[8], ''],
        ['PR Alíquota 5', pr_params[9], f'{pr_params[9]*100:.3f}%' if pr_params[9] else ''],
        ['PR Limite 6 (UFM)', pr_params[10], ''],
        ['PR Alíquota 6', pr_params[11], f'{pr_params[11]*100:.3f}%' if pr_params[11] else ''],
        ['PR Limite 7 (UFM)', pr_params[12], ''],
        ['PR Alíquota 7', pr_params[13], f'{pr_params[13]*100:.3f}%' if pr_params[13] else ''],
        ['PR Alíquota 8', pr_params[14], f'{pr_params[14]*100:.3f}%' if pr_params[14] else ''],
        ['', '', '']
    ])
    
    # PNR - 15 parameters
    param_data.append(['PREDIAL NÃO RESIDENCIAL (PNR)', '', ''])
    pnr_params = params[30:45]
    param_data.extend([
        ['PNR Limite 1 (UFM)', pnr_params[0], ''],
        ['PNR Alíquota 1', pnr_params[1], f'{pnr_params[1]*100:.3f}%' if pnr_params[1] else ''],
        ['PNR Limite 2 (UFM)', pnr_params[2], ''],
        ['PNR Alíquota 2', pnr_params[3], f'{pnr_params[3]*100:.3f}%' if pnr_params[3] else ''],
        ['PNR Limite 3 (UFM)', pnr_params[4], ''],
        ['PNR Alíquota 3', pnr_params[5], f'{pnr_params[5]*100:.3f}%' if pnr_params[5] else ''],
        ['PNR Limite 4 (UFM)', pnr_params[6], ''],
        ['PNR Alíquota 4', pnr_params[7], f'{pnr_params[7]*100:.3f}%' if pnr_params[7] else ''],
        ['PNR Limite 5 (UFM)', pnr_params[8], ''],
        ['PNR Alíquota 5', pnr_params[9], f'{pnr_params[9]*100:.3f}%' if pnr_params[9] else ''],
        ['PNR Limite 6 (UFM)', pnr_params[10], ''],
        ['PNR Alíquota 6', pnr_params[11], f'{pnr_params[11]*100:.3f}%' if pnr_params[11] else ''],
        ['PNR Limite 7 (UFM)', pnr_params[12], ''],
        ['PNR Alíquota 7', pnr_params[13], f'{pnr_params[13]*100:.3f}%' if pnr_params[13] else ''],
        ['PNR Alíquota 8', pnr_params[14], f'{pnr_params[14]*100:.3f}%' if pnr_params[14] else ''],
        ['', '', '']
    ])
    
    # EG, ER, ENR (each 15 parameters)
    categories = [
        ('ESTACIONAMENTOS GERAL (EG)', params[45:60], 'EG'),
        ('ESTACIONAMENTOS RESIDENCIAIS (ER)', params[60:75], 'ER'),
        ('ESTACIONAMENTOS NÃO RESIDENCIAIS (ENR)', params[75:90], 'EN')
    ]
    
    for cat_name, cat_params, prefix in categories:
        param_data.append([cat_name, '', ''])
        param_data.extend([
            [f'{prefix} Limite 1 (UFM)', cat_params[0], ''],
            [f'{prefix} Alíquota 1', cat_params[1], f'{cat_params[1]*100:.3f}%' if cat_params[1] else ''],
            [f'{prefix} Limite 2 (UFM)', cat_params[2], ''],
            [f'{prefix} Alíquota 2', cat_params[3], f'{cat_params[3]*100:.3f}%' if cat_params[3] else ''],
            [f'{prefix} Limite 3 (UFM)', cat_params[4], ''],
            [f'{prefix} Alíquota 3', cat_params[5], f'{cat_params[5]*100:.3f}%' if cat_params[5] else ''],
            [f'{prefix} Limite 4 (UFM)', cat_params[6], ''],
            [f'{prefix} Alíquota 4', cat_params[7], f'{cat_params[7]*100:.3f}%' if cat_params[7] else ''],
            [f'{prefix} Limite 5 (UFM)', cat_params[8], ''],
            [f'{prefix} Alíquota 5', cat_params[9], f'{cat_params[9]*100:.3f}%' if cat_params[9] else ''],
            [f'{prefix} Limite 6 (UFM)', cat_params[10], ''],
            [f'{prefix} Alíquota 6', cat_params[11], f'{cat_params[11]*100:.3f}%' if cat_params[11] else ''],
            [f'{prefix} Limite 7 (UFM)', cat_params[12], ''],
            [f'{prefix} Alíquota 7', cat_params[13], f'{cat_params[13]*100:.3f}%' if cat_params[13] else ''],
            [f'{prefix} Alíquota 8', cat_params[14], f'{cat_params[14]*100:.3f}%' if cat_params[14] else ''],
            ['', '', '']
        ])
    
    # Terrenos (T1DF, T2DF, T3DF - each 3 parameters)
    terreno_categories = [
        ('TERRENOS 1ª DF (T1DF)', params[90:93], '1'),
        ('TERRENOS 2ª DF (T2DF)', params[93:96], '2'),
        ('TERRENOS 3ª DF (T3DF)', params[96:99], '3')
    ]
    
    for cat_name, cat_params, num in terreno_categories:
        param_data.append([cat_name, '', ''])
        param_data.extend([
            [f'T{num}DF Limite 1 (UFM)', cat_params[0], ''],
            [f'T{num}DF Alíquota 1', cat_params[1], f'{cat_params[1]*100:.3f}%' if cat_params[1] else ''],
            [f'T{num}DF Alíquota 2', cat_params[2], f'{cat_params[2]*100:.3f}%' if cat_params[2] else ''],
            ['', '', '']
        ])
    
    # TAE and TAF (1 parameter each)
    param_data.extend([
        ['TERRENOS ALÍQUOTA ESPECIAL (TAE)', '', ''],
        ['TAE Alíquota 1', params[99], f'{params[99]*100:.3f}%' if params[99] else ''],
        ['', '', ''],
        ['TERRENOS ALÍQUOTA FIXA (TAF)', '', ''],
        ['TAF Alíquota 1', params[100], f'{params[100]*100:.3f}%' if params[100] else '']
    ])
    
    # Create DataFrame
    df = pd.DataFrame(param_data, columns=['Parâmetro', 'Valor', 'Percentual'])
    return df

def format_worksheet(worksheet, dataframe, currency_columns=None):
    """Format worksheet with currency formatting and auto-fit columns"""
    from openpyxl.styles import NamedStyle, Font, PatternFill, Alignment
    from openpyxl.utils import get_column_letter
    
    if currency_columns is None:
        currency_columns = []
    
    # Create currency style
    currency_style = NamedStyle(name="currency_brl")
    currency_style.number_format = 'R$ #,##0.00'
    
    # Create header style
    header_style = NamedStyle(name="header")
    header_style.font = Font(bold=True, color="FFFFFF")
    header_style.fill = PatternFill(start_color="366092", end_color="366092", fill_type="solid")
    header_style.alignment = Alignment(horizontal="center", vertical="center")
    
    # Apply header formatting
    for col_num in range(1, len(dataframe.columns) + 1):
        cell = worksheet.cell(row=1, column=col_num)
        cell.font = header_style.font
        cell.fill = header_style.fill
        cell.alignment = header_style.alignment
    
    # Apply currency formatting to specified columns
    for col_name in currency_columns:
        if col_name in dataframe.columns:
            col_idx = dataframe.columns.get_loc(col_name) + 1  # Excel is 1-indexed
            col_letter = get_column_letter(col_idx)
            
            # Apply currency format to all data cells in this column (skip header)
            for row_num in range(2, len(dataframe) + 2):
                cell = worksheet.cell(row=row_num, column=col_idx)
                cell.number_format = 'R$ #,##0.00'
    
    # Auto-fit column widths with 10% extra padding
    for column in worksheet.columns:
        max_length = 0
        column_letter = column[0].column_letter
        col_idx = column[0].column - 1  # Convert to 0-based index
        
        # Check if this is a currency column
        is_currency_column = False
        if col_idx < len(dataframe.columns):
            col_name = dataframe.columns[col_idx]
            is_currency_column = col_name in currency_columns
        
        for cell in column:
            try:
                if cell.value:
                    if is_currency_column and isinstance(cell.value, (int, float)):
                        # For currency columns, calculate based on formatted display length
                        # Format: "R$ 1,234,567,890.12" 
                        formatted_value = f"R$ {cell.value:,.2f}"
                        cell_length = len(formatted_value)
                    else:
                        # For non-currency columns, use actual string length
                        cell_length = len(str(cell.value))
                    
                    if cell_length > max_length:
                        max_length = cell_length
            except:
                pass
        
        # Set column width with 10% extra padding
        adjusted_width = min((max_length + 2) * 1.1, 55)  # 10% extra + cap at 55
        worksheet.column_dimensions[column_letter].width = adjusted_width
    
    # Set minimum width for very narrow columns
    for col_letter in [get_column_letter(i) for i in range(1, len(dataframe.columns) + 1)]:
        if worksheet.column_dimensions[col_letter].width < 12:
            worksheet.column_dimensions[col_letter].width = 12

# --- Function to create Excel file ---
def create_excel_download(df_resumo_iptu, result_agg, total_novo_str, total_atual_trib_str, total_atual_calc_str, 
                         valor_venal_choice, ufm_value, diferencia_estacionamentos_flag, diferencia_predios_flag, all_parameters):
    """Create an Excel file with multiple sheets containing the results and parameters"""
    
    # Create a BytesIO object to store the Excel file in memory
    output = io.BytesIO()
    
    # Create Excel writer
    with pd.ExcelWriter(output, engine='openpyxl') as writer:
        # Sheet 1: Detailed summary by category and range
        if df_resumo_iptu is not None and not df_resumo_iptu.empty:
            # Create a copy without formatting for Excel export
            df_export = df_resumo_iptu.copy()
            # Convert formatted numbers back to numeric for Excel
            if 'Total arrecadado na faixa' in df_export.columns:
                df_export['Total arrecadado na faixa'] = df_export['Total arrecadado na faixa'].astype(str).str.replace(',', '').astype(float)
            df_export.to_excel(writer, sheet_name='Resumo Detalhado', index=False)
            
            # Format the sheet
            worksheet = writer.sheets['Resumo Detalhado']
            format_worksheet(worksheet, df_export, currency_columns=['Total arrecadado na faixa'])
        
        # Sheet 2: Aggregated summary by category
        if result_agg is not None and not result_agg.empty:
            # Create a copy without formatting for Excel export
            result_export = result_agg.copy()
            # Convert formatted numbers back to numeric for Excel
            total_cols_to_convert = [col for col in result_export.columns if col.startswith("Total")]
            for col_name in total_cols_to_convert:
                if col_name in result_export.columns:
                    result_export[col_name] = result_export[col_name].astype(str).str.replace(',', '').astype(float)
            result_export.to_excel(writer, sheet_name='Resumo Agregado', index=False)
            
            # Format the sheet
            worksheet = writer.sheets['Resumo Agregado']
            currency_cols = [col for col in result_export.columns if col.startswith("Total")]
            format_worksheet(worksheet, result_export, currency_columns=currency_cols)
        
        # Sheet 3: Summary totals
        summary_data = {
            'Descrição': ['Total IPTU Novo', 'Total IPTU Atual Tributado', 'Total IPTU Atual Calculado'],
            'Valor': [
                float(total_novo_str.split(': ')[1].replace(',', '')) if ': ' in total_novo_str else 0,
                float(total_atual_trib_str.split(': ')[1].replace(',', '')) if ': ' in total_atual_trib_str else 0,
                float(total_atual_calc_str.split(': ')[1].replace(',', '')) if ': ' in total_atual_calc_str else 0
            ]
        }
        summary_df = pd.DataFrame(summary_data)
        summary_df.to_excel(writer, sheet_name='Totais Gerais', index=False)
        
        # Format the sheet
        worksheet = writer.sheets['Totais Gerais']
        format_worksheet(worksheet, summary_df, currency_columns=['Valor'])
        
        # Sheet 4: Parameters and Ranges Used
        params_data = create_parameters_sheet(valor_venal_choice, ufm_value, diferencia_estacionamentos_flag, diferencia_predios_flag, all_parameters)
        params_data.to_excel(writer, sheet_name='Parâmetros Utilizados', index=False)
        
        # Format the parameters sheet
        worksheet = writer.sheets['Parâmetros Utilizados']
        format_worksheet(worksheet, params_data, currency_columns=[])
    
    output.seek(0)
    return output

# --- Main processing function ---
def process_iptu_data(
    valor_venal_choice, ufm_value_input, 
    diferencia_estacionamentos_flag, diferencia_predios_flag,
    # Inputs for Faixas e Alíquotas
    pg_lim1, pg_alq1, pg_lim2, pg_alq2, pg_lim3, pg_alq3, pg_lim4, pg_alq4, pg_lim5, pg_alq5, pg_lim6, pg_alq6, pg_lim7, pg_alq7, pg_alq8,
    pr_lim1, pr_alq1, pr_lim2, pr_alq2, pr_lim3, pr_alq3, pr_lim4, pr_alq4, pr_lim5, pr_alq5, pr_lim6, pr_alq6, pr_lim7, pr_alq7, pr_alq8,
    pnr_lim1, pnr_alq1, pnr_lim2, pnr_alq2, pnr_lim3, pnr_alq3, pnr_lim4, pnr_alq4, pnr_lim5, pnr_alq5, pnr_lim6, pnr_alq6, pnr_lim7, pnr_alq7, pnr_alq8,
    eg_lim1, eg_alq1, eg_lim2, eg_alq2, eg_lim3, eg_alq3, eg_lim4, eg_alq4, eg_lim5, eg_alq5, eg_lim6, eg_alq6, eg_lim7, eg_alq7, eg_alq8,
    er_lim1, er_alq1, er_lim2, er_alq2, er_lim3, er_alq3, er_lim4, er_alq4, er_lim5, er_alq5, er_lim6, er_alq6, er_lim7, er_alq7, er_alq8,
    enr_lim1, enr_alq1, enr_lim2, enr_alq2, enr_lim3, enr_alq3, enr_lim4, enr_alq4, enr_lim5, enr_alq5, enr_lim6, enr_alq6, enr_lim7, enr_alq7, enr_alq8,
    t1df_lim1, t1df_alq1, t1df_alq2,
    t2df_lim1, t2df_alq1, t2df_alq2,
    t3df_lim1, t3df_alq1, t3df_alq2,
    tae_alq1,
    taf_alq1
    ):
    
    # === CSV LOADING AND VALIDATION ===
    if not os.path.exists(CSV_FILE_PATH):
        return f"Erro: Arquivo '{CSV_FILE_PATH}' não encontrado no servidor.", None, None, "", "", "", gr.Textbox(visible=False), gr.DownloadButton(visible=False)

    try:
        the_merge = pd.read_csv(CSV_FILE_PATH)
    except Exception as e:
        return f"Erro ao ler o arquivo CSV '{CSV_FILE_PATH}': {str(e)}", None, None, "", "", "", gr.Textbox(visible=False), gr.DownloadButton(visible=False)
    
    valor_venal_utilizado = valor_venal_choice
    UFM_VALUE = ufm_value_input
    
    required_cols = ["TIPO_LANCAMENTO", "DES_TIPO_ISENCAO_MULTI", "VLR_IMPOSTO_iptu", 
                     "DES_FINALIDADE_unidade", "DES_USO_unidade", "IDF_TIPO_BENEFICIO",
                     "NUM_DIVISAO_FISCAL_iptu", valor_venal_utilizado, 
                     "VLR_IMPOSTO_CALCULADO_iptu"] 
    missing_cols = [col for col in required_cols if col not in the_merge.columns]
    if missing_cols:
        return f"Colunas ausentes no CSV: {', '.join(missing_cols)}", None, None, "", "", "", gr.Textbox(visible=False), gr.DownloadButton(visible=False)

    for col_str in ["TIPO_LANCAMENTO", "DES_TIPO_ISENCAO_MULTI", "DES_FINALIDADE_unidade", "DES_USO_unidade"]:
        if col_str in the_merge.columns:
            the_merge[col_str] = the_merge[col_str].astype(str).fillna('')

    # === PARAMETER ASSIGNMENT ===
    # [All parameter assignments remain exactly the same as before]
    PG_lim_1, PG_aliq_1 = pg_lim1, pg_alq1; PG_lim_2, PG_aliq_2 = pg_lim2, pg_alq2; PG_lim_3, PG_aliq_3 = pg_lim3, pg_alq3; PG_lim_4, PG_aliq_4 = pg_lim4, pg_alq4; PG_lim_5, PG_aliq_5 = pg_lim5, pg_alq5; PG_lim_6, PG_aliq_6 = pg_lim6, pg_alq6; PG_lim_7, PG_aliq_7 = pg_lim7, pg_alq7; PG_aliq_8 = pg_alq8
    PR_lim_1, PR_aliq_1 = pr_lim1, pr_alq1; PR_lim_2, PR_aliq_2 = pr_lim2, pr_alq2; PR_lim_3, PR_aliq_3 = pr_lim3, pr_alq3; PR_lim_4, PR_aliq_4 = pr_lim4, pr_alq4; PR_lim_5, PR_aliq_5 = pr_lim5, pr_alq5; PR_lim_6, PR_aliq_6 = pr_lim6, pr_alq6; PR_lim_7, PR_aliq_7 = pr_lim7, pr_alq7; PR_aliq_8 = pr_alq8
    PNR_lim_1, PNR_aliq_1 = pnr_lim1, pnr_alq1; PNR_lim_2, PNR_aliq_2 = pnr_lim2, pnr_alq2; PNR_lim_3, PNR_aliq_3 = pnr_lim3, pnr_alq3; PNR_lim_4, PNR_aliq_4 = pnr_lim4, pnr_alq4; PNR_lim_5, PNR_aliq_5 = pnr_lim5, pnr_alq5; PNR_lim_6, PNR_aliq_6 = pnr_lim6, pnr_alq6; PNR_lim_7, PNR_aliq_7 = pnr_lim7, pnr_alq7; PNR_aliq_8 = pnr_alq8
    EG_lim_1, EG_aliq_1 = eg_lim1, eg_alq1; EG_lim_2, EG_aliq_2 = eg_lim2, eg_alq2; EG_lim_3, EG_aliq_3 = eg_lim3, eg_alq3; EG_lim_4, EG_aliq_4 = eg_lim4, eg_alq4; EG_lim_5, EG_aliq_5 = eg_lim5, eg_alq5; EG_lim_6, EG_aliq_6 = eg_lim6, eg_alq6; EG_lim_7, EG_aliq_7 = eg_lim7, eg_alq7; EG_aliq_8 = eg_alq8
    ER_lim_1, ER_aliq_1 = er_lim1, er_alq1; ER_lim_2, ER_aliq_2 = er_lim2, er_alq2; ER_lim_3, ER_aliq_3 = er_lim3, er_alq3; ER_lim_4, ER_aliq_4 = er_lim4, er_alq4; ER_lim_5, ER_aliq_5 = er_lim5, er_alq5; ER_lim_6, ER_aliq_6 = er_lim6, er_alq6; ER_lim_7, ER_aliq_7 = er_lim7, er_alq7; ER_aliq_8 = er_alq8
    ENR_lim_1, ENR_aliq_1 = enr_lim1, enr_alq1; ENR_lim_2, ENR_aliq_2 = enr_lim2, enr_alq2; ENR_lim_3, ENR_aliq_3 = enr_lim3, enr_alq3; ENR_lim_4, ENR_aliq_4 = enr_lim4, enr_alq4; ENR_lim_5, ENR_aliq_5 = enr_lim5, enr_alq5; ENR_lim_6, ENR_aliq_6 = enr_lim6, enr_alq6; ENR_lim_7, ENR_aliq_7 = enr_lim7, enr_alq7; ENR_aliq_8 = enr_alq8
    T1DF_lim_1, T1DF_aliq_1 = t1df_lim1, t1df_alq1; T1DF_aliq_2 = t1df_alq2
    T2DF_lim_1, T2DF_aliq_1 = t2df_lim1, t2df_alq1; T2DF_aliq_2 = t2df_alq2
    T3DF_lim_1, T3DF_aliq_1 = t3df_lim1, t3df_alq1; T3DF_aliq_2 = t3df_alq2
    TAE_aliq_1 = tae_alq1
    TAF_aliq_1 = taf_alq1

    # === DATA FILTERING AND CLASSIFICATION ===
    # [All filtering logic remains exactly the same as before]
    sem_lancamento = (the_merge["TIPO_LANCAMENTO"].isin(['Isenção Total por Benefício Fiscal', 'Imóvel com bloqueio de lançamento de IPTU/TCL', 'Não lançado - Valor total calculado menor que o mínimo', 'Isenção TCL Box e Não Lançado - valor menor que Mínimo', 'Isenção Técnica'])) | ((the_merge["TIPO_LANCAMENTO"]=='Isenção TCL - Box') & (the_merge["VLR_IMPOSTO_iptu"]==0))
    isentos = (the_merge["DES_TIPO_ISENCAO_MULTI"].str.contains("isen", case=False, na=False))
    imunes = (the_merge["DES_TIPO_ISENCAO_MULTI"].str.contains("imun", case=False, na=False)) | (the_merge["DES_TIPO_ISENCAO_MULTI"].str.contains("IMUNIDADES", na=False))
    nao_incidencia = (the_merge["DES_TIPO_ISENCAO_MULTI"].str.contains("NÃO INCIDÊNCIA DE IPTU", case=False, na=False))
    nao_tributados = (isentos) | (imunes) | (sem_lancamento) | (nao_incidencia)

    # Property type classifications [Same as before]
    finalidades_estacionamentos = ['ESPACO DE ESTACIONAMENTO RESIDENCIAL', 'ESPACO DE ESTACIONAMENTO NAO RESIDENCIAL', 'ESPACO ESTACIONAMENTO VINCULADO NAO RESID DESCOBERTO', 'ESPACO ESTACIONAMENTO VINCULADO RESID COBERTO', 'ESPACO ESTACIONAMENTO VINCULADO NAO RESID COBERTO', 'ESPACO DE ESTACIONAMENTO RESIDENCIAL DESCOBERTO', 'ESPACO DE ESTACIONAMENTO NAO RESIDENC DESCOBERTO', 'ESPACO ESTACIONAMENTO VINCULADO RESID DESCOBERTO']
    finalidades_terrenos = ['TERRENO', 'GLEBA', 'TERRENOS CONDOMINIO HORIZ ABERTO SEM AREA USO COMUM', 'TERRENO EM CONDOMINIO HORIZONTAL FECHADO', 'TERRENO EM CONDOMINIO HORIZONTAL ABERTO', 'SOBRA DE AREA', 'AREA A VISTORIAR']
    
    # All property classifications [Same logic as before]
    estacionamentos_residenciais = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos)) & (the_merge["DES_USO_unidade"]=='Exclusivamente Residencial')
    estacionamentos_residenciais_tributados = (estacionamentos_residenciais) & (~nao_tributados)
    estacionamentos_residenciais_nao_tributados = (estacionamentos_residenciais) & (nao_tributados)
    estacionamentos_nao_residenciais = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos)) & (the_merge["DES_USO_unidade"]!='Exclusivamente Residencial')
    estacionamentos_nao_residenciais_tributados =  (estacionamentos_nao_residenciais) & (~nao_tributados)
    estacionamentos_nao_residenciais_nao_tributados = (estacionamentos_nao_residenciais) & (nao_tributados)
    estacionamentos_geral = the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos)
    estacionamentos_geral_tributados = (estacionamentos_geral) & (~nao_tributados)
    estacionamentos_geral_nao_tributados = (estacionamentos_geral) & (nao_tributados)

    terrenos_aliqesp = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (pd.to_numeric(the_merge["IDF_TIPO_BENEFICIO"], errors="coerce").fillna(0).astype(int) == 301) & (~nao_tributados)
    terrenos_aliqfix = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (pd.to_numeric(the_merge["IDF_TIPO_BENEFICIO"], errors="coerce").fillna(0).astype(int) == 95) & (~nao_tributados)
    terrenos_1df = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (the_merge["NUM_DIVISAO_FISCAL_iptu"]==1) & (~terrenos_aliqesp) & (~terrenos_aliqfix)
    terrenos_1df_tributados = (terrenos_1df) & (~nao_tributados)
    terrenos_1df_nao_tributados = (terrenos_1df) & (nao_tributados)
    terrenos_2df = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (the_merge["NUM_DIVISAO_FISCAL_iptu"]==2) & (~terrenos_aliqesp) & (~terrenos_aliqfix)
    terrenos_2df_tributados =  (terrenos_2df) & (~nao_tributados)
    terrenos_2df_nao_tributados = (terrenos_2df) & (nao_tributados)
    terrenos_3df = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (the_merge["NUM_DIVISAO_FISCAL_iptu"]==3) & (~terrenos_aliqesp) & (~terrenos_aliqfix)
    terrenos_3df_tributados = (terrenos_3df)  & (~nao_tributados)
    terrenos_3df_nao_tributados = (terrenos_3df) & (nao_tributados)

    isen_prop_loc = ((the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - PROPRIETARIO/USUFRUTUARIO APOSENTADO, INATIVO, PENSIONISTA') | (the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - LOCATÁRIO/COMODATARIO/ARRENDATÁRIO  APOSENTADO, INATIVO, PENSIONISTA')| (the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - PROPRIETARIO/USUFRUTUARIO DEFICIENTE'))
    isen_hab_pop = ((the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - HABITAÇÕES POPULARES DE EMPREENDIMENTOS HABITACIONAIS DESTINADOS PARA HABITAÇÃO DE INTERESSE SOCIAL') | (the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - HABITAÇÕES POPULARES ORIUNDAS DE REGULARIZAÇÕES FUNDIÁRIAS PROMOVIDAS POR ÓRGÃOS PÚBLICOS'))
    
    prediais_residenciais = (~the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos + finalidades_terrenos)) & (the_merge["DES_USO_unidade"] == 'Exclusivamente Residencial')
    prediais_residenciais_tributados = (prediais_residenciais) & (~nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop)
    prediais_residenciais_nao_tributados = (prediais_residenciais) & (nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop)
    prediais_nao_residenciais = (~the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos + finalidades_terrenos)) & (the_merge["DES_USO_unidade"] != 'Exclusivamente Residencial') & (~isen_prop_loc) & (~isen_hab_pop)
    prediais_nao_residenciais_tributados = (prediais_nao_residenciais) & (~nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop)
    prediais_nao_residenciais_nao_tributados = (prediais_nao_residenciais) & (nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop)
    prediais_geral = (~the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos + finalidades_terrenos)) & (~isen_prop_loc) & (~isen_hab_pop)
    prediais_geral_tributados = (prediais_geral) & (~nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop)
    prediais_geral_nao_tributados = (prediais_geral) & (nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop)
    
    # === IPTU RULES DEFINITION ===
    IPTU_RULES = {
        'PGI': { 'name': "Predial Sem Dif. por Uso Isentos", 'rule': prediais_geral_nao_tributados, 'ranges': [[np.inf, 0.0]]},
        'PG': { 'name': "Predial Sem Dif. por Uso", 'rule': prediais_geral_tributados, 'ranges': [[PG_lim_1*UFM_VALUE, PG_aliq_1],[PG_lim_2*UFM_VALUE, PG_aliq_2],[PG_lim_3*UFM_VALUE, PG_aliq_3],[PG_lim_4*UFM_VALUE, PG_aliq_4],[PG_lim_5*UFM_VALUE, PG_aliq_5],[PG_lim_6*UFM_VALUE, PG_aliq_6],[PG_lim_7*UFM_VALUE, PG_aliq_7],[np.inf, PG_aliq_8]]},
        'PRI': { 'name': "Predial Residencial Isentos", 'rule': prediais_residenciais_nao_tributados, 'ranges': [[np.inf, 0.0]]},
        'PR': { 'name': "Predial Residencial", 'rule': prediais_residenciais_tributados, 'ranges': [[PR_lim_1*UFM_VALUE, PR_aliq_1],[PR_lim_2*UFM_VALUE, PR_aliq_2],[PR_lim_3*UFM_VALUE, PR_aliq_3],[PR_lim_4*UFM_VALUE, PR_aliq_4],[PR_lim_5*UFM_VALUE, PR_aliq_5],[PR_lim_6*UFM_VALUE, PR_aliq_6],[PR_lim_7*UFM_VALUE, PR_aliq_7],[np.inf, PR_aliq_8]]},
        'PNRI': { 'name': "Predial Não Residencial Isentos", 'rule': prediais_nao_residenciais_nao_tributados, 'ranges': [[np.inf, 0.0]]},
        'PNR': { 'name': "Predial Não Residencial", 'rule': prediais_nao_residenciais_tributados, 'ranges': [[PNR_lim_1*UFM_VALUE, PNR_aliq_1],[PNR_lim_2*UFM_VALUE, PNR_aliq_2],[PNR_lim_3*UFM_VALUE, PNR_aliq_3],[PNR_lim_4*UFM_VALUE, PNR_aliq_4],[PNR_lim_5*UFM_VALUE, PNR_aliq_5],[PNR_lim_6*UFM_VALUE, PNR_aliq_6],[PNR_lim_7*UFM_VALUE, PNR_aliq_7],[np.inf, PNR_aliq_8]]},
        'EGI': { 'name':'Estacionamentos Sem Dif. por Uso Isentos', 'rule': estacionamentos_geral_nao_tributados, 'ranges': [[np.inf, 0.0]]},
        'EG': { 'name': "Estacionamentos Sem Dif. por Uso", 'rule': estacionamentos_geral_tributados, 'ranges': [[EG_lim_1*UFM_VALUE, EG_aliq_1],[EG_lim_2*UFM_VALUE, EG_aliq_2],[EG_lim_3*UFM_VALUE, EG_aliq_3],[EG_lim_4*UFM_VALUE, EG_aliq_4],[EG_lim_5*UFM_VALUE, EG_aliq_5],[EG_lim_6*UFM_VALUE, EG_aliq_6],[EG_lim_7*UFM_VALUE, EG_aliq_7],[np.inf, EG_aliq_8]]},
        'ERI': { 'name':'Estacionamentos Residenciais Isentos', 'rule': estacionamentos_residenciais_nao_tributados, 'ranges': [[np.inf, 0.0]]},
        'ER': { 'name':'Estacionamentos Residenciais', 'rule': estacionamentos_residenciais_tributados, 'ranges': [[ER_lim_1*UFM_VALUE, ER_aliq_1],[ER_lim_2*UFM_VALUE, ER_aliq_2],[ER_lim_3*UFM_VALUE, ER_aliq_3],[ER_lim_4*UFM_VALUE, ER_aliq_4],[ER_lim_5*UFM_VALUE, ER_aliq_5],[ER_lim_6*UFM_VALUE, ER_aliq_6],[ER_lim_7*UFM_VALUE, ER_aliq_7],[np.inf, ER_aliq_8]]},
        'ENRI': { 'name':'Estacionamentos Não Residenciais Isentos', 'rule': estacionamentos_nao_residenciais_nao_tributados, 'ranges': [[np.inf, 0.0]]},
        'ENR': { 'name':'Estacionamentos Não Residenciais', 'rule': estacionamentos_nao_residenciais_tributados, 'ranges': [[ENR_lim_1*UFM_VALUE, ENR_aliq_1],[ENR_lim_2*UFM_VALUE, ENR_aliq_2],[ENR_lim_3*UFM_VALUE, ENR_aliq_3],[ENR_lim_4*UFM_VALUE, ENR_aliq_4],[ENR_lim_5*UFM_VALUE, ENR_aliq_5],[ENR_lim_6*UFM_VALUE, ENR_aliq_6],[ENR_lim_7*UFM_VALUE, ENR_aliq_7],[np.inf, ENR_aliq_8]]},
        'T1DFI': { 'name':'Terrenos na 1a DF Isentos', 'rule': terrenos_1df_nao_tributados, 'ranges': [[np.inf, 0.0]]},
        'T1DF': { 'name': 'Terrenos na 1a DF', 'rule': terrenos_1df_tributados, 'ranges': [[T1DF_lim_1*UFM_VALUE, T1DF_aliq_1],[np.inf, T1DF_aliq_2]]},
        'T2DFI': { 'name':'Terrenos na 2a DF Isentos', 'rule': terrenos_2df_nao_tributados, 'ranges': [[np.inf, 0.0]]},
        'T2DF': { 'name': 'Terrenos na 2a DF', 'rule': terrenos_2df_tributados, 'ranges': [[T2DF_lim_1*UFM_VALUE, T2DF_aliq_1],[np.inf, T2DF_aliq_2]]},
        'T3DFI': { 'name':'Terrenos na 3a DF Isentos', 'rule': terrenos_3df_nao_tributados, 'ranges': [[np.inf, 0.0]]},
        'T3DF': { 'name': 'Terrenos na 3a DF', 'rule': terrenos_3df_tributados, 'ranges': [[T3DF_lim_1*UFM_VALUE, T3DF_aliq_1],[np.inf, T3DF_aliq_2]]},
        'TAE': { 'name': 'Terrenos Aliq. Esp.', 'rule': terrenos_aliqesp, 'ranges': [[np.inf, TAE_aliq_1]]},
        'TAF': { 'name': 'Terrenos Aliq. Fix.', 'rule': terrenos_aliqfix, 'ranges': [[np.inf, TAF_aliq_1]]},
    }

    # Rule filtering based on differentiation flags [Same logic as before]
    if diferencia_estacionamentos_flag:
        if 'EG' in IPTU_RULES: del IPTU_RULES['EG']
        if 'EGI' in IPTU_RULES: del IPTU_RULES['EGI']
    else:
        if 'ER' in IPTU_RULES: del IPTU_RULES['ER']
        if 'ERI' in IPTU_RULES: del IPTU_RULES['ERI']
        if 'ENR' in IPTU_RULES: del IPTU_RULES['ENR']
        if 'ENRI' in IPTU_RULES: del IPTU_RULES['ENRI']

    if diferencia_predios_flag:
        if 'PG' in IPTU_RULES: del IPTU_RULES['PG']
        if 'PGI' in IPTU_RULES: del IPTU_RULES['PGI']
    else:
        if 'PR' in IPTU_RULES: del IPTU_RULES['PR']
        if 'PRI' in IPTU_RULES: del IPTU_RULES['PRI']
        if 'PNR' in IPTU_RULES: del IPTU_RULES['PNR']
        if 'PNRI' in IPTU_RULES: del IPTU_RULES['PNRI']

    reference_rule_key = 'PR' if diferencia_predios_flag else 'PG'
    if reference_rule_key not in IPTU_RULES:
         if 'PG' in IPTU_RULES: reference_rule_key = 'PG'
         elif 'PR' in IPTU_RULES: reference_rule_key = 'PR'
         else: return f"Erro: Nenhuma regra de referência Predial (PG/PR) disponível.", None, None, "", "", "", gr.Textbox(visible=False), gr.DownloadButton(visible=False)
    reference_rule = IPTU_RULES[reference_rule_key]

    # Special rules for exemptions [Same logic as before]
    prpl_ranges = [[100000 * UFM_VALUE, 0.0]]
    if reference_rule['ranges'][0][0] >= 100000 * UFM_VALUE: prpl_ranges = reference_rule['ranges'].copy()
    else:
        for threshold, rate in reference_rule['ranges']:
            if threshold > 100000 * UFM_VALUE: prpl_ranges.append([threshold, rate])
    IPTU_RULES['PRPL'] = {'name': "Predial Residencial - Aposentado, Inativo, Pensionista, Deficiente", 'rule': isen_prop_loc, 'ranges': prpl_ranges}

    prph_ranges = [[55000 * UFM_VALUE, 0.0]]
    if reference_rule['ranges'][0][0] >= 55000 * UFM_VALUE: prph_ranges = reference_rule['ranges'].copy()
    else:
        for threshold, rate in reference_rule['ranges']:
            if threshold > 55000 * UFM_VALUE: prph_ranges.append([threshold, rate])
    IPTU_RULES['PRHP'] = {'name': "Predial Residencial - Habitações Populares", 'rule': isen_hab_pop, 'ranges': prph_ranges}
    
    # === TAX CALCULATION ENGINE ===
    # [All calculation logic remains exactly the same as before]
    the_merge[valor_venal_utilizado] = pd.to_numeric(the_merge[valor_venal_utilizado], errors='coerce')

    for regra_nome, regra in IPTU_RULES.items():
        filtro = regra["rule"]
        faixas = regra["ranges"]
        current_vv_values = the_merge.loc[filtro, valor_venal_utilizado] 
        limites = [0] + [lim[0] for lim in faixas]
        aliquotas = [lim[1] for lim in faixas]

        for i in range(len(aliquotas)):
            limite_inferior = limites[i]
            limite_superior = limites[i + 1] if i + 1 < len(limites) else float('inf')
            aliquota = aliquotas[i]
            nome_coluna = f"IPTU_{regra_nome}_F{i+1}"
            valor_na_banda = np.maximum(0, np.minimum(current_vv_values, limite_superior) - limite_inferior)
            if limite_superior == float('inf'):
                valor_na_banda = np.maximum(0, current_vv_values - limite_inferior)
            imposto_na_banda = valor_na_banda * aliquota
            the_merge.loc[filtro, nome_coluna] = imposto_na_banda

    new_total_columns = {}
    for chave, regra in IPTU_RULES.items():
        colunas_faixas = [f"IPTU_{chave}_F{i+1}" for i in range(len(regra["ranges"]))]
        for col_f in colunas_faixas:
            if col_f not in the_merge.columns: the_merge[col_f] = 0
        if not colunas_faixas: new_total_columns[f"IPTU_{chave}_TOTAL"] = pd.Series(0, index=the_merge.index)
        else: new_total_columns[f"IPTU_{chave}_TOTAL"] = the_merge[colunas_faixas].fillna(0).sum(axis=1)
    the_merge = pd.concat([the_merge, pd.DataFrame(new_total_columns, index=the_merge.index)], axis=1)

    # === RESULTS GENERATION ===
    # [All results generation logic remains exactly the same as before]
    resumo_total = []
    for regra_nome, regra in IPTU_RULES.items():
        nome_legivel = regra["name"]; filtro_rule = regra["rule"]; faixas = regra["ranges"]
        df_filtrado = the_merge[filtro_rule].copy()
        vv_perc = df_filtrado[valor_venal_utilizado]
        limites_faixas = [lim[0] for lim in faixas]; limites_com_zero = [0] + limites_faixas; aliquotas_faixas = [lim[1] for lim in faixas]

        for i, (limite_superior_raw, aliquota) in enumerate(faixas):
            limite_superior_display = limite_superior_raw if limite_superior_raw != np.inf else float('inf')
            faixa_col = f"IPTU_{regra_nome}_F{i+1}"
            if faixa_col not in df_filtrado.columns: df_filtrado[faixa_col] = 0
            faixa_nome_val_inf = limite_superior_display/UFM_VALUE if UFM_VALUE != 0 else float('inf')
            faixa_nome = f"{limites_com_zero[i]/UFM_VALUE if UFM_VALUE !=0 else 0:,.0f} a {faixa_nome_val_inf:,.0f} UFM ({aliquota*100:.2f}%)"
            if limite_superior_display == float('inf'): faixa_nome = f"{limites_com_zero[i]/UFM_VALUE if UFM_VALUE != 0 else 0:,.0f} a inf UFM ({aliquota*100:.2f}%)"
            total_faixa = df_filtrado[faixa_col].fillna(0).sum()
            cond_exclusiva = pd.Series(False, index=vv_perc.index)
            if not vv_perc.empty:
                if i == 0: cond_exclusiva = vv_perc <= limite_superior_raw
                else: cond_exclusiva = (vv_perc > limites_com_zero[i]) & (vv_perc <= limite_superior_raw)
            qnt_exclusiva = cond_exclusiva.sum()
            cond_atinge = pd.Series(False, index=vv_perc.index)
            if not vv_perc.empty: cond_atinge = vv_perc > limites_com_zero[i]
            qnt_atinge = cond_atinge.sum()
            resumo_total.append([nome_legivel, faixa_nome, qnt_exclusiva, qnt_atinge, total_faixa])
    
    df_resumo_iptu = pd.DataFrame(resumo_total, columns=["Categoria", "Faixa (VV em UFM)", "Inscrições apenas nesta faixa", "Inscrições que atingem esta faixa", "Total arrecadado na faixa"])
    df_resumo_iptu.reset_index(drop=True, inplace=True)

    # Aggregation and normalization logic [Same as before]
    df = df_resumo_iptu.copy()
    temp_cat_col = df["Categoria"].astype(str)
    if diferencia_predios_flag:
        temp_cat_col = temp_cat_col.str.replace(r" - Aposentado, Inativo, Pensionista, Deficiente$", "", regex=True)
        temp_cat_col = temp_cat_col.str.replace(r" - Habitações Populares$", "", regex=True)
    else:
        predial_pattern = r"Predial (Residencial|Não Residencial|Sem Dif\. por Uso)( - Aposentado, Inativo, Pensionista, Deficiente| - Habitações Populares| Isentos)?$"
        temp_cat_col = temp_cat_col.str.replace(predial_pattern, "Predial Sem Dif. por Uso", regex=True)
    temp_cat_col = temp_cat_col.str.replace(r" Isentos$", "", regex=True)
    df["CategoriaNormalizada"] = temp_cat_col
    df["Total arrecadado na faixa"] = pd.to_numeric(df["Total arrecadado na faixa"], errors="coerce").fillna(0)
    result_agg = df.groupby("CategoriaNormalizada", as_index=False).agg({"Inscrições apenas nesta faixa": "sum", "Total arrecadado na faixa": "sum"}).rename(columns={"CategoriaNormalizada": "Categoria", "Inscrições apenas nesta faixa": "Inscrições", "Total arrecadado na faixa": "Total IPTU Novo"})

    # Current tax totals calculation [Same as before]
    total_imposto_atual, total_imposto_calculado, inscricoes_com_iptu = {}, {}, {}
    for regra_nome, regra in IPTU_RULES.items():
        nome_legivel = regra["name"]
        nome_normalizado = str(nome_legivel)
        if diferencia_predios_flag:
            nome_normalizado = nome_normalizado.replace(" - Aposentado, Inativo, Pensionista, Deficiente", "")
            nome_normalizado = nome_normalizado.replace(" - Habitações Populares", "")
        else:
            if "Predial Residencial" in nome_normalizado or "Predial Não Residencial" in nome_normalizado or "Predial Sem Dif. por Uso" in nome_normalizado :
                 nome_normalizado = "Predial Sem Dif. por Uso"
        nome_normalizado = nome_normalizado.replace(" Isentos", "")
        filtro_rule = regra["rule"]
        total_imposto_atual[nome_normalizado] = total_imposto_atual.get(nome_normalizado, 0) + the_merge.loc[filtro_rule, "VLR_IMPOSTO_iptu"].fillna(0).sum()
        total_imposto_calculado[nome_normalizado] = total_imposto_calculado.get(nome_normalizado, 0) + the_merge.loc[filtro_rule, "VLR_IMPOSTO_CALCULADO_iptu"].fillna(0).sum()
        inscricoes_com_iptu[nome_normalizado] = inscricoes_com_iptu.get(nome_normalizado, 0) + (the_merge.loc[filtro_rule, "VLR_IMPOSTO_iptu"].fillna(0) > 0).sum()
        
    result_agg["Total IPTU Atual Tributado"] = result_agg["Categoria"].map(total_imposto_atual).fillna(0)
    result_agg["Total IPTU Atual Calculado"] = result_agg["Categoria"].map(total_imposto_calculado).fillna(0)
    result_agg["Inscrições com IPTU > 0"] = result_agg["Categoria"].map(inscricoes_com_iptu).fillna(0)

    # Final filtering [Same as before]
    if diferencia_estacionamentos_flag: result_agg = result_agg[result_agg["Categoria"] != "Estacionamentos Sem Dif. por Uso"]
    else: result_agg = result_agg[~result_agg["Categoria"].isin(["Estacionamentos Não Residenciais", "Estacionamentos Residenciais"])]
    if diferencia_predios_flag: result_agg = result_agg[result_agg["Categoria"] != "Predial Sem Dif. por Uso"]
    else: result_agg = result_agg[~result_agg["Categoria"].isin(["Predial Não Residencial", "Predial Residencial"])]
    cols_order = ["Categoria", "Inscrições", "Inscrições com IPTU > 0", "Total IPTU Novo", "Total IPTU Atual Tributado", "Total IPTU Atual Calculado"]
    current_cols = [col for col in cols_order if col in result_agg.columns]
    result_agg = result_agg[current_cols]

    # === FORMATTING FOR DISPLAY ===
    if 'Total arrecadado na faixa' in df_resumo_iptu.columns:
        df_resumo_iptu['Total arrecadado na faixa'] = df_resumo_iptu['Total arrecadado na faixa'].apply(lambda x: f"{x:,.2f}" if pd.notnull(x) else x)

    total_cols_to_format = [col for col in result_agg.columns if col.startswith("Total")]
    for col_name in total_cols_to_format:
        if result_agg[col_name].dtype == float or result_agg[col_name].dtype == np.float64:
             result_agg[col_name] = result_agg[col_name].apply(lambda x: f"{x:,.2f}" if pd.notnull(x) else x)

    # Calculate summary totals
    total_novo_sum = pd.to_numeric(result_agg['Total IPTU Novo'].str.replace(',', ''), errors='coerce').sum()
    total_atual_trib_sum = pd.to_numeric(result_agg['Total IPTU Atual Tributado'].str.replace(',', ''), errors='coerce').sum()
    total_atual_calc_sum = pd.to_numeric(result_agg['Total IPTU Atual Calculado'].str.replace(',', ''), errors='coerce').sum()

    total_novo_str = f"Total IPTU Novo: {total_novo_sum:,.2f}"
    total_atual_trib_str = f"Total IPTU Atual Tributado: {total_atual_trib_sum:,.2f}"
    total_atual_calc_str = f"Total IPTU Atual Calculado: {total_atual_calc_sum:,.2f}"

    # === EXCEL FILE GENERATION ===
    filename_text = ""
    download_button_result = gr.DownloadButton(visible=False)
    
    try:
        # Collect all parameters for the Excel export
        all_parameters = [
            pg_lim1, pg_alq1, pg_lim2, pg_alq2, pg_lim3, pg_alq3, pg_lim4, pg_alq4, pg_lim5, pg_alq5, pg_lim6, pg_alq6, pg_lim7, pg_alq7, pg_alq8,
            pr_lim1, pr_alq1, pr_lim2, pr_alq2, pr_lim3, pr_alq3, pr_lim4, pr_alq4, pr_lim5, pr_alq5, pr_lim6, pr_alq6, pr_lim7, pr_alq7, pr_alq8,
            pnr_lim1, pnr_alq1, pnr_lim2, pnr_alq2, pnr_lim3, pnr_alq3, pnr_lim4, pnr_alq4, pnr_lim5, pnr_alq5, pnr_lim6, pnr_alq6, pnr_lim7, pnr_alq7, pnr_alq8,
            eg_lim1, eg_alq1, eg_lim2, eg_alq2, eg_lim3, eg_alq3, eg_lim4, eg_alq4, eg_lim5, eg_alq5, eg_lim6, eg_alq6, eg_lim7, eg_alq7, eg_alq8,
            er_lim1, er_alq1, er_lim2, er_alq2, er_lim3, er_alq3, er_lim4, er_alq4, er_lim5, er_alq5, er_lim6, er_alq6, er_lim7, er_alq7, er_alq8,
            enr_lim1, enr_alq1, enr_lim2, enr_alq2, enr_lim3, enr_alq3, enr_lim4, enr_alq4, enr_lim5, enr_alq5, enr_lim6, enr_alq6, enr_lim7, enr_alq7, enr_alq8,
            t1df_lim1, t1df_alq1, t1df_alq2,
            t2df_lim1, t2df_alq1, t2df_alq2,
            t3df_lim1, t3df_alq1, t3df_alq2,
            tae_alq1,
            taf_alq1
        ]
        
        excel_file_buffer = create_excel_download(
            df_resumo_iptu, result_agg, total_novo_str, total_atual_trib_str, total_atual_calc_str,
            valor_venal_choice, ufm_value_input, diferencia_estacionamentos_flag, diferencia_predios_flag, all_parameters
        )
        
        # Calculate file size
        file_size_bytes = len(excel_file_buffer.getvalue())
        if file_size_bytes < 1024 * 1024:  # Less than 1MB
            size_str = f"{file_size_bytes / 1024:.1f} KB"
        else:
            size_str = f"{file_size_bytes / (1024 * 1024):.1f} MB"
        
        # Create timestamp in YYYYMMDD_HHMM format
        # Define the São Paulo timezone
        sao_paulo_tz = pytz.timezone("America/Sao_Paulo")
        now_sao_paulo = datetime.now(sao_paulo_tz)
        timestamp = now_sao_paulo.strftime("%Y%m%d_%H%M")
        filename = f"resultados_iptu_{timestamp}.xlsx"
        
        # Save to temporary file
        try:
            # First try the standard temp directory
            temp_dir = tempfile.gettempdir()
            temp_file_path = os.path.join(temp_dir, filename)
            
            with open(temp_file_path, 'wb') as f:
                f.write(excel_file_buffer.getvalue())
            
            # Success - update UI components
            filename_text = filename
            download_button_result = gr.DownloadButton(
                label=f"Download ({size_str})", 
                value=temp_file_path, 
                visible=True
            )
            
        except (PermissionError, OSError):
            # If that fails, try current directory (for HF Spaces)
            with open(filename, 'wb') as f:
                f.write(excel_file_buffer.getvalue())
            
            # Success - update UI components  
            filename_text = filename
            download_button_result = gr.DownloadButton(
                label=f"Download ({size_str})", 
                value=filename, 
                visible=True
            )
            
    except Exception as e:
        print(f"Erro ao criar arquivo Excel: {str(e)}")
        filename_text = ""
        download_button_result = gr.DownloadButton(visible=False)
    
    return ("Processamento concluído.", df_resumo_iptu, result_agg, total_novo_str, total_atual_trib_str, total_atual_calc_str, 
            gr.Textbox(value=filename_text, visible=bool(filename_text)), download_button_result)

# Functions to handle field visibility
def update_parking_visibility(diferencia_estacionamentos):
    """Update visibility of parking fields based on differentiation checkbox"""
    if diferencia_estacionamentos:
        # Hide EG, show ER and ENR
        return [
            gr.Accordion(visible=False),  # EG
            gr.Accordion(visible=True),   # ER
            gr.Accordion(visible=True)    # ENR
        ]
    else:
        # Show EG, hide ER and ENR
        return [
            gr.Accordion(visible=True),   # EG
            gr.Accordion(visible=False),  # ER
            gr.Accordion(visible=False)   # ENR
        ]

def update_building_visibility(diferencia_predios):
    """Update visibility of building fields based on differentiation checkbox"""
    if diferencia_predios:
        # Hide PG, show PR and PNR
        return [
            gr.Accordion(visible=False),  # PG
            gr.Accordion(visible=True),   # PR
            gr.Accordion(visible=True)    # PNR
        ]
    else:
        # Show PG, hide PR and PNR
        return [
            gr.Accordion(visible=True),   # PG
            gr.Accordion(visible=False),  # PR
            gr.Accordion(visible=False)   # PNR
        ]

# --- Gradio Interface ---
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("# Simulador de Cálculo de IPTU")
    gr.Markdown(f"Ajuste os parâmetros abaixo.")

    with gr.Row():
        with gr.Column(scale=1):
            gr.Markdown("### Parâmetros Gerais")
            valor_venal_dropdown = gr.Dropdown(choices=["VV_90", "VV_85", "VV_80", "VV_90_RED", "VV_85_RED", "VV_80_RED"], value="VV_90", label="Valor Venal Utilizado")
            ufm_input = gr.Number(value=5.771, label="Valor da UFM (2025)")
            diferencia_estacionamentos_check = gr.Checkbox(value=False, label="Diferenciar Estacionamentos por Uso?")
            diferencia_predios_check = gr.Checkbox(value=False, label="Diferenciar Prédios por Uso?")
            
            # Import functionality
            gr.Markdown("### 📥 Importar Configurações")
            gr.Markdown("*Faça upload de um arquivo Excel gerado anteriormente para restaurar todas as configurações*")
            
            with gr.Group():
                with gr.Row():
                    import_file = gr.File(
                        label="Selecionar arquivo Excel", 
                        file_types=[".xlsx"], 
                        file_count="single",
                        height=200
                    )
                with gr.Row():
                    import_button = gr.Button("🔄 Importar Parâmetros", variant="secondary", size="lg", scale=2)
                    clear_button = gr.Button("🗑️ Limpar", variant="outline", size="lg", scale=1)
                
                import_status = gr.Textbox(
                    label="Status da Importação", 
                    interactive=False, 
                    visible=False,
                    lines=2
                )
            
            gr.Markdown("### Faixas e Alíquotas Configuráveis")
            all_rate_inputs = []

            pg_defaults_lim = [25000, 60000, 100000, 140000, 200000, 300000, 600000]
            pg_defaults_aliq = [0.0, 0.004, 0.0047, 0.0055, 0.0062, 0.007, 0.0077, 0.0085]
            
            # Create accordions with visibility control
            with gr.Accordion("Predial Geral (PG)", open=False, visible=True) as pg_accordion:
                pg_inputs = create_8_band_inputs("PG", pg_defaults_lim, pg_defaults_aliq)
                all_rate_inputs.extend(pg_inputs)
            
            with gr.Accordion("Predial Residencial (PR)", open=False, visible=False) as pr_accordion:
                pr_inputs = create_8_band_inputs("PR", pg_defaults_lim, pg_defaults_aliq)
                all_rate_inputs.extend(pr_inputs)

            with gr.Accordion("Predial Não Residencial (PNR)", open=False, visible=False) as pnr_accordion:
                pnr_inputs = create_8_band_inputs("PNR", pg_defaults_lim, pg_defaults_aliq)
                all_rate_inputs.extend(pnr_inputs)

            with gr.Accordion("Estacionamentos Geral (EG)", open=False, visible=True) as eg_accordion:
                eg_inputs = create_8_band_inputs("EG", pg_defaults_lim, pg_defaults_aliq)
                all_rate_inputs.extend(eg_inputs)

            with gr.Accordion("Estacionamentos Residenciais (ER)", open=False, visible=False) as er_accordion:
                er_inputs = create_8_band_inputs("ER", pg_defaults_lim, pg_defaults_aliq)
                all_rate_inputs.extend(er_inputs)

            with gr.Accordion("Estacionamentos Não Residenciais (ENR)", open=False, visible=False) as enr_accordion:
                enr_inputs = create_8_band_inputs("ENR", pg_defaults_lim, pg_defaults_aliq)
                all_rate_inputs.extend(enr_inputs)
            
            t_df_defaults_lim = 15000
            with gr.Accordion("Terrenos 1a DF (T1DF)", open=False) as t1df_accordion:
                t1df_inputs = create_2_band_inputs("T1DF", t_df_defaults_lim, [0.0, 0.03])
                all_rate_inputs.extend(t1df_inputs)
            
            with gr.Accordion("Terrenos 2a DF (T2DF)", open=False) as t2df_accordion:
                t2df_inputs = create_2_band_inputs("T2DF", t_df_defaults_lim, [0.0, 0.02])
                all_rate_inputs.extend(t2df_inputs)

            with gr.Accordion("Terrenos 3a DF (T3DF)", open=False) as t3df_accordion:
                t3df_inputs = create_2_band_inputs("T3DF", t_df_defaults_lim, [0.0, 0.01])
                all_rate_inputs.extend(t3df_inputs)

            # TAE and TAF are always hidden as requested
            with gr.Accordion("Terrenos Alíquota Especial (TAE)", open=False, visible=False) as tae_accordion:
                tae_alq1_input = gr.Number(label="TAE Alíquota 1 (ex: 0.009)", value=0.009)
                all_rate_inputs.append(tae_alq1_input)

            with gr.Accordion("Terrenos Alíquota Fixa (TAF)", open=False, visible=False) as taf_accordion:
                taf_alq1_input = gr.Number(label="TAF Alíquota 1 (ex: 0.0095)", value=0.0095)
                all_rate_inputs.append(taf_alq1_input)

            process_button = gr.Button("Processar Dados", variant="primary")

        with gr.Column(scale=2):
            status_message = gr.Textbox(label="Status", interactive=False)
            gr.Markdown("### Resumo Detalhado por Faixa e Categoria")
            output_df_resumo = gr.DataFrame(label="Resumo por Faixa", wrap=True)
            gr.Markdown("### Resumo Agregado por Categoria")
            output_df_result = gr.DataFrame(label="Resumo Agregado", wrap=True)
            
            gr.Markdown("### Totais Gerais Calculados")
            total_novo_text = gr.Textbox(interactive=False)
            total_atual_trib_text = gr.Textbox(interactive=False)
            total_atual_calc_text = gr.Textbox(interactive=False)
            
            # Add download section
            gr.Markdown("### Download Resultados")
            filename_display = gr.Textbox(label="Arquivo gerado", interactive=False, visible=False)
            download_btn = gr.DownloadButton(label="Download", visible=False)

    # Set up visibility change handlers
    diferencia_estacionamentos_check.change(
        fn=update_parking_visibility,
        inputs=[diferencia_estacionamentos_check],
        outputs=[eg_accordion, er_accordion, enr_accordion]
    )
    
    diferencia_predios_check.change(
        fn=update_building_visibility,
        inputs=[diferencia_predios_check],
        outputs=[pg_accordion, pr_accordion, pnr_accordion]
    )

    click_inputs = [
        valor_venal_dropdown, ufm_input, 
        diferencia_estacionamentos_check, diferencia_predios_check
    ] + all_rate_inputs

    # Import function with improved feedback
    def import_parameters(file_path):
        """Import parameters from Excel file with better feedback"""
        if not file_path:
            return [gr.update() for _ in range(len(all_rate_inputs) + 5)]  # +5 for new status field
        
        try:
            # Read the parameters sheet
            df_params = pd.read_excel(file_path, sheet_name='Parâmetros Utilizados')
            
            # Extract general parameters
            valor_venal = df_params[df_params['Parâmetro'] == 'Valor Venal Utilizado']['Valor'].iloc[0]
            ufm_value = float(df_params[df_params['Parâmetro'] == 'Valor da UFM']['Valor'].iloc[0])
            diferencia_est = df_params[df_params['Parâmetro'] == 'Diferenciar Estacionamentos por Uso']['Valor'].iloc[0] == 'Sim'
            diferencia_pred = df_params[df_params['Parâmetro'] == 'Diferenciar Prédios por Uso']['Valor'].iloc[0] == 'Sim'
            
            # Extract all parameter values in order
            param_patterns = [
                # PG (15 params)
                ['PG Limite 1 (UFM)', 'PG Alíquota 1', 'PG Limite 2 (UFM)', 'PG Alíquota 2', 'PG Limite 3 (UFM)', 'PG Alíquota 3',
                 'PG Limite 4 (UFM)', 'PG Alíquota 4', 'PG Limite 5 (UFM)', 'PG Alíquota 5', 'PG Limite 6 (UFM)', 'PG Alíquota 6',
                 'PG Limite 7 (UFM)', 'PG Alíquota 7', 'PG Alíquota 8'],
                # PR (15 params)
                ['PR Limite 1 (UFM)', 'PR Alíquota 1', 'PR Limite 2 (UFM)', 'PR Alíquota 2', 'PR Limite 3 (UFM)', 'PR Alíquota 3',
                 'PR Limite 4 (UFM)', 'PR Alíquota 4', 'PR Limite 5 (UFM)', 'PR Alíquota 5', 'PR Limite 6 (UFM)', 'PR Alíquota 6',
                 'PR Limite 7 (UFM)', 'PR Alíquota 7', 'PR Alíquota 8'],
                # PNR (15 params)
                ['PNR Limite 1 (UFM)', 'PNR Alíquota 1', 'PNR Limite 2 (UFM)', 'PNR Alíquota 2', 'PNR Limite 3 (UFM)', 'PNR Alíquota 3',
                 'PNR Limite 4 (UFM)', 'PNR Alíquota 4', 'PNR Limite 5 (UFM)', 'PNR Alíquota 5', 'PNR Limite 6 (UFM)', 'PNR Alíquota 6',
                 'PNR Limite 7 (UFM)', 'PNR Alíquota 7', 'PNR Alíquota 8'],
                # EG (15 params)
                ['EG Limite 1 (UFM)', 'EG Alíquota 1', 'EG Limite 2 (UFM)', 'EG Alíquota 2', 'EG Limite 3 (UFM)', 'EG Alíquota 3',
                 'EG Limite 4 (UFM)', 'EG Alíquota 4', 'EG Limite 5 (UFM)', 'EG Alíquota 5', 'EG Limite 6 (UFM)', 'EG Alíquota 6',
                 'EG Limite 7 (UFM)', 'EG Alíquota 7', 'EG Alíquota 8'],
                # ER (15 params)
                ['ER Limite 1 (UFM)', 'ER Alíquota 1', 'ER Limite 2 (UFM)', 'ER Alíquota 2', 'ER Limite 3 (UFM)', 'ER Alíquota 3',
                 'ER Limite 4 (UFM)', 'ER Alíquota 4', 'ER Limite 5 (UFM)', 'ER Alíquota 5', 'ER Limite 6 (UFM)', 'ER Alíquota 6',
                 'ER Limite 7 (UFM)', 'ER Alíquota 7', 'ER Alíquota 8'],
                # ENR (15 params)
                ['EN Limite 1 (UFM)', 'EN Alíquota 1', 'EN Limite 2 (UFM)', 'EN Alíquota 2', 'EN Limite 3 (UFM)', 'EN Alíquota 3',
                 'EN Limite 4 (UFM)', 'EN Alíquota 4', 'EN Limite 5 (UFM)', 'EN Alíquota 5', 'EN Limite 6 (UFM)', 'EN Alíquota 6',
                 'EN Limite 7 (UFM)', 'EN Alíquota 7', 'EN Alíquota 8'],
                # T1DF (3 params)
                ['T1DF Limite 1 (UFM)', 'T1DF Alíquota 1', 'T1DF Alíquota 2'],
                # T2DF (3 params)
                ['T2DF Limite 1 (UFM)', 'T2DF Alíquota 1', 'T2DF Alíquota 2'],
                # T3DF (3 params)
                ['T3DF Limite 1 (UFM)', 'T3DF Alíquota 1', 'T3DF Alíquota 2'],
                # TAE (1 param)
                ['TAE Alíquota 1'],
                # TAF (1 param)
                ['TAF Alíquota 1']
            ]
            
            # Flatten the patterns list
            all_param_names = []
            for group in param_patterns:
                all_param_names.extend(group)
            
            # Extract values for each parameter
            param_values = []
            missing_params = []
            for param_name in all_param_names:
                try:
                    value = df_params[df_params['Parâmetro'] == param_name]['Valor'].iloc[0]
                    param_values.append(float(value) if pd.notnull(value) else 0.0)
                except (IndexError, ValueError):
                    param_values.append(0.0)  # Default value if not found
                    missing_params.append(param_name)
            
            # Create success message
            if missing_params:
                status_msg = f"✅ Importação concluída com avisos!\n⚠️ {len(missing_params)} parâmetros não encontrados (valores padrão aplicados)"
            else:
                status_msg = f"✅ Importação concluída com sucesso!\n📊 {len(param_values)} parâmetros importados"
            
            # Return updates for all components
            updates = [
                gr.update(value=valor_venal),      # valor_venal_dropdown
                gr.update(value=ufm_value),        # ufm_input
                gr.update(value=diferencia_est),   # diferencia_estacionamentos_check
                gr.update(value=diferencia_pred),  # diferencia_predios_check
                gr.update(value=status_msg, visible=True)  # import_status
            ]
            
            # Add updates for all rate inputs
            for i, value in enumerate(param_values):
                if i < len(all_rate_inputs):
                    updates.append(gr.update(value=value))
                else:
                    break
            
            # Pad with no-change updates if needed
            while len(updates) < len(all_rate_inputs) + 5:
                updates.append(gr.update())
            
            return updates
            
        except Exception as e:
            error_msg = f"❌ Erro na importação:\n{str(e)}"
            updates = [
                gr.update(),  # valor_venal_dropdown - no change
                gr.update(),  # ufm_input - no change
                gr.update(),  # diferencia_estacionamentos_check - no change
                gr.update(),  # diferencia_predios_check - no change
                gr.update(value=error_msg, visible=True)  # import_status
            ]
            # Add no-change updates for all rate inputs
            updates.extend([gr.update() for _ in range(len(all_rate_inputs))])
            return updates

    # Clear function
    def clear_all_parameters():
        """Reset all parameters to default values"""
        pg_defaults_lim = [25000, 60000, 100000, 140000, 200000, 300000, 600000]
        pg_defaults_aliq = [0.0, 0.004, 0.0047, 0.0055, 0.0062, 0.007, 0.0077, 0.0085]
        t_df_defaults_lim = 15000
        
        # Default values for all parameters
        default_values = []
        # PG (15 params)
        for i in range(7):
            default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]])
        default_values.append(pg_defaults_aliq[7])
        # PR (15 params) - same as PG
        for i in range(7):
            default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]])
        default_values.append(pg_defaults_aliq[7])
        # PNR (15 params) - same as PG
        for i in range(7):
            default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]])
        default_values.append(pg_defaults_aliq[7])
        # EG (15 params) - same as PG
        for i in range(7):
            default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]])
        default_values.append(pg_defaults_aliq[7])
        # ER (15 params) - same as PG
        for i in range(7):
            default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]])
        default_values.append(pg_defaults_aliq[7])
        # ENR (15 params) - same as PG
        for i in range(7):
            default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]])
        default_values.append(pg_defaults_aliq[7])
        # T1DF (3 params)
        default_values.extend([t_df_defaults_lim, 0.0, 0.03])
        # T2DF (3 params)
        default_values.extend([t_df_defaults_lim, 0.0, 0.02])
        # T3DF (3 params)
        default_values.extend([t_df_defaults_lim, 0.0, 0.01])
        # TAE (1 param)
        default_values.append(0.009)
        # TAF (1 param)
        default_values.append(0.0095)
        
        updates = [
            gr.update(value="VV_90"),      # valor_venal_dropdown
            gr.update(value=5.771),        # ufm_input
            gr.update(value=False),        # diferencia_estacionamentos_check
            gr.update(value=False),        # diferencia_predios_check
            gr.update(value="🔄 Parâmetros resetados para valores padrão", visible=True)  # import_status
        ]
        
        # Add updates for all rate inputs
        for i, value in enumerate(default_values):
            if i < len(all_rate_inputs):
                updates.append(gr.update(value=value))
            else:
                break
        
        # Pad with no-change updates if needed
        while len(updates) < len(all_rate_inputs) + 5:
            updates.append(gr.update())
        
        return updates

    # Set up import and clear button clicks
    import_button.click(
        fn=import_parameters,
        inputs=[import_file],
        outputs=[valor_venal_dropdown, ufm_input, diferencia_estacionamentos_check, diferencia_predios_check, import_status] + all_rate_inputs
    )
    
    clear_button.click(
        fn=clear_all_parameters,
        inputs=[],
        outputs=[valor_venal_dropdown, ufm_input, diferencia_estacionamentos_check, diferencia_predios_check, import_status] + all_rate_inputs
    )

    process_button.click(
        fn=process_iptu_data,
        inputs=click_inputs,
        outputs=[status_message, output_df_resumo, output_df_result, 
                 total_novo_text, total_atual_trib_text, total_atual_calc_text, filename_display, download_btn]
    )
    
    gr.Markdown(f"""
    ## 📋 Instruções:
    
    ### 🎯 Fluxo Básico:
    1. **⚙️ Parâmetros Gerais**: Configure valor venal, UFM e flags de diferenciação
    2. **📊 Faixas e Alíquotas**: Ajuste limites (em UFM) e alíquotas (ex: 0.004 = 0.4%)
    3. **▶️ Processar**: Clique em "Processar Dados" para calcular
    4. **💾 Download**: Baixe os resultados completos em Excel
    
    ### 🔄 Import/Export de Configurações:
    - **📥 Importar**: Faça upload de arquivo Excel gerado anteriormente
    - **🗑️ Limpar**: Reset todos os parâmetros para valores padrão  
    
    ### 📊 Conteúdo do Excel:
    - **📈 Resumo Detalhado**: Dados por faixa e categoria
    - **📋 Resumo Agregado**: Totais por categoria principal  
    - **💰 Totais Gerais**: Sumário dos valores calculados
    - **⚙️ Parâmetros Utilizados**: Configurações completas (reimportáveis)
    
    ### 🎛️ Controles de Visibilidade:
    - **Estacionamentos**: Marque "Diferenciar por Uso" para mostrar campos ER/ENR em vez de EG
    - **Prédios**: Marque "Diferenciar por Uso" para mostrar campos PR/PNR em vez de PG
    - **TAE/TAF**: Campos sempre ocultos (configurados internamente)
    """)

if __name__ == "__main__":
    demo.launch()