Update app.py

app.py

@@ -6,14 +6,14 @@ import folium
 from streamlit_folium import st_folium
 from folium.plugins import MarkerCluster
 from sklearn.ensemble import RandomForestRegressor
-from sklearn.cluster import KMeans
 from wordcloud import WordCloud
 import matplotlib.pyplot as plt
 import unicodedata
 
-# --- CONFIGURAÇÃO E ESTILO DA PÁGINA ---
+# --- CONFIGURAÇÃO DA PÁGINA ---
 st.set_page_config(page_title="Airbnb Intelligence Pro", layout="wide", page_icon="🏘️")
 
+# --- CSS CUSTOMIZADO ---
 st.markdown("""
 <style>
     .metric-card {
@@ -23,184 +23,157 @@ st.markdown("""
         border-radius: 5px;
         box-shadow: 1px 1px 3px rgba(0,0,0,0.1);
     }
-    h1, h2, h3 { color: #2c3e50; } 
     .stExpander { border: 1px solid #ddd; border-radius: 5px; background-color: #ffffff; }
 </style>
 """, unsafe_allow_html=True)
 
-# --- FUNÇÕES UTILITÁRIAS ---
-
+# --- FUNÇÃO DE NORMALIZAÇÃO DE TEXTO ---
 def normalizar_texto(texto):
-    """Remove acentos e minúsculo para garantir merge correto (Ex: Floriánópolis -> florianopolis)."""
+    """Remove acentos e coloca em minúsculo para garantir merge correto."""
     if pd.isna(texto): return ""
     nfkd = unicodedata.normalize('NFKD', str(texto))
     return u"".join([c for c in nfkd if not unicodedata.combining(c)]).lower().strip()
 
-# --- CARREGAMENTO E LIMPEZA DE DADOS (CACHING) ---
+# --- CARREGAMENTO E LIMPEZA (CACHEADO) ---
 @st.cache_data
 def load_data():
-    """Carrega, limpa e calcula os KPIs financeiros a partir de todos os CSVs."""
     try:
+        # Carregamento dos arquivos
         df = pd.read_csv('lisitng_geral.csv', sep=';', encoding='utf-8')
         fipe = pd.read_csv('fipezap_geral.csv', sep=';', encoding='utf-8')
         past = pd.read_csv('past_geral.csv', sep=';', encoding='utf-8')
         seg = pd.read_csv('casos_homicidios.csv', sep=';', encoding='utf-8')
     except FileNotFoundError:
-        st.error("ERRO CRÍTICO: Arquivos CSV não encontrados.")
+        st.error("ERRO: Arquivos CSV não encontrados. Faça o upload no Hugging Face.")
         st.stop()
 
-    # 1. Limpeza Crítica de Coordenadas (CORREÇÃO BH/Curitiba/POA)
+    # --- 1. LIMPEZA DE COORDENADAS (Sua Lógica Solicitada) ---
+    # Garante que BH, Curitiba e POA apareçam
     cols_coords = ['latitude', 'longitude']
     for col in cols_coords:
         if df[col].dtype == 'object':
-            df[col] = df[col].astype(str).str.replace(',', '.').astype(float)
-    df = df.dropna(subset=cols_coords)
+            df[col] = df[col].str.replace(',', '.').astype(float)
     
-    # 2. Limpeza e Normalização de Finanças/Cidades
+    # Remove linhas sem coordenada (essencial para o mapa não quebrar)
+    df = df.dropna(subset=cols_coords)
+    # ---------------------------------------------------------
+
+    # 2. Limpeza Financeira
     cols_fin = ['ttm_revenue_native', 'ttm_avg_rate_native', 'ttm_occupancy', 'rating_overall']
     for col in cols_fin:
-        if df[col].dtype == 'object':
+        if col in df.columns and df[col].dtype == 'object':
             df[col] = df[col].astype(str).str.replace('R$', '').str.replace('.', '').str.replace(',', '.').astype(float)
-    
+
+    # Normalização de Cidades
     df['city_norm'] = df['city'].apply(normalizar_texto)
-    df['city'] = df['city'].str.title() 
+    df['city'] = df['city'].str.title() # Deixar bonito para visualização
+
+    # Imputação de Nulos (Quartos/Hóspedes)
     df['bedrooms'] = df['bedrooms'].fillna(df.groupby(['city', 'room_type'])['bedrooms'].transform('median')).fillna(1)
-    
-    # 3. Cálculo de ROI (Cruzando FIPEZAP)
+    df['guests'] = df['guests'].fillna(df.groupby(['city', 'room_type'])['guests'].transform('median')).fillna(2)
+
+    # 3. Limpeza e Merge FipeZap
+    fipe = fipe.dropna(subset=['city', 'preco_m2'])
+    fipe = fipe.loc[:, ~fipe.columns.str.contains('^Unnamed')]
     fipe['city_norm'] = fipe['city'].apply(normalizar_texto)
+    
+    # Merge Preço m2
     media_cidade = fipe.groupby('city_norm')['preco_m2'].mean().to_dict()
-    df['preco_m2_estimado'] = df['city_norm'].map(media_cidade).fillna(fipe['preco_m2'].mean())
-    df['metragem_estimada'] = df['bedrooms'].apply(lambda n: 45 if n <= 1 else (75 if n == 2 else 110))
+    df['preco_m2_estimado'] = df['city_norm'].map(media_cidade)
+    # Fallback: Média geral se não achar a cidade
+    df['preco_m2_estimado'] = df['preco_m2_estimado'].fillna(fipe['preco_m2'].mean())
+
+    # 4. Cálculos de KPI (ROI)
+    def estimar_metragem(n):
+        return 45 if n <= 1 else (75 if n == 2 else 110)
+    
+    df['metragem_estimada'] = df['bedrooms'].apply(estimar_metragem)
     df['valor_imovel_estimado'] = df['metragem_estimada'] * df['preco_m2_estimado']
     
+    # Blindagem contra divisão por zero
     df['ROI_anual'] = (df['ttm_revenue_native'] / df['valor_imovel_estimado']) * 100
-    df['ROI_anual'] = df['ROI_anual'].replace([np.inf, -np.inf], 0).fillna(0) # Blindagem
+    df['ROI_anual'] = df['ROI_anual'].replace([np.inf, -np.inf], 0).fillna(0)
+
+    # Score e Recomendação IA
+    def normalize(series):
+        return (series - series.min()) / (series.max() - series.min())
     
-    # 4. Score e Recomendação
-    def normalize(series): return (series - series.min()) / (series.max() - series.min())
     df['Score'] = ((normalize(df['ROI_anual']) * 60) + (normalize(df['rating_overall'].fillna(0)) * 40)) * 100
-    df['Recomendacao'] = df.apply(lambda row: "💎 COMPRA RECOMENDADA" if row['Score'] >= 60 else ("✅ POTENCIAL" if row['Score'] >= 40 else "❌ NÃO RECOMENDADO"), axis=1)
 
-    # 5. Merge Segurança
+    def gerar_laudo(row):
+        if row['Score'] >= 60: return "💎 COMPRA RECOMENDADA"
+        elif row['Score'] >= 40: return "✅ POTENCIAL"
+        elif row['Score'] >= 20: return "⚠️ ARRISCADO"
+        else: return "❌ NÃO RECOMENDADO"
+    
+    df['Recomendacao'] = df.apply(gerar_laudo, axis=1)
+
+    # 5. Limpeza e Merge Segurança
     seg['city_norm'] = seg['city'].apply(normalizar_texto)
     seg_recent = seg.sort_values('date', ascending=False).groupby('city_norm')['Homicidios'].first().reset_index()
+    
     df = pd.merge(df, seg_recent, on='city_norm', how='left')
-    df['Homicidios'] = df['Homicidios'].fillna(-1) # -1 para indicar sem dados
+    df['Homicidios'] = df['Homicidios'].fillna(-1) # -1 indica sem dados
 
-    # 6. Preparação Histórico (para Sazonalidade)
+    # 6. Limpeza Histórico (Past)
     past['date'] = pd.to_datetime(past['date'], format='%d/%m/%Y', errors='coerce')
     past['city_norm'] = past['city'].apply(normalizar_texto)
 
     return df, past
 
-# --- TREINAMENTO MODELO IA E CLUSTERING (CACHING) ---
+# --- TREINAMENTO MODELO IA ---
 @st.cache_resource
-def train_and_cluster(df):
-    """Treina os modelos de predição de Receita e Preço e aplica K-Means para nichos."""
+def train_model(df):
     df_model = df[df['ttm_revenue_native'] > 0].copy()
+    features = ['bedrooms', 'guests', 'num_reviews', 'latitude', 'longitude']
     
+    # Feature Engineering Simples
     df_model['is_superhost'] = df_model['superhost'].astype(str).apply(lambda x: 1 if x.upper() in ['VERDADEIRO', 'TRUE'] else 0)
     df_model['has_pool'] = df_model['amenities'].astype(str).str.contains('pool|Piscina', case=False).astype(int)
     
-    features = ['bedrooms', 'guests', 'num_reviews', 'latitude', 'longitude', 'is_superhost', 'has_pool', 'ROI_anual']
-    
-    X = df_model[features]
+    X = df_model[features + ['is_superhost', 'has_pool']]
+    # One Hot Encoding
     X = pd.concat([X, pd.get_dummies(df_model['city'], prefix='city')], axis=1)
     X = pd.concat([X, pd.get_dummies(df_model['room_type'], prefix='type')], axis=1)
-    y_rev = df_model['ttm_revenue_native']
-    y_adr = df_model['ttm_avg_rate_native'] 
-    
-    # Treinamento de Modelos
-    model_rev = RandomForestRegressor(n_estimators=40, random_state=42).fit(X, y_rev)
-    model_adr = RandomForestRegressor(n_estimators=40, random_state=42).fit(X, y_adr)
-    
-    # Calculo do GAP de ADR para Clustering
-    df_model['ADR_Predito'] = model_adr.predict(X)
-    df_model['ADR_GAP'] = df_model['ADR_Predito'] - df_model['ttm_avg_rate_native']
-
-    # Clustering (K-Means)
-    X_cluster = df_model[['latitude', 'longitude', 'ROI_anual', 'ttm_avg_rate_native']].dropna()
-    scaler = X_cluster.copy()
-    for col in scaler.columns: 
-        scaler[col] = (scaler[col] - scaler[col].mean()) / scaler[col].std()
-
-    kmeans = KMeans(n_clusters=5, random_state=42, n_init='auto').fit(scaler)
-    df_model['Cluster_Mercado'] = kmeans.labels_
-    
-    return df_model, model_rev, model_adr, X.columns
-
-# --- FUNÇÕES DE RENDERIZAÇÃO (REUSÁVEIS) ---
-
-def render_property_card(df_row, title="Ficha Técnica"):
-    """Renderiza a ficha técnica detalhada de um único imóvel."""
-    if df_row is None or df_row.empty:
-        st.info("Clique em um ponto no mapa ou selecione um imóvel.")
-        return
-    
-    row = df_row.iloc[0] # Pega a primeira (e única) linha
-    
-    st.markdown(f"""
-    <div style="background-color: #f0f2f6; padding: 20px; border-radius: 10px; border: 1px solid #ccc;">
-        <h3 style='margin-top: 0px;'>{title}</h3>
-    </div>
-    """, unsafe_allow_html=True)
+    y = df_model['ttm_revenue_native']
     
-    c_img, c_info, c_kpi = st.columns([1, 1, 1])
-    
-    with c_img:
-        if pd.notna(row['cover_photo_url']):
-            st.image(row['cover_photo_url'], use_container_width=True)
-        else:
-            st.info("Sem foto disponível")
-    
-    with c_info:
-        st.write(f"**Cidade:** {row['city']}")
-        st.write(f"**Tipo:** {row['room_type']}")
-        st.write(f"**Acomoda:** {int(row['guests'])} pessoas")
-        st.write(f"**Quartos:** {int(row['bedrooms'])}")
-        st.metric("Nota Geral", f"⭐ {row['rating_overall']:.2f}")
-
-    with c_kpi:
-        st.metric("Faturamento Anual", f"R$ {row['ttm_revenue_native']:,.0f}")
-        st.metric("ROI Estimado", f"{row['ROI_anual']:.1f}%")
-        st.metric("Preço Imóvel Est.", f"R$ {row['valor_imovel_estimado']:,.0f}")
-        
-        status = row['Recomendacao']
-        if "COMPRA" in status:
-            st.success(f"## {status}")
-        else:
-            st.warning(f"## {status}")
-
-# --- INÍCIO DA APLICAÇÃO ---
+    model = RandomForestRegressor(n_estimators=40, random_state=42)
+    model.fit(X, y)
+    return model, X.columns
 
+# --- CARREGAMENTO ---
 df, df_past = load_data()
-df_model_comp, model_rev, model_adr, model_cols = train_and_cluster(df)
+model, model_cols = train_model(df)
 
-# --- SIDEBAR (FILTROS) ---
+# --- INTERFACE: SIDEBAR ---
 st.sidebar.image("https://upload.wikimedia.org/wikipedia/commons/6/69/Airbnb_Logo_Bélo.svg", width=140)
 st.sidebar.header("Navegação")
-page = st.sidebar.radio("", ["📊 Dashboard de Mercado", "🤖 Simulador IA"])
+page = st.sidebar.radio("", ["📊 Análise de Mercado", "🤖 Simulador IA"])
 
 st.sidebar.markdown("---")
 st.sidebar.header("Filtros")
 
+# Filtro Cidades
 cidades_disponiveis = sorted(df['city'].unique())
 cidades_sel = st.sidebar.multiselect("Cidades:", cidades_disponiveis, default=cidades_disponiveis)
 
+# Filtro Quartos
 quartos = st.sidebar.slider("Quartos:", 0, 8, (0, 8))
-usar_seguranca = st.sidebar.checkbox("🛡️ Filtrar por Segurança", value=False)
 
+# Filtro Segurança (Opcional)
+usar_seguranca = st.sidebar.checkbox("🛡️ Filtrar por Segurança", value=False)
 if usar_seguranca:
-    max_homicidios = int(df[df['Homicidios'] >= 0]['Homicidios'].max()) if not df.empty else 1
+    max_homicidios = int(df[df['Homicidios'] >= 0]['Homicidios'].max())
     filtro_homicidios = st.sidebar.slider("Máx Homicídios/Ano:", 0, max_homicidios, max_homicidios)
 
+# Filtro Outliers
 esconder_outliers = st.sidebar.checkbox("Ocultar Outliers (Preço)", value=True)
 
-# --- APLICAÇÃO DOS FILTROS ---
+# APLICAÇÃO DOS FILTROS
 df_filtered = df[
     (df['city'].isin(cidades_sel)) & 
     (df['bedrooms'].between(quartos[0], quartos[1]))
-].copy()
+]
 
 if usar_seguranca:
     df_filtered = df_filtered[(df_filtered['Homicidios'] >= 0) & (df_filtered['Homicidios'] <= filtro_homicidios)]
@@ -212,60 +185,104 @@ if esconder_outliers:
     if pd.notna(IQR):
         df_filtered = df_filtered[df_filtered['ttm_avg_rate_native'] <= (Q3 + 1.5 * IQR)]
 
-
-# --- PÁGINA 1: DASHBOARD DE MERCADO ---
-
-if page == "📊 Dashboard de Mercado":
-    st.title("📍 Inteligência Imobiliária Airbnb Pro")
+# --- PÁGINA 1: DASHBOARD ---
+if page == "📊 Análise de Mercado":
+    st.title("📍 Inteligência Imobiliária Airbnb")
     
     # 1. KPIs
     kpi1, kpi2, kpi3, kpi4 = st.columns(4)
-    kpi1.metric("Imóveis Filtrados", len(df_filtered))
-    kpi2.metric("Preço Diária (Mediana)", f"R$ {df_filtered['ttm_avg_rate_native'].median():.0f}")
-    kpi3.metric("Faturamento Anual (Médio)", f"R$ {df_filtered['ttm_revenue_native'].mean():,.0f}")
+    kpi1.metric("Imóveis", len(df_filtered))
+    kpi2.metric("Preço Médio", f"R$ {df_filtered['ttm_avg_rate_native'].median():.0f}")
+    kpi3.metric("Faturamento Médio", f"R$ {df_filtered['ttm_revenue_native'].mean():,.0f}")
     kpi4.metric("ROI Médio", f"{df_filtered['ROI_anual'].median():.1f}% a.a.")
     
     st.markdown("---")
 
-    # 2. MAPA INTERATIVO (Folium Limpo)
+    # 2. MAPA (Folium Limpo)
     st.subheader("Mapa de Oportunidades")
-    st.caption("Passe o mouse para ver o preço. Clique no ponto para ver a Ficha Técnica abaixo.")
+    st.caption("Passe o mouse para ver o preço. Clique para ver detalhes abaixo.")
     
     if not df_filtered.empty:
         center_lat = df_filtered['latitude'].mean()
         center_lon = df_filtered['longitude'].mean()
-        m = folium.Map(location=[center_lat, center_lon], zoom_start=11, tiles='CartoDB positron')
+        
+        # Mapa estilo 'CartoDB positron' para ser limpo e legível
+        m = folium.Map(location=[center_lat, center_lon], zoom_start=12, tiles='CartoDB positron')
         marker_cluster = MarkerCluster().add_to(m)
         
+        # Adicionar pontos (Limitado a 1000 para performance)
         for idx, row in df_filtered.head(1000).iterrows():
+            # Cor baseada na recomendação
             color = '#2ecc71' if row['Recomendacao'] == "💎 COMPRA RECOMENDADA" else '#3498db'
             
             folium.CircleMarker(
                 location=[row['latitude'], row['longitude']],
-                radius=7, color=color, fill=True, fill_color=color, fill_opacity=0.8,
-                popup=row['listing_name'], # Chave de retorno para o clique
-                tooltip=f"{row['listing_name']}: R$ {row['ttm_avg_rate_native']:.0f}"
+                radius=7,
+                color=color,
+                fill=True,
+                fill_color=color,
+                fill_opacity=0.8,
+                popup=row['listing_name'], # Chave para identificar o clique
+                tooltip=f"R$ {row['ttm_avg_rate_native']:.0f}/noite"
             ).add_to(marker_cluster)
         
+        # Renderizar mapa e capturar clique
         map_data = st_folium(m, height=500, width="100%")
     else:
-        st.warning("Sem dados para exibir no mapa com os filtros atuais.")
+        st.warning("Sem dados para exibir no mapa.")
         map_data = None
 
-    # 3. PAINEL DE DETALHES (RENDERIZAÇÃO DO CLIQUE ABAIXO DO MAPA)
-    st.markdown("---")
-    st.subheader("📋 Ficha Técnica Detalhada")
+    # 3. DETALHES DO IMÓVEL (ABAIXO DO MAPA)
+    st.markdown("### 📋 Ficha Técnica do Imóvel")
     
     selected_listing = None
     if map_data and map_data.get('last_object_clicked_popup'):
         name_clicked = map_data['last_object_clicked_popup']
         match = df_filtered[df_filtered['listing_name'] == name_clicked]
         if not match.empty:
-            selected_listing = match
+            selected_listing = match.iloc[0]
+
+    if selected_listing is not None:
+        with st.container():
+            st.markdown(f"""
+            <div style="background-color: #f0f2f6; padding: 20px; border-radius: 10px; border: 1px solid #ccc;">
+                <h3>🏡 {selected_listing['listing_name']}</h3>
+            </div>
+            """, unsafe_allow_html=True)
             
-    render_property_card(selected_listing)
+            c_img, c_info, c_kpi = st.columns([1, 1, 1])
+            
+            with c_img:
+                if pd.notna(selected_listing['cover_photo_url']):
+                    st.image(selected_listing['cover_photo_url'], use_container_width=True)
+                else:
+                    st.info("Sem foto disponível")
+            
+            with c_info:
+                st.write(f"**Cidade:** {selected_listing['city']}")
+                st.write(f"**Tipo:** {selected_listing['room_type']}")
+                st.write(f"**Acomoda:** {int(selected_listing['guests'])} pessoas")
+                st.write(f"**Quartos:** {int(selected_listing['bedrooms'])}")
+                st.metric("Nota Geral", f"⭐ {selected_listing['rating_overall']}")
+
+            with c_kpi:
+                st.metric("Faturamento Anual", f"R$ {selected_listing['ttm_revenue_native']:,.2f}")
+                st.metric("ROI Estimado", f"{selected_listing['ROI_anual']:.2f}%")
+                
+                status = selected_listing['Recomendacao']
+                if "COMPRA" in status:
+                    st.success(f"## {status}")
+                elif "NÃO" in status:
+                    st.error(f"## {status}")
+                else:
+                    st.warning(f"## {status}")
+
+    else:
+        st.info("👆 Clique em uma bolinha colorida no mapa acima para ver a análise completa do imóvel aqui.")
+
+    st.markdown("---")
 
-    # 4. GRÁFICOS V.1 (VISÍVEIS)
+    # 4. GRÁFICOS VISUAIS (Estilo Código 1)
     col_g1, col_g2 = st.columns(2)
     
     with col_g1:
@@ -276,45 +293,45 @@ if page == "📊 Dashboard de Mercado":
         
     with col_g2:
         st.subheader("💎 Qualidade vs. Faturamento")
+        # Proteção contra erro de tamanho NaN
         df_filtered['size_safe'] = df_filtered['ROI_anual'].apply(lambda x: max(0.1, x))
         fig_scat = px.scatter(df_filtered, x="rating_overall", y="ttm_revenue_native", 
                               size="size_safe", color="room_type",
                               title="Nota x Receita (Tamanho = ROI)", hover_name="listing_name")
         st.plotly_chart(fig_scat, use_container_width=True)
 
+    # 5. ANÁLISES AVANÇADAS (EXPANDER)
     st.markdown("---")
-    
-    # 5. ANÁLISES AVANÇADAS (EXPANDER V.2)
-    with st.expander("🔬 Ver Análises Avançadas (Sazonalidade, Segurança e Clustering)"):
+    with st.expander("🔬 Ver Análises Avançadas (Sazonalidade, Segurança e Palavras-Chave)"):
         
-        tab1, tab2, tab3, tab4 = st.tabs(["📅 Sazonalidade", "🛡️ Risco/Segurança", "☁️ Palavras-Chave", "⚔️ Comparador"])
+        tab1, tab2, tab3 = st.tabs(["📅 Sazonalidade", "🛡️ Segurança", "☁️ Palavras-Chave"])
         
         with tab1:
             st.markdown("##### Ocupação Mensal Histórica")
+            # Filtra histórico usando city_norm para garantir match
             cidades_norm = [normalizar_texto(c) for c in cidades_sel]
             past_filtered = df_past[df_past['city_norm'].isin(cidades_norm)].copy()
             
             if not past_filtered.empty:
                 past_filtered['month'] = past_filtered['date'].dt.strftime('%Y-%m')
-                seasonal = past_filtered.groupby('month')['occupancy_real'].mean().reset_index()
-                fig_line = px.line(seasonal, x='month', y='occupancy_real', markers=True)
+                seasonal = past_filtered.groupby('month')['occupancy'].mean().reset_index()
+                fig_line = px.line(seasonal, x='month', y='occupancy', markers=True)
                 st.plotly_chart(fig_line, use_container_width=True)
             else:
-                st.info("Histórico de sazonalidade não disponível.")
+                st.warning("Sem dados históricos para as cidades selecionadas.")
                 
         with tab2:
-            st.markdown("##### Segurança vs Retorno")
-            df_seg_plot = df_filtered[df_filtered['Homicidios'] >= 0].copy()
+            st.markdown("##### Segurança vs Retorno Financeiro")
+            df_seg_plot = df_filtered[df_filtered['Homicidios'] >= 0]
             if not df_seg_plot.empty:
-                df_seg_plot['Tamanho_Bolha'] = df_seg_plot['ROI_anual'].apply(lambda x: max(0.1, x))
                 fig_seg = px.scatter(df_seg_plot, x="Homicidios", y="ttm_revenue_native", 
-                                     color="city", size="Tamanho_Bolha", hover_name="listing_name")
+                                     color="city", size="size_safe", hover_name="listing_name")
                 st.plotly_chart(fig_seg, use_container_width=True)
             else:
-                st.warning("Sem dados de segurança para exibir.")
+                st.warning("Cidades selecionadas não possuem dados de homicídios no arquivo.")
                 
         with tab3:
-            st.markdown("##### O que os Melhores Imóveis (Diamantes) Têm?")
+            st.markdown("##### O que os Melhores Imóveis têm?")
             top_performers = df_filtered[df_filtered['Recomendacao'] == "💎 COMPRA RECOMENDADA"]
             text = " ".join(str(a) for a in top_performers['amenities'].dropna())
             if text.strip():
@@ -324,72 +341,64 @@ if page == "📊 Dashboard de Mercado":
                 ax.axis("off")
                 st.pyplot(fig)
             else:
-                st.info("Não há Top Performers suficientes.")
-
-        with tab4:
-            st.markdown("##### Comparador Lado a Lado")
-            
-            all_listings = df_filtered['listing_name'].unique().tolist()
-            col_sel1, col_sel2 = st.columns(2)
-            
-            with col_sel1:
-                sel_1 = st.selectbox("Imóvel 1:", all_listings, index=None, key='comp1')
-            with col_sel2:
-                sel_2 = st.selectbox("Imóvel 2:", all_listings, index=None, key='comp2')
-                
-            st.markdown("---")
-            
-            col_comp1, col_comp_spacer, col_comp2 = st.columns([1, 0.1, 1])
-            
-            if sel_1:
-                comp_1 = df_filtered[df_filtered['listing_name'] == sel_1]
-                with col_comp1:
-                    render_property_card(comp_1, title="Imóvel 1")
-            
-            if sel_2:
-                comp_2 = df_filtered[df_filtered['listing_name'] == sel_2]
-                with col_comp2:
-                    render_property_card(comp_2, title="Imóvel 2")
+                st.info("Não há Top Performers suficientes para gerar a nuvem.")
 
-# --- PÁGINA 2: SIMULADOR IA ---
+# --- PÁGINA 2: SIMULADOR ---
 elif page == "🤖 Simulador IA":
-    st.title("🤖 Oráculo de Investimentos e Cluster")
+    st.title("🤖 Simulador de Investimento & IA")
     
-    tab_sim, tab_calc, tab_cluster = st.tabs(["🔮 Previsão com IA", "💰 Lucro Líquido", "🗺️ Nichos de Mercado"])
+    col_ia, col_calc = st.columns(2)
     
-    with tab_sim:
-        # Lógica de Previsão de Receita (Revenue Prediction)
-        col_input, col_result = st.columns([1, 1])
-        # ... (código de input e previsão se mantém) ...
-        
-    with tab_calc:
-        # Lógica de Calculadora de Lucro Líquido
-        # ... (código de input e cálculo se mantém) ...
+    with col_ia:
+        st.subheader("🔮 Previsão de Receita (IA)")
+        sim_city = st.selectbox("Cidade:", sorted(df['city'].unique()))
+        sim_type = st.selectbox("Tipo:", df['room_type'].unique())
+        sim_bed = st.slider("Quartos:", 0, 8, 2)
+        sim_guest = st.slider("Hóspedes:", 1, 16, 4)
+        sim_pool = st.checkbox("Tem Piscina?", value=False)
+        sim_super = st.checkbox("Será Superhost?", value=True)
         
-    with tab_cluster:
-        st.markdown("### 🗺️ Análise de Nichos de Mercado (Clustering)")
-        st.caption("Agrupamentos baseados em Localização, Preço e ROI. Cada cluster representa um 'nicho' diferente de mercado.")
-        
-        # Gráfico de Dispersão do Cluster
-        df_plot = df_model_comp.head(2000).dropna(subset=['Cluster_Mercado', 'ROI_anual', 'ttm_avg_rate_native', 'ADR_GAP'])
-        fig_cluster = px.scatter(df_plot, 
-                                 x='ROI_anual', 
-                                 y='ttm_avg_rate_native', 
-                                 color='Cluster_Mercado',
-                                 hover_data=['city', 'ROI_anual', 'ADR_GAP'],
-                                 title="Clusters por ROI vs Preço (Cor = Nicho)")
-        st.plotly_chart(fig_cluster, use_container_width=True)
+        if st.button("Calcular Previsão"):
+            # Monta input
+            base_lat = df[df['city'] == sim_city]['latitude'].mean()
+            base_lon = df[df['city'] == sim_city]['longitude'].mean()
+            if pd.isna(base_lat): base_lat = -23.55 # Fallback
+            if pd.isna(base_lon): base_lon = -46.63
+            
+            input_df = pd.DataFrame({
+                'bedrooms': [sim_bed], 'guests': [sim_guest], 
+                'num_reviews': [30], 'latitude': [base_lat], 'longitude': [base_lon],
+                'is_superhost': [1 if sim_super else 0],
+                'has_pool': [1 if sim_pool else 0]
+            })
+            
+            # One Hot Encoding Manual
+            for col in model_cols:
+                if col not in input_df.columns:
+                    if f"city_{sim_city}" == col: input_df[col] = 1
+                    elif f"type_{sim_type}" == col: input_df[col] = 1
+                    else: input_df[col] = 0
+            
+            # Reordenar colunas
+            input_df = input_df[model_cols]
+            pred = model.predict(input_df)[0]
+            
+            st.success(f"Faturamento Estimado: R$ {pred:,.2f}/ano")
+            st.metric("Média Mensal", f"R$ {pred/12:,.2f}")
+
+    with col_calc:
+        st.subheader("💰 Calculadora de Lucro Líquido")
+        rec_bruta = st.number_input("Receita Bruta Anual (R$):", value=50000.0)
+        val_imovel = st.number_input("Valor do Imóvel (R$):", value=400000.0)
+        taxa = st.slider("Taxa Airbnb (%):", 0, 20, 15)
+        custo_fixo = st.number_input("Custo Fixo Mensal (Condomínio/Luz) R$:", value=800.0)
         
-        # Tabela de Insights do Cluster
-        cluster_summary = df_model_comp.groupby('Cluster_Mercado').agg(
-            Count=('listing_id', 'count'),
-            ROI_Medio=('ROI_anual', 'median'),
-            Preco_Diaria_Medio=('ttm_avg_rate_native', 'median'),
-            GAP_Medio_ADR=('ADR_GAP', 'median')
-        ).reset_index().sort_values('ROI_Medio', ascending=False)
+        custo_total = (rec_bruta * (taxa/100)) + (custo_fixo * 12)
+        lucro = rec_bruta - custo_total
+        roi_real = (lucro / val_imovel) * 100
         
-        st.subheader("Resumo dos Nichos de Mercado")
-        st.dataframe(cluster_summary.style.format(
-            {'ROI_Medio': '{:.1f}%', 'Preco_Diaria_Medio': 'R$ {:.0f}', 'GAP_Medio_ADR': 'R$ {:.0f}'}
-        ))
-        st.info("O cluster com maior 'GAP Médio de ADR' e 'ROI Alto' é o 'Pote de Ouro': O mercado cobra pouco por imóveis com grande potencial de lucro.")
+        st.divider()
+        st.metric("Lucro Líquido Anual", f"R$ {lucro:,.2f}")
+        st.metric("ROI Real (Líquido)", f"{roi_real:.2f}%")
+        if roi_real > 6:
+            st.balloons()