app.py

import gradio as gr
import pandas as pd
import geopandas as gpd

# ---------------------------------------
# Função para formatar visualização
# ---------------------------------------
def formatar_float_visualizacao(df, casas=4):
    df_visual = df.copy()
    float_cols = df_visual.select_dtypes(include=['float']).columns
    df_visual[float_cols] = df_visual[float_cols].round(casas)
    return df_visual

# ---------------------------------------
# Carregar shapefile dos eixos
# ---------------------------------------
gdf_eixos = gpd.read_file("EixosLogradouros.shp", engine="fiona")
gdf_eixos = gdf_eixos.to_crs("EPSG:4326")

# ---------------------------------------
# Autopreenchimento de colunas
# ---------------------------------------
def listar_colunas(arquivo_excel, aba):
    if arquivo_excel is None or aba is None:
        return gr.update(choices=[]), gr.update(choices=[])

    df = pd.read_excel(arquivo_excel.name, sheet_name=aba)
    colunas = df.columns.tolist()
    colunas_upper = {c.upper(): c for c in colunas}

    col_cdlog = colunas_upper.get("CTM", colunas_upper.get("CDLOG"))
    col_num = None

    for nome in ["Nº GEO", "NUM_GEO", "NUM", "NUMERO"]:
        if nome in colunas_upper:
            col_num = colunas_upper[nome]
            break

    return (
        gr.update(choices=colunas, value=col_cdlog),
        gr.update(choices=colunas, value=col_num)
    )

# ---------------------------------------
# Carregar abas
# ---------------------------------------
def carregar_abas(arquivo_excel):
    if arquivo_excel is None:
        return gr.update(choices=[]), None
    xls = pd.ExcelFile(arquivo_excel.name)
    abas = xls.sheet_names
    return gr.update(choices=abas, value=abas[0]), abas[0]

# ---------------------------------------
# Exibir tabela
# ---------------------------------------
def exibir_tabela(arquivo_excel, aba, col_num):
    if arquivo_excel is None or aba is None:
        return None, ""

    df = pd.read_excel(arquivo_excel.name, sheet_name=aba)
    df["_idx"] = range(len(df))

    if col_num in df.columns:
        df[col_num] = pd.to_numeric(df[col_num], errors='coerce').fillna(0).astype(int)

    return formatar_float_visualizacao(df), f"{df.shape[0]} linhas e {df.shape[1]} colunas"

# ---------------------------------------
# Interpolação com sugestões
# ---------------------------------------
# ---------------------------------------
# Interpolação com sugestões CORRETAS
# ---------------------------------------
def interpolar_enderecos(df, col_cdlog, col_num):

    df = df.copy()
    df[col_num] = pd.to_numeric(df[col_num], errors='coerce').fillna(0).astype(int)

    resultados = []
    falhas = []

    for _, row in df.iterrows():

        idx = row["_idx"]
        cdlog = row[col_cdlog]
        numero = row[col_num]

        segmentos = gdf_eixos[gdf_eixos['CDLOG'] == cdlog]

        if segmentos.empty:
            resultados.append((None, None))
            falhas.append({
                "_idx": idx,
                "cdlog": cdlog,
                "numero_atual": numero,
                "motivo": "CDLOG não encontrado",
                "sugestoes": "",
                "numero_corrigido": ""
            })
            continue

        lado = "Par" if numero % 2 == 0 else "Ímpar"
        ini_col, fim_col = (
            ("NRPARINI", "NRPARFIN")
            if lado == "Par"
            else ("NRIMPINI", "NRIMPFIN")
        )

        segmentos = segmentos.copy()
        segmentos[ini_col] = pd.to_numeric(segmentos[ini_col], errors="coerce")
        segmentos[fim_col] = pd.to_numeric(segmentos[fim_col], errors="coerce")
        segmentos = segmentos.dropna(subset=[ini_col, fim_col])

        cond = (segmentos[ini_col] <= numero) & (segmentos[fim_col] >= numero)
        segmentos_validos = segmentos[cond]

        # ------------------------------------------------
        # 🔴 SE NÃO ENCONTRAR INTERVALO → MESMA LÓGICA DO SEGUNDO CÓDIGO
        # ------------------------------------------------
        if segmentos_validos.empty:

            sugestoes_str = ""
            

            if not segmentos.empty:

                diffs = (segmentos[ini_col] - numero).abs()
                min_index = diffs.idxmin()
                linha_proxima = segmentos.loc[min_index]

                ini = linha_proxima[ini_col]
                fim = linha_proxima[fim_col]

                # if pd.notna(ini) and pd.notna(fim):

                #     numeros_validos = list(range(int(ini), int(fim) + 1, 2))

                #     # ordena pela proximidade do número digitado
                #     numeros_validos.sort(key=lambda x: abs(x - numero))

                #     # pega apenas os 10 mais próximos
                #     sugestoes = numeros_validos[:10]

                #     sugestoes_str = ", ".join(map(str, sugestoes))

                if pd.notna(ini) and pd.notna(fim):

                    ini = int(ini)
                    fim = int(fim)
                
                    # gera todos os números do intervalo
                    todos_numeros = list(range(ini, fim + 1))
                
                    # separa pares e ímpares
                    pares = [n for n in todos_numeros if n % 2 == 0]
                    impares = [n for n in todos_numeros if n % 2 != 0]
                
                    # ordena por proximidade
                    pares.sort(key=lambda x: abs(x - numero))
                    impares.sort(key=lambda x: abs(x - numero))
                
                    # pega 5 de cada
                    sugestoes = pares[:5] + impares[:5]
                
                    # ordena novamente por proximidade geral
                    sugestoes.sort(key=lambda x: abs(x - numero))

                    sugestoes_str = ", ".join(map(str, sugestoes))

            resultados.append((None, None))
            falhas.append({
                "_idx": idx,
                "cdlog": cdlog,
                "numero_atual": numero,
                "motivo": "Numeração fora do intervalo",
                "sugestoes": sugestoes_str,
                "numero_corrigido": ""
            })
            continue

        # ------------------------------------------------
        # INTERPOLAÇÃO NORMAL
        # ------------------------------------------------
        linha = segmentos_validos.iloc[0]
        geom = linha.geometry

        ini = linha[ini_col]
        fim = linha[fim_col]

        if fim == ini:
            resultados.append((None, None))
            continue

        frac = (numero - ini) / (fim - ini)
        frac = max(0, min(1, frac))

        ponto = geom.interpolate(geom.length * frac)

        resultados.append((ponto.x, ponto.y))

    df["lon"] = [x for x, y in resultados]
    df["lat"] = [y for x, y in resultados]

    output_path = "dados_interpolados.xlsx"
    df.to_excel(output_path, index=False)

    df_falhas = pd.DataFrame(falhas)

    return formatar_float_visualizacao(df), df_falhas, output_path

# ---------------------------------------
# Aplicar correções digitadas
# ---------------------------------------
def aplicar_correcoes(df_original, df_falhas, col_num):

    df_original = df_original.copy()

    for _, row in df_falhas.iterrows():
        if str(row["numero_corrigido"]).strip() != "":
            idx = row["_idx"]
            novo_num = int(row["numero_corrigido"])
            df_original.loc[df_original["_idx"] == idx, col_num] = novo_num

    return df_original

# ---------------------------------------
# Interface
# ---------------------------------------
with gr.Blocks() as app:

    gr.Markdown("## DAI - Geolocalização com Correção Manual")

    estado_df = gr.State()

    arquivo = gr.File(label="Arquivo Excel", file_types=[".xlsx"])
    with gr.Row():
        dropdown_abas = gr.Dropdown(label="Aba")
        linhas_info = gr.Textbox(label="Linhas e Colunas", interactive=False)
        dropdown_cdlog = gr.Dropdown(label="Coluna CDLOG")
        dropdown_num = gr.Dropdown(label="Coluna Número")

    tabela_output = gr.Dataframe(label="Prévia", interactive=True)
    btn_interpolar = gr.Button("Obter Coordenadas")

    tabela_interpolada = gr.Dataframe(label="Com Coordenadas")
    arquivo_saida = gr.File(label="Baixar Planilha com Coordenadas")
    falhas_output = gr.Dataframe(label="Falhas (Digite número_corrigido)", interactive=True)

    btn_aplicar = gr.Button("Aplicar Correções")

    # Eventos
    arquivo.change(fn=carregar_abas, inputs=arquivo, outputs=[dropdown_abas, dropdown_abas])

    dropdown_abas.change(
        fn=exibir_tabela,
        inputs=[arquivo, dropdown_abas, dropdown_num],
        outputs=[tabela_output, linhas_info]
    ).then(
        fn=lambda df: df,
        inputs=tabela_output,
        outputs=estado_df
    ).then(
        fn=listar_colunas,
        inputs=[arquivo, dropdown_abas],
        outputs=[dropdown_cdlog, dropdown_num]
    )

    btn_interpolar.click(
        fn=interpolar_enderecos,
        inputs=[estado_df, dropdown_cdlog, dropdown_num],
        outputs=[tabela_interpolada, falhas_output, arquivo_saida]
    )

    btn_aplicar.click(
        fn=aplicar_correcoes,
        inputs=[estado_df, falhas_output, dropdown_num],
        outputs=estado_df
    ).then(
        fn=interpolar_enderecos,
        inputs=[estado_df, dropdown_cdlog, dropdown_num],
        outputs=[tabela_interpolada, falhas_output, arquivo_saida]
    )

app.launch(server_name="0.0.0.0", server_port=7860)