Customizing Link Preview Metadata in Flet Web App

[WashingtonErly]

Question

I'm having trouble customizing the link preview metadata when sharing URLs from my Flet web application. Currently, whenever I share a link, the preview shows the Flet logo and the name "Flet application" instead of my application's branding.

I've searched through the documentation and settings but haven't found a way to modify the metadata (og:image, og:title, og:description, etc.) to reflect my own logo, app name, and description.

Is there a way to configure this within Flet, or do I need to implement an external solution to override these default settings? Any guidance would be greatly appreciated. Thanks in advance!

Code sample

import warnings
import re

# Suprime os avisos de depreciação específicos do websockets / uvicorn
warnings.filterwarnings(
    "ignore",
    message="websockets.legacy is deprecated",
    category=DeprecationWarning
)
warnings.filterwarnings(
    "ignore",
    message="websockets.server.WebSocketServerProtocol is deprecated",
    category=DeprecationWarning
)
warnings.filterwarnings(
    "ignore",
    message="remove second argument of ws_handler",
    category=DeprecationWarning
)

import flet as ft
import random
import pandas as pd
import smtplib
from flet.auth.providers import GoogleOAuthProvider
from flet.auth import OAuthProvider
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from unidecode import unidecode
from dotenv import load_dotenv
from pathlib import Path
import hashlib
import os
import time
from IPython.display import display, Markdown, Latex
from datetime import datetime, timedelta


os.environ["FLET_SECRET_KEY"]=os.urandom(12).hex()
os.environ["FLET_FORCE_WEB_SERVER"]="true"
os.environ["FLET_SERVER_PORT"]="8003"
os.environ["FLET_WEB_RENDERER"]="canvaskit"
os.environ["FLET_WEB_ALLOW_EXTERNAL_ROUTING"] = "true"  # <-- Added!
BASE_URL = os.getenv("BASE_URL", "http://localhost:8003")

load_dotenv()
# Directory to save images
IMAGE_DIR = "profile_images"

def carregar_texto(nome_arquivo, texto_padrao="Texto não disponível."):
    """
    Carrega o conteúdo de um arquivo de texto da pasta 'docs'.

    :param nome_arquivo: Nome do arquivo de texto (ex: 'politica_privacidade.txt').
    :param texto_padrao: Texto a ser retornado se o arquivo não for encontrado.
    :return: Conteúdo do arquivo ou texto padrão.
    """
    # Define o caminho completo para o arquivo
    caminho_arquivo = Path(__file__).parent / 'docs' / nome_arquivo
    
    try:
        # Lê e retorna o conteúdo do arquivo
        return caminho_arquivo.read_text(encoding='utf-8').strip()
    except FileNotFoundError:
        print(f"Arquivo {caminho_arquivo} não encontrado. Usando texto padrão.")
    except Exception as e:
        print(f"Erro ao ler o arquivo {caminho_arquivo}: {e}")
        return texto_padrao

# Ensure the directory exists
os.makedirs(IMAGE_DIR, exist_ok=True)

# Ler dados dos arquivos Parquet
jobs_df = pd.read_parquet("data/jobs.parquet", engine='pyarrow').astype(str)
#print(jobs_df)
try:
    data_usuario = pd.read_parquet("data/users_dataframe.parquet", engine="pyarrow")
except Exception as e:
    print(f"Erro ao carregar Parquet: {e}")

# Variáveis globais
selected_job = None
user_logged_in = False
user_email = ""
user_name = ""
usuario_google = ""
modelo_trabalho_selecionado = "Todos"
salario_selecionado = "Todos"


# Variáveis string para armazenar opções selecionadas
modelo_trabalho_selecionado_str = "Todos"
salario_selecionado_str = "Todos"
dias_selecionados_str = "Todos"
estado_selecionado_str = "Todos"
cargo_selecionado_text = ""
quantidade_vagas_text = ""

#Listas para filtros
ESTADOS_BRASILEIROS = [
    "Todos", "AC", "AL", "AP", "AM", "BA", "CE", "DF", "ES", "GO", "MA",
    "MT", "MS", "MG", "PA", "PB", "PR", "PE", "PI", "RJ", "RN", "RS",
    "RO", "RR", "SC", "SP", "SE", "TO"
]

# Variáveis Login Google
client_id = os.environ['client_id']
client_secret = os.environ['client_secret']
cliente_redirect_url = os.environ['cliente_redirect_url']

#base url
BASE_URL = os.getenv("BASE_URL", "http://localhost:8003")

# Variáveis de exibição da lista
job_list_view = ft.ListView(expand=True)
job_description = ft.Container(expand=True, padding=10)

usuario = {
    "nome_completo": "",
    "email": "",
    "telefone": "",
    "senha": "",
    "confirmar_senha": "",
    "cargo_interesse": ""
}

# ---- ESTILOS PERSONALIZADOS ----
BOTAO_STYLE = ft.ButtonStyle(
    bgcolor="#013764",
    color="#FFFFFF",
    padding=ft.padding.symmetric(horizontal=10, vertical=6),
    shape=ft.RoundedRectangleBorder(radius=6),
)
BOTAO_STYLE_BACK = ft.ButtonStyle(
    bgcolor="#BEBEBE",
    color="#FFFFFF",
    padding=ft.padding.symmetric(horizontal=10, vertical=6),
    shape=ft.RoundedRectangleBorder(radius=6),
)
BOTAO_STYLE_VER_DETALHES = ft.ButtonStyle(
    bgcolor=ft.colors.WHITE,  # Preenchimento Branco
    color="#013764",  # Texto Azul Escuro
    padding=ft.padding.symmetric(horizontal=10, vertical=6),  # Padding
    shape=ft.RoundedRectangleBorder(radius=6),  # Cantos arredondados
    overlay_color=ft.colors.BLUE_100,  # Cor de sobreposição ao passar o mouse (hover)

)
MENU_STYLE = ft.TextStyle(
    color="#FFFFFF",
    weight=ft.FontWeight.BOLD,

)
BORDER_RADIUS = 8
BORDER_COLOR = "#eeeeee"

# ---- FUNÇÕES AUXILIARES ----
def validate_email(e):

    # Regex simples (pode ser adaptada para algo mais robusto se desejar)
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    if re.match(pattern, e.control.value or ""):
        e.control.error_text = None
    else:
        e.control.error_text = "E-mail inválido!"
    e.page.update()

def verificar_email_no_banco(user_email):

    # Verifica se o e-mail existe na coluna correspondente do DataFrame
    if "email" not in data_usuario.columns:
        raise KeyError("A coluna 'email' não existe no DataFrame.")

    return user_email in data_usuario["email"].values


def validate_full_name(e):

    if e.control.value and len(e.control.value.split()) >= 2:
        e.control.error_text = None
    else:
        e.control.error_text = "Insira seu nome completo (mínimo de dois nomes)!"
    e.page.update()

def validate_password(e):

    pattern = r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$'
    if re.match(pattern, e.control.value or ""):
        e.control.error_text = None
    else:
        e.control.error_text = (
            "A senha deve ter no mínimo 8 caracteres, incluindo "
            "uma letra maiúscula, uma letra minúscula, um número e um caractere especial."
        )
    e.page.update()

def mask_phone_on_blur(e):

    # Obtém o valor atual do campo
    raw_value = e.control.value or ""
    
    # Remove todos os caracteres não numéricos
    digits = ''.join(filter(str.isdigit, raw_value))
    
    # Limita a entrada a 11 dígitos (2 para DDD + 9 para número celular)
    digits = digits[:11]
    
    # Aplica a máscara conforme o número de dígitos
    if len(digits) < 3:
        masked = f"({digits}"
    elif len(digits) < 7:
        masked = f"({digits[:2]}) {digits[2:]}"
    elif len(digits) < 11:
        masked = f"({digits[:2]}) {digits[2:7]}-{digits[7:]}"
    else:
        masked = f"({digits[:2]}) {digits[2:7]}-{digits[7:11]}"
    
    # Atualiza o valor do campo com a máscara aplicada
    e.control.value = masked
    
    # --- Validação do formato final (XX)XXXXX-XXXX ---
    pattern = r'^\(\d{2}\)\s?\d{5}-\d{4}$'
    if re.match(pattern, masked):
        e.control.error_text = None
    else:
        e.control.error_text = "Telefone inválido."
    
    e.page.update()

PORTA = os.getenv("porta_smtp")
SENHA_SMTP = os.getenv("senha_smtp")

def send_verification_code(email):
    """Função para gerar e enviar o código de verificação (simulado)."""
    global verification_code
    verification_code = str(random.randint(100000, 999999))  # Gera um código de 6 dígitos
    # print(f"Código enviado (simulado): {verification_code}")

    try:
        # Criação da mensagem
        msg = MIMEText(f"Seu código de verificação é: {verification_code}")
        msg['Subject'] = 'Verificação de E-mail'
        msg['From'] = 'naoresponder@jobstrategy.com.br'  # Seu e-mail de envio
        msg['To'] = email

        # Configuração do servidor SMTP com SSL
        with smtplib.SMTP_SSL('mail.jobstrategy.com.br', PORTA) as server:
            # server.set_debuglevel(1)  # Ativa o modo debug para visualizar detalhes da conexão
            server.login('naoresponder@jobstrategy.com.br', SENHA_SMTP)  # Insira a senha correta
            server.send_message(msg)
    except smtplib.SMTPAuthenticationError as e:
        print(f"Erro de autenticação: {e.smtp_code} - {e.smtp_error.decode()}")
    except Exception as e:
        print(f"Erro ao enviar e-mail: {e}")

def parse_salary(salario):
    try:
        return float(salario.replace("R$", "").replace(".", "").replace(",", "."))
    except ValueError:
        return 0.0

def generate_slug(title, city, job_index):
    safe_title = unidecode(title).lower().replace(' ', '-')
    safe_city = unidecode(city).lower().replace(' ','-',)
    safe_city = unidecode(safe_city).replace(',','-')
    return f"{safe_title}{safe_city}-{job_index}"

def hash_password(password):
    salt = os.urandom(16)
    hash_value = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 100000)
    return salt + hash_value

def verify_password(stored_hash, provided_password):
    salt = stored_hash[:16]
    stored_hash_value = stored_hash[16:]
    new_hash = hashlib.pbkdf2_hmac('sha256', provided_password.encode(), salt, 100000)
    return stored_hash_value == new_hash

# ---- DESCRIÇÃO DAS VAGAS E ROTAS ----
def generate_job_page(page, index):
    global user_logged_in
    job = jobs_df.iloc[index]

    def candidatar_se(e):
        if user_logged_in:
            page.launch_url(selected_job["job_url_direct"])
        else:
            page.go("/login")

    description = job["description"] if job["description"] else "Descrição não disponível."
    location = str(job.get('location', 'Presencial'))

    if selected_job['job_type'] is None or selected_job['job_type'] == "None":
        modelo_de_trabalho_select = 'Presencial'
    else:
        modelo_de_trabalho_select = selected_job['job_type']

    # CAMPOS DE BUSCA
    search_bar_title_field = ft.TextField(
        hint_text="Buscar vagas por título...",
        expand=True,
        prefix_icon=ft.icons.SEARCH,
    )
    search_bar_city_field = ft.TextField(
        hint_text="Buscar vagas por cidade...",
        expand=True,
        prefix_icon=ft.icons.LOCATION_ON,
    )

    return ft.View(
        f"/vagas/{generate_slug(job['title'], job['location'], index)}",
        scroll=ft.ScrollMode.AUTO,
        horizontal_alignment=ft.CrossAxisAlignment.CENTER,
        vertical_alignment=ft.MainAxisAlignment.START,
        controls=[
            # 1. Cabeçalho
            create_header(page, user_logged_in),

            # 2. CAMPOS DE BUSCA (SEPARADOS DO RESTO)
            ft.Container(
                content=ft.ResponsiveRow(
                    controls=[
                        ft.Container(
                            content=search_bar_title_field,
                            col={"xs": 12, "md": 3},
                            alignment=ft.alignment.center,
                        ),
                        ft.Container(
                            content=search_bar_city_field,
                            col={"xs": 12, "md": 3},
                            alignment=ft.alignment.center,
                        ),
                        ft.Container(
                            content=ft.ElevatedButton(
                                "Buscar Vagas",
                                height=48,
                                style=BOTAO_STYLE,
                                # Ao clicar, vai para /vagas (sem filtro local):
                                on_click=lambda e: page.go("/vagas"),
                            ),
                            col={"xs": 12, "md": 2},
                            alignment=ft.alignment.center_left,
                        ),
                    ],
                    spacing=10,
                    alignment=ft.MainAxisAlignment.CENTER,
                ),
                padding=ft.padding.symmetric(vertical=10),
                alignment=ft.alignment.center,
            ),

            # 3. CONTAINER COM DETALHES DA VAGA
            ft.Container(
                width=600,
                alignment=ft.alignment.center,
                padding=20,
                border=ft.border.all(1, BORDER_COLOR),
                border_radius=BORDER_RADIUS,
                content=ft.Column(
                    spacing=10,
                    alignment=ft.MainAxisAlignment.CENTER,
                    controls=[
                        # Título da vaga
                        ft.Text(
                            job["title"], 
                            size=24, 
                            weight=ft.FontWeight.BOLD, 
                            text_align=ft.TextAlign.CENTER
                        ),

                        # Localização
                        ft.Row(
                            controls=[
                                ft.Icon(ft.icons.LOCATION_ON),
                                ft.Markdown(f"**Localização:** {job['location']}"),
                            ]
                        ),

                        # Modelo
                        ft.Row(
                            controls=[
                                ft.Icon(ft.icons.WORK),
                                ft.Markdown(f"**Modelo de Trabalho:** {modelo_de_trabalho_select}"),
                            ]
                        ),

                        # Descrição
                        ft.ResponsiveRow(
                            controls=[
                                ft.Text(
                                    "Descrição da Vaga",
                                    font_family='Poppins',
                                    weight=ft.FontWeight.BOLD,
                                    size=18
                                ),
                                ft.Markdown(
                                    selected_job['description'] 
                                    if selected_job['description'] 
                                    else "Descrição não disponível.",
                                ),
                            ]
                        ),

                        # Botão Candidatar-se
                        ft.ElevatedButton(
                            "Candidatar-se no site da empresa",
                            style=BOTAO_STYLE,
                            on_click=candidatar_se
                        ),

                        # Botão Voltar
                        ft.ElevatedButton(
                            "Voltar",
                            style=BOTAO_STYLE,
                            on_click=lambda e: page.go("/vagas")
                        ),
                    ],
                ),
            ),

            # 4. Rodapé
            create_footer(page),
        ],
    )


def generate_job_page_by_slug(page, slug):
    for index, job in jobs_df.iterrows():
        if generate_slug(job["title"], job["location"], index) == slug:
            return generate_job_page(page, index)
    return ft.View(
        "/vagas",
        controls=[
            ft.Text("Vaga não encontrada!", size=24, color="red"),
            ft.ElevatedButton(
                "Voltar",
                style=BOTAO_STYLE,
                on_click=lambda e: page.go("/vagas")
            )
        ]
    )

def vagas_detalhada_view(page, slug):
    for index, job in jobs_df.iterrows():
        if generate_slug(job["title"], job["location"], index) == slug:
            return generate_job_page(page, index)
    return ft.View(
        "/vagas",
        controls=[
            ft.Text("Vaga não encontrada!", size=24, color="red"),
            ft.ElevatedButton(
                "Voltar",
                style=BOTAO_STYLE,
                on_click=lambda e: page.go("/vagas")
            )
        ]
    )

def compartilhar_vaga(slug, page):
    """Função para compartilhar a vaga."""
    vaga_url = f"{BASE_URL}/#/vagas/{slug}"
    share_text = f"{vaga_url}"
    try:
        page.set_clipboard(share_text)
        
        # Criar o snackbar
        snack = ft.SnackBar(
            content=ft.Text("Link da vaga copiado para a área de transferência!"),
            bgcolor=ft.colors.BLUE,
        )
        
        # Atribuir o snackbar à página
        page.snackbar = snack
        page.snackbar.open = True
        page.update()
    except Exception as ex:
        snack = ft.SnackBar(
            content=ft.Text(f"Erro ao compartilhar a vaga: {ex}"),
            bgcolor=ft.colors.RED,
        )
        page.snackbar = snack
        page.snackbar.open = True
        page.update()



# ---- LOGOUT ----
def logout(page: ft.Page):
    # Remover informações do armazenamento local
    page.client_storage.remove("user_logged_in")
    page.client_storage.remove("user_email")
    page.client_storage.remove("user_name")
    
    # Atualizar variáveis globais
    global user_logged_in, user_email, user_name
    user_logged_in = False
    user_email = ""
    user_name = ""
    
    # Atualizar a interface
    page.appbar = create_header(page,user_logged_in)
    page.theme = ft.colors.WHITE70
    page.go("/")
    page.update()

def create_popup_menu_items(page: ft.Page):
    """Cria itens do menu (ícone de 'hambúrguer') com icons e links, incluindo políticas do footer."""
    items = []
    items.append(
        ft.PopupMenuItem(
            text="Pagina Inicial",
            icon=ft.icons.HOME,
            on_click=lambda e: page.go("/")
        )
    )
    # Se logado, Perfil, Logout etc.
    if user_logged_in:
        items.append(
            ft.PopupMenuItem(
                text="Perfil",
                icon=ft.icons.ACCOUNT_CIRCLE,
                on_click=lambda e: page.go("/profile")
            )
        )
        items.append(
            ft.PopupMenuItem(
                text="Logout",
                icon=ft.icons.LOGOUT,
                on_click=lambda e: logout(page)
            )
        )
    else:
        # Se não estiver logado, exibe Login e Cadastro
        items.append(
            ft.PopupMenuItem(
                text="Login",
                icon=ft.icons.LOGIN,
                on_click=lambda e: page.go("/login")
            )
        )
    
    # Políticas e Ajuda (sempre visíveis, independentemente de login)
    items.append(ft.PopupMenuItem())  # Item vazio para "dividir"
    items.append(
    ft.PopupMenuItem(
        text="Termos de Uso",
        icon=ft.icons.DESCRIPTION,
        on_click=lambda e: page.launch_url(f"{BASE_URL}/#/termos-de-uso", web_window_name="_blank")
    )
    )
    items.append(
        ft.PopupMenuItem(
            text="Política de Privacidade",
            icon=ft.icons.POLICY,
            on_click=lambda e: page.launch_url(f"{BASE_URL}/#/politica-de-privacidade", web_window_name="_blank"),
        )
    )
    items.append(
        ft.PopupMenuItem(
            text="Política de Cookies",
            icon=ft.icons.COOKIE,
            on_click=lambda e: page.launch_url(f"{BASE_URL}/#/politica-de-cookies", web_window_name="_blank"),
        )
    )
    items.append(
        ft.PopupMenuItem(
            text="Ajuda",
            icon=ft.icons.HELP_OUTLINE,
            on_click=lambda e: page.launch_url("https://jobstrategy.com.br/premium/ajuda")
        )
    )
    items.append(ft.PopupMenuItem())  # Outro separador
    items.append(
        ft.PopupMenuItem(
            text="2025 JobStrategy", 
            icon=ft.icons.COPYRIGHT,
            # enabled=False  # Desabilitado para não ser clicável
        )
    )

    return items
def create_header(page: ft.Page, usuario_logado: bool):
    return ft.Container(
        height=50,  # Limita a altura total do header (opcional)
        content=ft.ResponsiveRow(
            alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
            controls=[
                #
                # 1. Logo
                #
                ft.Container(
                    content=ft.Image(
                        src="/Logos/JobStrategy-logo-horizontal-fundo-claro.png",
                        width=140
                    ),
                    on_click=lambda e: page.go("/"),
                    alignment=ft.alignment.center,
                    col={"xs": 4, "md": 2},
                ),

                #
                # 2. Botão "Vagas" - somente em telas MD ou maiores
                #
                ft.Container(
                    content=ft.TextButton(
                        text="Vagas",
                        on_click=lambda e: page.go("/vagas"),
                        style=ft.ButtonStyle(
                            padding={"left": 6, "top": 2, "right": 6, "bottom": 2},
                            overlay_color={"hovered": "transparent"},  # Remove a sobreposição no hover
                            color={"": "#013764"},  # Cor do texto azul
                        ),
                    ),
                    alignment=ft.alignment.center_left,
                    col={"xs": 0, "md": 2},
                ),

                #
                # 3. Espaçador - some em telas pequenas
                #
                ft.Container(
                    expand=True,
                    alignment=ft.alignment.center,
                    col={"xs": 0, "md": 4},
                ),
                *(
                    [
                        # Espaço reservado para botão "Acessar" (MD+)
                        ft.Container(
                            height=40,  # Mantém o espaço ocupado pelo botão
                            col={"xs": 0, "md": 2},
                        ),

                        # Espaço reservado para botão "Acessar" (XS)
                        ft.Container(
                            height=40,  # Mantém o espaço ocupado pelo botão
                            col={"xs": 4, "md": 0},
                        ),
                    ] if usuario_logado else [
                        # Botão "Acessar" (sem ícone) - só em MD+
                        ft.Container(
                            content=ft.ElevatedButton(
                                text="Acessar",
                                icon = ft.icons.PERSON,
                                on_click=lambda e: page.go("/login"),
                                style=ft.ButtonStyle(
                                    padding={"left": 8, "top": 2, "right": 8, "bottom": 2},
                                    text_style=ft.TextStyle(weight=ft.FontWeight.BOLD, font_family="Poppins"),  # Negrito
                                    
                                ),
                            ),
                            alignment=ft.alignment.center_right,
                            col={"xs": 0, "md": 2},
                        ),

                        # Botão "Acessar" (com ícone) - só em XS
                        ft.Container(
                            content=ft.ElevatedButton(
                                text="Acessar",
                                icon = ft.icons.PERSON,
                                on_click=lambda e: page.go("/login"),
                                style=ft.ButtonStyle(
                                    padding={"left": 8, "top": 2, "right": 8, "bottom": 2},
                                    text_style=ft.TextStyle(weight=ft.FontWeight.BOLD,font_family="Poppins"),  # Negrito
                                ),
                            ),
                            alignment=ft.alignment.center_right,
                            col={"xs": 4, "md": 0},
                        ),
                    ]
                ),

                ft.Container(
                    alignment=ft.alignment.center,
                    col={"xs": 2, "md": 1},
                    content=ft.PopupMenuButton(
                        icon=ft.icons.MENU,
                        items=create_popup_menu_items(page),
                    ),
                ),
            ],
        ),
        # Reduz a padding vertical no header
        padding=ft.padding.symmetric(horizontal=10, vertical=2),
        border=ft.border.only(bottom=ft.BorderSide(2, "#01376480"))  # Borda azul na parte inferior
    )

def create_footer(page):
    return ft.Container(
        width=float("inf"),  # Faz o footer ocupar 100% da largura
        content=ft.Column(
            [
                ft.Divider(height=1, color="#cccccc"),

                # ✅ Responsividade aprimorada usando col(xs, md)
                ft.ResponsiveRow(
                    controls=[
                        ft.Text(
                            "",
                            col={"xs": 12, "md": 1},  
                            text_align=ft.TextAlign.CENTER
                        ),
                        ft.Text(
                            "© 2025 JobStrategy",
                            col={"xs": 12, "md": 2},  
                            text_align=ft.TextAlign.CENTER
                        ),
                        ft.TextButton(
                            "Termos de Uso",
                            on_click=lambda e: page.launch_url(f"{BASE_URL}/#/termos-de-uso", web_window_name="_blank"),
                            col={"xs": 12, "md": 2}
                        ),
                        ft.TextButton(
                            "Política de Privacidade",
                            on_click=lambda e: page.launch_url(f"{BASE_URL}/#/politica-de-privacidade", web_window_name="_blank"),
                            col={"xs": 12, "md": 2}
                        ),
                        ft.TextButton(
                            "Política de Cookies",
                            on_click=lambda e: page.launch_url(f"{BASE_URL}/#/politica-de-cookies", web_window_name="_blank"),
                            col={"xs": 12, "md": 2}
                        ),
                        ft.TextButton(
                            "Ajuda",
                            on_click=lambda e: page.launch_url("https://jobstrategy.com.br/premium/ajuda"),
                            col={"xs": 12, "md": 2}
                        ),
                        ft.Text(
                            "",
                            col={"xs": 12, "md": 1},  
                            text_align=ft.TextAlign.CENTER
                        ),

                    ],
                    run_spacing=10,  # Espaçamento extra para telas pequenas
                    columns=12,       # Divide o layout em 12 colunas
                    vertical_alignment=ft.CrossAxisAlignment.CENTER
                )
            ],
            spacing=5,
        ),
        padding=ft.padding.only(top=10, bottom=10),
        alignment=ft.alignment.bottom_center,  # ✅ Mantendo fixo na parte inferior
    )

# ---- CONSENTIMENTO DE COOKIES ----
cookie_accepted = False

def show_cookie_consent(page):
    def accept_cookies(e):
        global cookie_accepted
        cookie_accepted = True
        page.dialog.open = False
        page.snack_bar = ft.SnackBar(ft.Text("Obrigado por aceitar os cookies!"), open=True)
        page.update()

    def decline_cookies(e):
        page.dialog.open = True
        page.update()

    cookie_dialog = ft.AlertDialog(
        title=ft.Text("Permissão de Cookies"),
        content=ft.Text(
            "Utilizamos cookies para melhorar sua experiência no site. Ao aceitar, você concorda com nossa política de cookies."
        ),
        actions=[
            ft.ElevatedButton("Aceitar", style=BOTAO_STYLE, on_click=accept_cookies),
            ft.ElevatedButton("Recusar", style=BOTAO_STYLE, on_click=decline_cookies),
        ],
        actions_alignment=ft.MainAxisAlignment.END,
    )

    if not cookie_accepted:
        page.dialog = cookie_dialog
        page.dialog.open = True
        page.update()

# ---- MAIN ----
def main(page: ft.Page):
    global selected_job, user_logged_in, user_email, cookie_accepted, usuario_google

    # Definições de tema, fonte e fundo
    page.fonts = {
        "Poppins": "fonts/Poppins-Regular.ttf",
    }

    #page.pwa = True
    
    # Configuração do tema global
    page.theme = ft.Theme(font_family="Poppins")  # Definir a fonte
    page.theme_mode = ft.ThemeMode.LIGHT         # Modo de tema claro
    page.bgcolor = "white"                       # Fundo branco
    page.title = "Job Strategy"                  # Título da página
    
    job_list_view = ft.ListView(expand=True)
    job_description = ft.Container(expand=True, padding=10)

    # ---- Campos de busca principal ----
    search_bar_title_field = ft.TextField(
        fill_color="#fefefe",
        hint_text="Buscar vagas por título...",
        expand=True,
        prefix_icon=ft.icons.SEARCH,
        on_change=lambda e: filter_jobs(),
    )

    search_bar_city_field = ft.TextField(
        fill_color="#fefefe",
        hint_text="Buscar vagas por cidade...",
        expand=True,
        prefix_icon=ft.icons.LOCATION_ON,
        on_change=lambda e: filter_jobs(),
    )

    # ---- Filtro de vagas da home ----
    def filter_jobs():
        query_title = search_bar_title_field.value.lower() if search_bar_title_field.value else ""
        query_city = search_bar_city_field.value.lower() if search_bar_city_field.value else ""

        # Filtrando as vagas
        filtered_jobs = jobs_df[
            (jobs_df["title"].str.contains(query_title, case=False, na=False)) &
            (jobs_df["location"].str.contains(query_city, case=False, na=False))
        ]

        # Limpando a lista de vagas antes de atualizar
        job_list_view.controls.clear()

        # Adicionando as vagas filtradas
        job_list_view.controls.append(
            ft.Container(
                content=ft.Column(
                    controls=[
                        ft.Container(
                            content=ft.Column(
                                controls=[
                                    # Título da vaga
                                    ft.Text(job["title"], size=18, weight=ft.FontWeight.BOLD),
                                    # Cidade e Estado
                                    ft.Text(f"{job['location']}"),
                                    ft.Text(f"{job['company']}"),
                                    # Salário
                                    # ft.Text(f"Salário: {job['salário']}"),
                                    # Botões responsivos
                                    ft.ResponsiveRow(
                                        controls=[
                                            # Botão para telas grandes
                                            ft.Container(
                                                content=ft.ElevatedButton(
                                                    "Ver Detalhes",
                                                    style=BOTAO_STYLE_VER_DETALHES,
                                                    on_click=lambda e, job=job.to_dict(): select_job(job, page),
                                                ),
                                                col={"xs": 0, "md": 6},  # Somente em telas médias ou maiores
                                            ),
                                            # Botão para telas pequenas
                                            ft.Container(
                                                content=ft.ElevatedButton(
                                                    "Ver Detalhes",
                                                    style=BOTAO_STYLE,
                                                    on_click=lambda e, job=job.to_dict(), index=index: page.go(
                                                        f"/vagas/{generate_slug(job['title'], job['location'], index)}"
                                                    ),
                                                ),
                                                col={"xs": 12, "md": 0},  # Somente em telas pequenas
                                            ),
                                        ],
                                        alignment=ft.MainAxisAlignment.START,  # Alinha os botões no início
                                        spacing=5,
                                    ),
                                ],
                                spacing=5,
                            ),
                            border=ft.border.all(1, BORDER_COLOR),
                            border_radius=BORDER_RADIUS,
                            padding=10,
                            margin=ft.margin.symmetric(vertical=3),
                            height=150,
                        )
                        for index, job in filtered_jobs.iterrows()  # Captura o índice aqui
                    ],
                    spacing=5,
                    scroll=ft.ScrollMode.AUTO,
                    horizontal_alignment=ft.CrossAxisAlignment.STRETCH,
                ),
                height=500,
                border_radius=BORDER_RADIUS,
                padding=10,
                margin=ft.margin.symmetric(vertical=1),
                expand=True,
            )
        )

        page.update()

    # ---- Exibir detalhes da vaga ----
    def select_job(job, page):
        global selected_job, user_logged_in
        selected_job = job
        def candidatar_se(e):
            if user_logged_in:
                # Usuário logado -> vai para o link da vaga
                page.launch_url(selected_job["job_url_direct"])
            else:
                # Usuário deslogado -> vai para /login
                page.go("/login")

        try:
            index = jobs_df[jobs_df["title"] == job["title"]].index[0]
            slug = generate_slug(job['title'], job['location'], index)
        except IndexError:
            slug = generate_slug(job['title'], job['location'], 'unknown')

        modelo_de_trabalho_select = ''
        if selected_job['job_type'] is None or selected_job['job_type'] == "None":
            modelo_de_trabalho_select = 'Presencial'
        else:
            modelo_de_trabalho_select = selected_job['job_type']


        job_description.content = ft.Container(
            content=ft.Column(
                controls=[
                    ft.Row(
                        controls=[
                            ft.TextButton(
                                content=ft.Text(
                                    value=selected_job['title'],
                                    size=18,  # Aumenta o tamanho da fonte
                                    color='#013764',  # Define a cor para azul escuro
                                    weight=ft.FontWeight.BOLD,  # Opcional: deixa o texto em negrito
                                ),
                                on_click=lambda e, slug=slug: page.go(f"/vagas/{slug}"),
                                style=ft.ButtonStyle(
                                    overlay_color=ft.colors.TRANSPARENT,  # Remove o efeito de hover
                                    # Opcional: remove padding adicional
                                    padding=ft.padding.only(left=0, right=0, top=0, bottom=0),
                                    # Opcional: remove bordas
                                )
                            ),
                            ft.ElevatedButton(
                                content=ft.Icon(ft.icons.LINK_OUTLINED),  # Ícone de link
                                style=BOTAO_STYLE,
                                on_click=lambda e: compartilhar_vaga(slug, page)
                            )
                        ],
                        alignment=ft.MainAxisAlignment.START,
                    ),
                    ft.Row(
                        controls=[
                            ft.Icon(ft.icons.LOCATION_ON),
                            ft.Markdown(f"**Localização:** {selected_job['location']}"),
                        ]
                    ),
                    ft.Row(
                        controls=[
                            ft.Icon(ft.icons.WORK),
                            ft.Markdown(
                                f"**Modelo de Trabalho:** {modelo_de_trabalho_select}"
                            ),
                        ]
                    ),
                    ft.ResponsiveRow(
                        controls=[
                            ft.Text(
                                "Descrição da Vaga",
                                font_family='Poppins',
                                weight=ft.FontWeight.BOLD,  # Deixa o texto em negrito
                                size=18  # Ajuste o tamanho do título aqui
                            ),
                            ft.Markdown(
                                selected_job['description'] if selected_job['description'] else "Descrição não disponível.",
                            ),
                        ]
                    ),
                    ft.ElevatedButton(
                        "Candidatar-se no site da empresa",
                        style=BOTAO_STYLE,
                        on_click=candidatar_se
                    ),
                ],
                spacing=10,
                scroll=ft.ScrollMode.AUTO  # ✅ Scroll ativado no Column
            ),
            height=500,  # ✅ Definido uma altura para ativar o scroll
            border_radius=BORDER_RADIUS,
            padding=10,
            margin=ft.margin.symmetric(vertical=5)
        )
        page.update()


    # ---- Login Google ----
    def google_login(page):
        global user_email, user_name, user_logged_in, data_usuario

        google_auth = GoogleOAuthProvider(
            client_id=client_id,
            client_secret=client_secret,
            redirect_url=cliente_redirect_url,
        )

        def show_snack_bar(message, success=True):
            """Exibe uma mensagem no SnackBar."""
            snack_bar = ft.SnackBar(
                content=ft.Text(message),
                bgcolor="blue" if success else "red",
            )
            page.overlay.append(snack_bar)
            snack_bar.open = True
            page.update()

        def on_google_login(e: ft.LoginEvent):
            global user_email, user_name, user_logged_in, data_usuario

            if e.error:
                print(f"Erro ao fazer login com Google: {e.error}")
                show_snack_bar("Erro ao fazer login com Google!", success=False)
                return

            if page.auth and page.auth.user:
                usuario_google = page.auth.user
                user_email = usuario_google.get("email", None)
                user_name = usuario_google.get("name", "Usuário sem nome")
                # print(f"Usuário logado com sucesso: {user_name} ({user_email})")

                if not user_email:
                    print("Email do usuário não encontrado.")
                    show_snack_bar("Erro ao recuperar o email do usuário!", success=False)
                    return

                # Salvar no armazenamento local
                page.client_storage.set("user_email", user_email)
                page.client_storage.set("user_name", user_name)

                # Certificar que o banco de dados está carregado
                try:
                    data_usuario = pd.read_parquet("data/users_dataframe.parquet")
                except FileNotFoundError:
                    data_usuario = pd.DataFrame(columns=["nome_completo", "email", "telefone", "senha", "cargo_interesse"])
                    data_usuario.to_parquet("data/users_dataframe.parquet")

                # Verificar se o usuário já está no banco de dados
                if user_email in data_usuario["email"].values:
                    user_logged_in = True
                    page.client_storage.set("user_logged_in", True)
                    show_snack_bar(f"Bem-vindo de volta, {user_name}!")
                    page.go("/profile")
                else:
                    show_snack_bar(f"Bem-vindo, {user_name}! Complete seu cadastro.")
                    page.go("/profile/finalizar-cadastro")
            else:
                print("Falha ao recuperar as informações do usuário.")
                show_snack_bar("Falha ao acessar os dados!", success=False)
                page.update()

        page.on_login = on_google_login
        page.login(google_auth)
    
    def excluir_usuario(page):
        """Exclui o usuário do banco de dados e realiza logout."""
        global data_usuario, user_email, user_logged_in

        # Verifica se o usuário está logado e o e-mail existe
        if not user_logged_in or not user_email:
            page.snack_bar = ft.SnackBar(
                content=ft.Text("Erro: Nenhum usuário logado ou e-mail inválido!"),
                open=True,
            )
            page.update()
            return False

        # Carrega os dados do banco de dados (simulado com Parquet ou DataFrame)
        try:
            data_usuario = pd.read_parquet("data/users_dataframe.parquet")
        except Exception as e:
            page.snack_bar = ft.SnackBar(
                content=ft.Text(f"Erro ao carregar banco de dados: {e}"),
                open=True,
            )
            page.update()
            return False

        # Verifica se o e-mail existe no banco de dados
        if user_email not in data_usuario["email"].values:
            page.snack_bar = ft.SnackBar(
                content=ft.Text("Erro: Usuário não encontrado no banco de dados!"),
                open=True,
            )
            page.update()
            return False

        # Remove o usuário do DataFrame
        data_usuario = data_usuario[data_usuario["email"] != user_email]

        # Salva as alterações no banco de dados
        try:
            data_usuario.to_parquet("data/users_dataframe.parquet", index=False)
            page.snack_bar = ft.SnackBar(
                content=ft.Text("Usuário excluído com sucesso!"),
                open=True,
            )
            # Realiza logout após excluir o usuário
            logout(page)
            return True
        except Exception as e:
            page.snack_bar = ft.SnackBar(
                content=ft.Text(f"Erro ao salvar alterações no banco de dados: {e}"),
                open=True,
            )
            page.update()
            return False


    def profile_google_view(page: ft.Page):
        """Página responsiva para desvincular conta Google."""
        status_text = ft.Text("", color="red")
        global user_logged_in
        def desvincular_click(e):
            # Chama excluir_usuario e verifica o sucesso
            if excluir_usuario(page):
                status_text.value = "Conta Google desvinculada com sucesso!"
                status_text.color = "green"
            else:
                status_text.value = "Ocorreu um erro ao desvincular."
                status_text.color = "red"
            page.update()

        return ft.View(
            "/profile/google",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                ft.Column(
                    expand=1,
                    alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
                    controls=[
                        create_header(page, user_logged_in),
                        ft.Container(
                            expand=1,
                            alignment=ft.alignment.center,
                            padding=ft.padding.all(20),
                            content=ft.ResponsiveRow(
                                controls=[
                                    ft.Column(col={"xs": 0, "md": 2}, controls=[]),
                                    ft.Column(
                                        col={"xs": 12, "md": 8},
                                        controls=[
                                            ft.Container(
                                                alignment=ft.alignment.center,
                                                content=ft.Column(
                                                    alignment=ft.MainAxisAlignment.CENTER,
                                                    horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                                    spacing=10,
                                                    controls=[
                                                        ft.Text(
                                                            "Desvincular Conta Google",
                                                            size=24,
                                                            weight=ft.FontWeight.BOLD,
                                                            text_align=ft.TextAlign.CENTER,
                                                        ),
                                                        ft.Text(
                                                            "Tem certeza de que deseja desvincular sua conta Google?\n"
                                                            "Após desvincular, você não poderá mais utilizar o login Google para acessar a plataforma.",
                                                            text_align=ft.TextAlign.CENTER,
                                                        ),
                                                        status_text,
                                                        ft.Row(
                                                            alignment=ft.MainAxisAlignment.CENTER,
                                                            spacing=10,
                                                            controls=[
                                                                ft.ElevatedButton(
                                                                    "Voltar ao Perfil",
                                                                    style=BOTAO_STYLE,
                                                                    on_click=lambda e: page.go("/profile"),
                                                                ),
                                                                ft.ElevatedButton(
                                                                    "Desvincular",
                                                                    style=BOTAO_STYLE,
                                                                    icon=ft.icons.LINK_OFF,
                                                                    on_click=desvincular_click,
                                                                ),
                                                            ],
                                                        ),
                                                    ],
                                                ),
                                            )
                                        ],
                                    ),
                                    ft.Column(col={"xs": 0, "md": 2}, controls=[]),
                                ]
                            ),
                        ),
                    ],
                )
            ],
        )

    # ---- View Principal ----
    def main_view(page):
        filter_jobs()
        global user_logged_in
        # Exemplo: Definindo width nos text fields
        search_bar_title_field.width = 300
        search_bar_city_field.width = 300

        side_container_left = ft.Container(
            expand=True,
            height=500,
            padding=20,
            col={"xs": 0, "md": 1},  # Some em telas xs, aparece em md+
        )

        side_container_right = ft.Container(
            expand=True,
            height=500,
            padding=20,
            col={"xs": 0, "md": 1},  # Some em telas xs, aparece em md+
        )

        center_container_jobs = ft.Container(
            content=job_list_view,
            expand=True,
            padding=20,
            height=500,
            col={"xs": 12, "md": 5},
        )

        center_container_description = ft.Container(
            content=job_description,
            expand=True,
            padding=20,
            height=500,
            col={"xs": 0, "md": 5},
        )

        return ft.View(
            "/",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),
                ft.Container(
                    content=ft.Column(
                        [
                            # Campos de busca e botão centralizados
                            ft.Container(
                                content=ft.ResponsiveRow(
                                    controls=[
                                        # Campo 1
                                        ft.Container(
                                            search_bar_title_field,
                                            expand=False,                # Removemos expand=True
                                            col={"xs": 12, "md": 3},     # Em telas pequenas -> 12 colunas; médias+ -> 3 colunas
                                        ),
                                        # Campo 2
                                        ft.Container(
                                            search_bar_city_field,
                                            expand=False,                
                                            col={"xs": 12, "md": 3},
                                        ),
                                        # Botão
                                        ft.Container(
                                            ft.ElevatedButton(
                                                "Buscar Vagas",
                                                style=BOTAO_STYLE,
                                                on_click=lambda e: page.go("/vagas"),
                                                height=48,
                                            ),
                                            expand=False,
                                            col={"xs": 12, "md": 2},
                                            alignment=ft.alignment.center_left,
                                        ),
                                    ],
                                    spacing=10,
                                    alignment=ft.MainAxisAlignment.CENTER,
                                ),
                            ),

                            # Row com laterais invisíveis em xs e centrado em md+
                            ft.Container(
                                content=ft.ResponsiveRow(
                                    controls=[
                                        side_container_left,
                                        center_container_jobs,
                                        center_container_description,
                                        side_container_right,
                                    ],
                                    spacing=10,
                                    alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
                                ),
                            ),
                        ],
                        spacing=20,
                        alignment=ft.MainAxisAlignment.CENTER,
                    ),
                    expand=True,
                    padding=ft.padding.symmetric(horizontal=30),
                    alignment=ft.alignment.center,
                ),
                create_footer(page),
            ],
        )

    # ---- Login View ----
    def login_view(page):
        global user_logged_in

        email_field = ft.TextField(
            hint_text="Email",
            width=300,
            fill_color="#fefefe",
            on_change=validate_email
        )
        password_field = ft.TextField(
            hint_text="Senha",
            password=True,
            width=300,
            fill_color="#fefefe"
        )
        error_message = ft.Text("", color="red")
        space_line = ft.Text("")

        def login_click(e):
            global user_logged_in, user_email, usuario, data_usuario
            data_usuario = pd.read_parquet("data/users_dataframe.parquet")

            # Se o campo de e-mail estiver com erro, não prossegue
            if email_field.error_text:
                error_message.value = "E-mail inválido!"
                page.update()
                return

            usuario_encontrado = data_usuario[
                data_usuario.email == email_field.value
            ].to_dict('records')

            if len(usuario_encontrado) == 0:
                error_message.value = "E-mail ou senha inválidos. Tente novamente."
            else:
                usuario = usuario_encontrado[0]
                stored_password_hash = usuario.get("senha")

                if verify_password(stored_password_hash, password_field.value):
                    user_logged_in = True
                    user_email = email_field.value

                    page.client_storage.set("user_email", user_email)
                    page.client_storage.set("user_logged_in", True)
                    page.client_storage.set("user_name", usuario.get("nome_completo"))

                    error_message.value = ""
                    page.go("/profile")
                else:
                    error_message.value = "E-mail ou senha inválidos. Tente novamente."

            page.update()

        return ft.View(
            "/login",
            scroll=ft.ScrollMode.AUTO,
            vertical_alignment=ft.MainAxisAlignment.START,
            controls=[
                # Coluna principal que ocupa toda a altura e “empurra” o footer
                ft.Column(
                    expand=True,  # Faz a coluna crescer verticalmente
                    alignment=ft.MainAxisAlignment.SPACE_BETWEEN,  
                    controls=[
                        create_header(page, user_logged_in),

                        # Miolo (conteúdo) que ocupa o espaço livre
                        ft.Container(
                            expand=1,  # Ocupa o espaço entre header e footer
                            alignment=ft.alignment.center,
                            padding=ft.padding.all(20),
                            content=ft.ResponsiveRow(
                                controls=[
                                    # Coluna lateral esquerda
                                    ft.Column(
                                        col={"xs": 0, "md": 2},  # Some em telas menores, aparece com 2 colunas em md+
                                        controls=[]
                                    ),
                                    
                                    # Coluna central
                                    ft.Column(
                                        col={"xs": 12, "md": 8},  # Em telas pequenas ocupa tudo (12), em md+ ocupa 8
                                        controls=[
                                            ft.Column(
                                                expand=True,
                                                alignment=ft.MainAxisAlignment.CENTER,
                                                horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                                spacing=15,
                                                controls=[
                                                    ft.Text("Login", size=28, weight=ft.FontWeight.BOLD),
                                                    email_field,
                                                    password_field,
                                                    error_message,
                                                    ft.Row(
                                                        alignment=ft.MainAxisAlignment.CENTER,
                                                        spacing=10,
                                                        controls=[
                                                            ft.ElevatedButton(
                                                                content=ft.Text(
                                                                    "Voltar",  # Texto do botão
                                                                    color="black",
                                                                ),
                                                                style=ft.ButtonStyle(
                                                                    bgcolor="lightgray",  # Cor de fundo do botão
                                                                    # padding=ft.symmetric(horizontal=10, vertical=6),  # Padding interno
                                                                    shape=ft.RoundedRectangleBorder(radius=8),  # Bordas arredondadas
                                                                ),
                                                                on_click=lambda e: page.go("/"),  # Ação ao clicar no botão
                                                            ),
                                                            ft.ElevatedButton(
                                                                content=ft.Row(
                                                                    controls=[
                                                                        ft.Container(
                                                                            content=ft.Image(
                                                                                src="/Logos/google.png",  # Substitua pelo caminho da imagem do Google
                                                                                width=16,  # Tamanho da imagem
                                                                                # height=16,
                                                                            ),
                                                                            padding=ft.padding.only(right=10),  # Espaçamento entre o ícone e o texto
                                                                        ),
                                                                        ft.Text(
                                                                            "Continuar com Google",
                                                                            size=14,
                                                                            color="black",  # Cor do texto
                                                                        ),
                                                                    ],
                                                                    alignment=ft.MainAxisAlignment.CENTER,
                                                                ),
                                                                style=ft.ButtonStyle(
                                                                    bgcolor="lightgray",  # Fundo cinza
                                                                    shape=ft.RoundedRectangleBorder(radius=8),  # Bordas arredondadas (opcional)
                                                                ),
                                                                on_click=lambda e: google_login(page),
                                                            ),
                                                            ft.ElevatedButton(
                                                                "Entrar",
                                                                style=BOTAO_STYLE,
                                                                on_click=login_click
                                                            ),
                                                        ]
                                                    ),
                                                    space_line,
                                                    ft.Row(
                                                        controls=[
                                                            ft.Text(
                                                                spans=[
                                                                    ft.TextSpan(
                                                                        text="Esqueceu sua senha? ",
                                                                        style=ft.TextStyle(
                                                                            color="gray",
                                                                            size=14,
                                                                            italic=True
                                                                        ),
                                                                    ),
                                                                    ft.TextSpan(
                                                                        text="Recupere aqui",
                                                                        style=ft.TextStyle(
                                                                            color="blue",
                                                                            italic=True,
                                                                            decoration="underline",  # Sublinhado
                                                                        ),
                                                                        on_click=lambda e: page.go("/nova-senha"),  # Redireciona ao clicar
                                                                    ),
                                                                ],
                                                                size=14,  # Tamanho do texto base
                                                            )
                                                        ],
                                                        alignment=ft.MainAxisAlignment.CENTER,  # Centraliza a linha
                                                    ),
                                                    space_line,
                                                    ft.Row(
                                                        controls=[
                                                            ft.Text(
                                                                spans=[
                                                                    ft.TextSpan(
                                                                        text="Ainda não se cadastrou? ",
                                                                        style=ft.TextStyle(
                                                                            color="black",
                                                                            size=14,
                                                                        ),
                                                                    ),
                                                                    ft.TextSpan(
                                                                        text="Cadastre-se aqui",
                                                                        style=ft.TextStyle(
                                                                            color="blue",
                                                                            italic=True,
                                                                            decoration="underline",  # Sublinhado
                                                                        ),
                                                                        on_click=lambda e: page.go("/cadastro"),  # Redireciona ao clicar
                                                                    ),
                                                                ],
                                                                size=14,  # Tamanho geral do texto
                                                            )
                                                        ],
                                                        alignment=ft.MainAxisAlignment.CENTER,  # Centraliza a linha
                                                    ),
                                                ],
                                            )
                                        ]
                                    ),

                                    # Coluna lateral direita
                                    ft.Column(
                                        col={"xs": 0, "md": 1},  # Some em telas menores, aparece em md+
                                        controls=[]
                                    ),
                                ]
                                
                            ),
                        ),
                        ft.Container(
                            ft.Column(
                                col={"xs": 0, "md": 1},  # Some em telas menores, aparece em md+
                                height = 100
                            )
                        ),
                        # Footer fixo ao final
                        create_footer(page),
                    ]
                ),
            ]
        )

    # ---- Profile View ----
    def profile_view(page):
        global user_email, data_usuario, user_logged_in
        data_usuario = pd.read_parquet("data/users_dataframe.parquet")

        user_email = page.client_storage.get("user_email")
        usuario = data_usuario.loc[data_usuario['email'] == user_email]

        if not usuario.empty:
            user_name = usuario.iloc[0]["nome_completo"]
            telefone = usuario.iloc[0].get("telefone", "Não informado")
            cargo_interesse = usuario.iloc[0].get("cargo_interesse", "Não informado")
            if not usuario["foto_url"].isna().values[0] and usuario["foto_url"].values[0] != "":
                current_foto_url ="/uploads/"+usuario["foto_url"].values[0]
            else:
                current_foto_url = "/Logos/perfil.png"  # Caminho padrão (verifique se existe e é servível)

            return ft.View(
                "/profile",
                scroll=ft.ScrollMode.AUTO,
                controls=[
                    create_header(page, user_logged_in),
                    ft.Container(
                        content=ft.Column(
                            controls=[
                                # Bloco de informações e foto em uma linha
                                ft.ResponsiveRow(
                                    controls=[
                                        ft.Container(
                                            col={"xs": 0, "md": 3},  # Responsivo: ocupa menos espaço em telas maiores
                                            alignment=ft.alignment.center,
                                        ),
                                        # Informações à esquerda
                                        ft.Container(
                                            content=
                                            ft.Column(
                                                controls=[
                                                    ft.Text(f"{user_name}", size=24, weight=ft.FontWeight.BOLD),
                                                    ft.Text(f"Email: {user_email}", size=16),
                                                    ft.Text(f"Telefone: {telefone}", size=16),
                                                    ft.Text(f"Cargo de Interesse: {cargo_interesse}", size=16),
                                                ],
                                                alignment=ft.MainAxisAlignment.START,
                                                spacing=10,
                                            ),
                                            col={"xs": 12, "md": 4},  # Responsivo: ocupa mais espaço em telas maiores
                                            alignment=ft.alignment.top_left,
                                            padding=10,
                                        ),
                                        # Foto à direita
                                        ft.Container(
                                            content=ft.Image(
                                                src=current_foto_url,
                                                width=150,
                                                height=150,
                                                error_content=ft.Icon(ft.icons.ERROR),
                                            ),
                                            col={"xs": 12, "md": 4},  # Responsivo: ocupa menos espaço em telas maiores
                                            alignment=ft.alignment.center_left,
                                            padding=10,
                                        ),
                                            ft.Container(
                                            col={"xs": 0, "md": 3},  # Responsivo: ocupa menos espaço em telas maiores
                                            alignment=ft.alignment.center,
                                        ),
                                    ],
                                    alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
                                    spacing=20,
                                ),
                                # Botões abaixo do bloco
                                ft.Row(
                                    controls=[
                                        ft.ElevatedButton(
                                            "Alterar Cadastro",
                                            style=BOTAO_STYLE,
                                            on_click=lambda e: page.go("/profile/edicao"),
                                            width=150,
                                        ),
                                        ft.ElevatedButton(
                                            "Alterar Foto",
                                            style=BOTAO_STYLE,
                                            on_click=lambda e: page.go("/profile/foto"),
                                            width=150,
                                        ),
                                    ],
                                    alignment=ft.MainAxisAlignment.CENTER,  # Centraliza os botões
                                    spacing=10,
                                ),
                            ],
                            spacing=20,
                        ),
                        alignment=ft.alignment.center,
                        padding=ft.padding.symmetric(horizontal=20, vertical=20),
                    ),
                    ft.Container(
                        ft.Column(
                            col={"xs": 0, "md": 1},  # Some em telas menores, aparece em md+
                            height = 220
                        )
                    ),
                    create_footer(page),
                ],
            )
        else:
            return ft.View(
                "/profile",
                # scroll=ft.ScrollMode.AUTO,
                controls=[
                    create_header(page, user_logged_in),
                    ft.Container(
                        content=ft.Column(
                            [
                                ft.Text(
                                    "Usuário não encontrado. Faça login novamente.",
                                    size=24,
                                    color="red",
                                    text_align=ft.TextAlign.CENTER  # Centraliza o texto horizontalmente
                                ),
                                ft.ElevatedButton(
                                    "Sair",
                                    style=BOTAO_STYLE,
                                    on_click=lambda e: page.go("/")
                                )
                            ],
                            alignment=ft.MainAxisAlignment.CENTER,  # Centraliza verticalmente
                            horizontal_alignment=ft.CrossAxisAlignment.CENTER  # Centraliza horizontalmente
                        ),
                        alignment=ft.alignment.center,  # Centraliza o conteúdo do Container
                        expand=True  # Faz o Container ocupar todo o espaço disponível
                    ),
                    create_footer(page),
                ]
            )

    def change_name_foto(old_filename: str, user_email: str) -> str:
        upload_folder = "assets/uploads"
        os.makedirs(upload_folder, exist_ok=True)
        old_path = os.path.join(upload_folder, old_filename)

        _, extension = os.path.splitext(old_filename)
        sanitized_email = user_email.replace("@", "_").replace(".", "_")
        new_filename = f"{sanitized_email}{extension}"
        new_path = os.path.join(upload_folder, new_filename)

        if os.path.exists(old_path):
            os.rename(old_path, new_path)
            print(f"Arquivo renomeado de {old_filename} para {new_filename}")
            return new_filename
        else:
            print(f"Arquivo {old_filename} não encontrado em {upload_folder}!")
            return old_filename


    def profile_foto_view(page: ft.Page):
        """Página responsiva para trocar a foto de perfil."""
        global data_usuario, user_email
        # Carregar DataFrame de usuários
        try:
            data_usuario = pd.read_parquet("data/users_dataframe.parquet")
        except FileNotFoundError:
            data_usuario = pd.DataFrame(columns=[
                "nome_completo", "email", "telefone", "senha",
                "cargo_interesse", "foto_url"
            ])

        # Obter o e-mail do usuário logado
        user_email = page.client_storage.get("user_email")
        if not user_email:
            # Redirecionar se o usuário não estiver logado
            return ft.View(
                "/profile/foto",
                controls=[
                    create_header(page),
                    ft.Text("Usuário não encontrado ou não logado.", color="red")
                ]
            )

        # Localizar os dados do usuário no DataFrame
        usuario_data = data_usuario[data_usuario["email"] == user_email]
        if usuario_data.empty:
            return ft.View(
                "/profile/foto",
                controls=[
                    create_header(page, user_logged_in),
                    ft.Text("Usuário não encontrado no banco de dados.", color="red")
                ]
            )

        # Definir o caminho da foto: se vazio/NaN, usa imagem default
        if not usuario_data["foto_url"].isna().values[0] and usuario_data["foto_url"].values[0] != "":
            current_foto_url ="/uploads/"+usuario_data["foto_url"].values[0]
        else:
            current_foto_url = "/Logos/perfil.png"  # Caminho padrão (verifique se existe e é servível)
        
        # Cria o componente de imagem
        foto_preview = ft.Image(
            src=current_foto_url,
            width=200
        )

        prog_bars: dict[str, ft.ProgressRing] = {}
        files = ft.Ref[ft.Column]()
        upload_button = ft.Ref[ft.ElevatedButton]()

        def file_picker_result(e: ft.FilePickerResultEvent):
            upload_button.current.disabled = True if e.files is None else False
            prog_bars.clear()
            files.current.controls.clear()
            if e.files is not None:
                for f in e.files:
                    prog = ft.ProgressRing(value=0, bgcolor="#eeeeee", width=20, height=20)
                    prog_bars[f.name] = prog
                    files.current.controls.append(ft.Row([prog, ft.Text(f.name)]))
            page.update()

        def on_upload_progress(e: ft.FilePickerUploadEvent):
            # Atualizar a barra de progresso
            prog_bars[e.file_name].value = e.progress
            prog_bars[e.file_name].update()

        file_picker = ft.FilePicker(on_result=file_picker_result, on_upload=on_upload_progress)

        def upload_files(e):
            """Faz upload dos arquivos e chama a função para renomear."""
            uf = []
            if file_picker.result is not None and file_picker.result.files is not None:
                # Preparando lista para upload
                for f in file_picker.result.files:
                    uf.append(
                        ft.FilePickerUploadFile(
                            name=f.name,
                            upload_url=page.get_upload_url(f.name, 600),
                        )
                    )

                # Executa o upload
                file_picker.upload(uf)
                print("Arquivos enviados:", uf)

                # Aguarda um pouco (ou verifique se finalizou de fato)
                time.sleep(1)

                # Depois do upload, renomear o arquivo no servidor
                if file_picker.result.files:
                    uploaded_file_name = file_picker.result.files[0].name
                    new_file_name = change_name_foto(uploaded_file_name, user_email)

                    # Atualizar no DataFrame
                    data_usuario.loc[data_usuario["email"] == user_email, "foto_url"] = new_file_name
                    data_usuario.to_parquet("data/users_dataframe.parquet", index=False)

                    print(f"Novo nome do arquivo: {new_file_name}")

                    # Atualizar preview da foto
                    foto_preview.src = new_file_name  # Se você servir /uploads/<arquivo>, ajuste aqui
                    foto_preview.update()
                    page.update()
                    time.sleep(1)
                    page.go("/profile")

        page.overlay.append(file_picker)
        page.update()
        return ft.View(
            "/profile/foto",
            scroll=ft.ScrollMode.AUTO,  # Permite scroll automático na View
            controls=[
                create_header(page, user_logged_in),  # Cabeçalho
                ft.Column(
                    expand=True,  # Permite que a coluna se expanda no espaço disponível
                    alignment=ft.MainAxisAlignment.START,
                    horizontal_alignment=ft.CrossAxisAlignment.STRETCH,
                    controls=[
                        ft.Container(
                            expand=True,
                            alignment=ft.alignment.center,
                            padding=ft.padding.symmetric(horizontal=20, vertical=20),
                            content=ft.ResponsiveRow(
                                alignment=ft.MainAxisAlignment.CENTER,
                                vertical_alignment=ft.CrossAxisAlignment.CENTER,
                                controls=[
                                    ft.Column(
                                        col={"sm": 12, "md": 6, "lg": 4},
                                        alignment=ft.MainAxisAlignment.CENTER,
                                        horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                        controls=[
                                            # Título
                                            ft.Text(
                                                "Atualizar Foto de Perfil",
                                                size=24,
                                                weight=ft.FontWeight.BOLD,
                                                text_align=ft.TextAlign.CENTER,
                                            ),
                                            # Pré-visualização da foto
                                            ft.Container(
                                                alignment=ft.alignment.center,
                                                content=foto_preview,
                                            ),
                                            # Botão para escolher foto
                                            ft.Container(
                                                alignment=ft.alignment.center,
                                                content=ft.ElevatedButton(
                                                    "Escolher Foto",
                                                    icon=ft.icons.UPLOAD_FILE,
                                                    style=BOTAO_STYLE,
                                                    on_click=lambda _: file_picker.pick_files(allow_multiple=False),
                                                ),
                                            ),
                                            # Lista de arquivos carregados
                                            ft.Container(
                                                alignment=ft.alignment.center,
                                                content=ft.Column(
                                                    ref=files,
                                                    alignment=ft.MainAxisAlignment.CENTER,
                                                    horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                                    controls=[
                                                        ft.Text(
                                                            "Nenhum arquivo carregado",
                                                            size=14,
                                                        ),
                                                    ],
                                                ),
                                            ),
                                            # Botões de ação
                                            ft.Row(
                                                alignment=ft.MainAxisAlignment.CENTER,
                                                controls=[
                                                    ft.ElevatedButton(
                                                        "Voltar ao Perfil",
                                                        style=BOTAO_STYLE_BACK,
                                                        on_click=lambda e: page.go("/profile"),
                                                    ),
                                                    ft.ElevatedButton(
                                                        "Salvar Foto",
                                                        ref=upload_button,
                                                        style=BOTAO_STYLE,
                                                        on_click=upload_files,
                                                    ),
                                                ],
                                            ),
                                            # Novo container para ajuste abaixo dos botões
                                            ft.Container(
                                                height=70,  # Altura ajustável
                                                alignment=ft.alignment.center,
                                            ),
                                        ],
                                    ),
                                ],
                            ),
                        ),
                    ],
                ),
                # Footer fixado no final

                create_footer(page),
            ],
        )

    # ---- Cadastro View ----
    def cadastro_view(page):
        global dados_usuario

        # Definindo as checkboxes e carregando o banco de dados
        checkbox_termos = ft.Checkbox(label="Aceito os termos de uso", value=False)
        checkbox_privacidade = ft.Checkbox(label="Aceito a política de privacidade.", value=False)
        checkbox_cookies = ft.Checkbox(label="Aceito a política de cookies.", value=False)
        dados_usuario = pd.read_parquet("data/users_dataframe.parquet")

        # Função para exibir um Snackbar
        def show_snack_bar(message):
            snack_bar = ft.SnackBar(ft.Text(message))
            page.overlay.append(snack_bar)
            snack_bar.open = True
            page.update()

        def mask_telefone(e):
            # Extract only digits and limit to 11 characters
            raw_digits = ''.join(filter(str.isdigit, telefone_field.value))[:11]
            
            masked = []
            raw = list(raw_digits)
            
            # Process area code (first 2 digits)
            area = []
            while len(area) < 2 and raw:
                area.append(raw.pop(0))
            if area:
                masked.append('(' + ''.join(area))
                if len(area) == 2:
                    masked.append(')')
            
            # Process next 5 digits
            part1 = []
            while len(part1) < 5 and raw:
                part1.append(raw.pop(0))
            if part1:
                masked.append(' ' + ''.join(part1))
                if len(part1) == 5:
                    masked.append('-')
            
            # Process last 4 digits
            part2 = []
            while len(part2) < 4 and raw:
                part2.append(raw.pop(0))
            if part2:
                masked.append(''.join(part2))
            
            masked_str = ''.join(masked)
            
            # Update the field if the masked value is different
            if telefone_field.value != masked_str:
                telefone_field.value = masked_str
                telefone_field.update()


        # Definição de campos do formulário
        nome_completo_field = ft.TextField(hint_text="Nome Completo", expand=1, fill_color="#fefefe", on_change=validate_full_name)
        email_field = ft.TextField(hint_text="E-mail", expand=1, fill_color="#fefefe", on_change=validate_email)
        telefone_field = ft.TextField(
            label="Telefone",
            hint_text="(XX) XXXXX-XXXX",
            expand=1,
            # on_change=mask_telefone,
            fill_color="#fefefe",
            on_blur=mask_phone_on_blur,  # Aplica a máscara enquanto o usuário digita
            keyboard_type="number",
            max_length=15,

            
        )
        senha_field = ft.TextField(hint_text="Senha", password=True, expand=1, fill_color="#fefefe",on_change=validate_password)
        confirmar_senha_field = ft.TextField(hint_text="Confirme a Senha", password=True, expand=1, fill_color="#fefefe",on_change=validate_password)
        cargo_interesse_field = ft.TextField(hint_text="Cargo de Interesse", expand=1, fill_color="#fefefe")

        # Definição do Container de erro antes de ser utilizado
        error_message = ft.Container(
            visible=False,
            padding=10,
            border_radius=8,
            bgcolor="#FFCDD2",
            content=ft.Column([])  # Inicialmente vazio
        )

        success_message = ft.Text("", color="green", size=24)

        # Função para registrar o clique
        def registrar_click(e):
            global dados_usuario  # Garantindo que a variável global seja usada

            # Limpar mensagens anteriores
            error_message.value = ""
            error_message_list = []

            # Validações
            if email_field.error_text:
                error_message_list.append("Informe um e-mail válido.")
            if not nome_completo_field.value:
                error_message_list.append("Informe seu Nome Completo.")
            if senha_field.value != confirmar_senha_field.value:
                error_message_list.append("As senhas não conferem.")
            if len(senha_field.value) < 6:
                error_message_list.append("A senha deve ter no mínimo 8 caracteres contendo letra maiuscula, minuscula, numero e caracter especial.")
            if not checkbox_termos.value:
                error_message_list.append("Você deve aceitar o Termo de Adesão.")
            if not checkbox_privacidade.value:
                error_message_list.append("Você deve aceitar a Política de Privacidade.")
            if not checkbox_cookies.value:
                error_message_list.append("Você deve aceitar a Política de Cookies.")
            if any(dados_usuario.email.values == email_field.value):
                error_message_list.append("Este e-mail já está cadastrado, efetue seu login")

            # Exibir a lista de erros no container se houver mensagens
            if error_message_list:
                error_message.content = ft.Column([
                    ft.Text("ATENÇÃO! Algumas informações estão incorretas:", weight=ft.FontWeight.BOLD, color="darkred"),
                    ft.Column([ft.Text(f"• {msg}", color="darkred") for msg in error_message_list])
                ])
                error_message.visible = True
                page.update()
                return

            # Cadastro bem-sucedido
            show_snack_bar("Cadastro realizado com sucesso!")
            hashed_password = hash_password(senha_field.value)

            # Inserindo novo usuário no banco de dados
            new_row = {
                "nome_completo": nome_completo_field.value,
                "email": email_field.value,
                "telefone": telefone_field.value,
                "senha": hashed_password,
                "cargo_interesse": cargo_interesse_field.value
            }
            dados_usuario = pd.concat([dados_usuario, pd.DataFrame([new_row])], ignore_index=True)
            dados_usuario.to_parquet("data/users_dataframe.parquet")

            # Redirecionamento após cadastro
            page.go("/")
            logout(page)
            page.update()


        # Retorna a view principal:
        return ft.View(
            "/cadastro",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),

                # Coluna principal que conterá todo o layout (header, meio, footer)
                ft.Column(
                    expand=True,  # Ocupa toda a altura disponível
                    alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
                    spacing=0,
                    controls=[
                        # ---------------------
                        # 1) Conteúdo principal
                        # ---------------------
                        ft.Container(
                            expand=True,
                            alignment=ft.alignment.center,
                            padding=ft.padding.symmetric(horizontal=20, vertical=20),
                            content=ft.ResponsiveRow(
                                # 3 colunas: lateral esquerda, central (formulário), lateral direita
                                #
                                # - Em telas pequenas (xs), as colunas laterais têm largura 0 (somem).
                                # - Em telas médias (md) ou maiores, cada lateral tem 2 colunas,
                                #   e o centro fica com 8 colunas (2+8+2 = 12 no total).
                                controls=[
                                    # Lateral esquerda
                                    ft.Column(
                                        col={"xs": 0, "md": 2},
                                        controls=[],
                                    ),
                                    # Coluna central (onde ficará o formulário)
                                    ft.Column(
                                        col={"xs": 12, "md": 8},
                                        controls=[
                                            ft.Text(
                                                "Cadastro de Usuário",
                                                size=18, weight=ft.FontWeight.BOLD,
                                                text_align=ft.TextAlign.CENTER
                                            ),
                                            # Container com os campos do formulário
                                            ft.Container(
                                                alignment=ft.alignment.center,
                                                content=ft.Column(
                                                    spacing=10,
                                                    alignment=ft.MainAxisAlignment.CENTER,
                                                    horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                                    controls=[
                                                        nome_completo_field,
                                                        email_field,
                                                        telefone_field,
                                                        senha_field,
                                                        confirmar_senha_field,
                                                        cargo_interesse_field,
                                                        error_message,
                                                    ],
                                                ),
                                            ),

                                            # Container dos checkboxes e links em duas colunas lado a lado
                                            ft.Container(
                                                alignment=ft.alignment.center,
                                                content=ft.ResponsiveRow(
                                                    # Duas colunas de tamanho fixo (6 + 6 = 12),
                                                    # que ficam lado a lado em qualquer breakpoint.
                                                    controls=[
                                                        ft.Column(
                                                            col=6,
                                                            controls=[
                                                                checkbox_termos,
                                                                checkbox_privacidade,
                                                                checkbox_cookies,
                                                            ],
                                                        ),
                                                        ft.Column(
                                                            col=6,
                                                            controls=[
                                                                ft.TextButton(
                                                                    "Leia os termos de uso",
                                                                    on_click=lambda e: page.launch_url(f"{BASE_URL}/#/termos-de-uso", web_window_name="_blank"),
                                                                    style=ft.ButtonStyle(
                                                                        color="blue",
                                                                        text_style=ft.TextStyle(
                                                                            decoration=ft.TextDecoration.UNDERLINE
                                                                        )
                                                                    ),
                                                                ),
                                                                ft.TextButton(
                                                                    "Leia a política de privacidade",
                                                                        on_click=lambda e: page.launch_url(f"{BASE_URL}/#/politica-de-privacidade", web_window_name="_blank"),                                                                    style=ft.ButtonStyle(
                                                                        color="blue",
                                                                        text_style=ft.TextStyle(
                                                                            decoration=ft.TextDecoration.UNDERLINE
                                                                        )
                                                                    ),
                                                                ),
                                                                ft.TextButton(
                                                                    "Leia a política de cookies",
                                                                        on_click=lambda e: page.launch_url(f"{BASE_URL}/#/politica-de-cookies", web_window_name="_blank"),                                                                    style=ft.ButtonStyle(
                                                                        color="blue",
                                                                        text_style=ft.TextStyle(
                                                                            decoration=ft.TextDecoration.UNDERLINE
                                                                        )
                                                                    ),
                                                                ),
                                                            ],
                                                        ),
                                                    ]
                                                ),
                                            ),

                                            # Botões de ação
                                            ft.Row(
                                                alignment=ft.MainAxisAlignment.CENTER,
                                                controls=[
                                                    ft.ElevatedButton(
                                                        "Voltar",
                                                        style=BOTAO_STYLE,
                                                        on_click=lambda e: page.go("/")
                                                    ),
                                                    ft.ElevatedButton(
                                                        text="Login com Google",
                                                        icon=ft.icons.ACCOUNT_CIRCLE,
                                                        style=BOTAO_STYLE,
                                                        on_click=lambda e: google_login(page),
                                                    ),
                                                    ft.ElevatedButton(
                                                        "Cadastrar",
                                                        style=BOTAO_STYLE,
                                                        on_click=registrar_click
                                                    ),
                                                ]
                                            ),
                                        ],
                                    ),
                                    # Lateral direita
                                    ft.Column(
                                        col={"xs": 0, "md": 2},
                                        controls=[],
                                    ),
                                ]
                            ),
                        ),

                        # ----------------
                        # 2) Footer fixo
                        # ----------------
                        create_footer(page),
                    ]
                )
            ]
        )


    def profile_finalizar_cadastro(page):
        global user_email, user_name, data_usuario
        dados_usuario = pd.read_parquet("data/users_dataframe.parquet")
        user_email = page.client_storage.get("user_email")
        user_name = page.client_storage.get("user_name")

        # Campos de texto
        nome_completo_field = ft.TextField(
            value=user_name or "",
            label="Nome Completo",
            hint_text="Digite seu nome completo",
            expand=True,
            fill_color="#fefefe",
            on_change=validate_full_name
        )
        email_field = ft.TextField(
            value=user_email or "",
            label="E-mail",
            hint_text="Digite seu e-mail",
            expand=True,
            disabled=True,
            fill_color="#fefefe"
        )
        telefone_field = ft.TextField(
            hint_text="Telefone",
            label="Telefone",
            keyboard_type="number",
            max_length=11,
            expand=True,
            fill_color="#fefefe",
            on_blur=mask_phone_on_blur
        )
        cargo_interesse_field = ft.TextField(
            hint_text="Cargo de Interesse",
            label="Cargo de Interesse",
            expand=True,
            fill_color="#fefefe"
        )

        # Checkboxes
        checkbox_termos = ft.Checkbox(label="Aceito os termos de uso", value=False)
        checkbox_privacidade = ft.Checkbox(label="Aceito a política de privacidade.", value=False)
        checkbox_cookies = ft.Checkbox(label="Aceito a política de cookies.", value=False)

        # Mensagens de erro e sucesso
        error_message = ft.Container(
            visible=False,
            padding=10,
            border_radius=8,
            bgcolor="#FFCDD2",
            content=ft.Column([], spacing=5)  # Inicialmente vazio com espaçamento entre mensagens
        )
        success_message = ft.Text("", color="green", size=24, text_align="center")

        def concluir_cadastro(e):
            global data_usuario, user_logged_in

            # Verifica se o usuário já existe
            if any(data_usuario.email.values == user_email):
                user_logged_in = True
                page.client_storage.set("user_logged_in", True)
                success_message.value = "Login realizado com sucesso!"
                # Limpa as mensagens de erro
                error_message.content.controls = []
                error_message.visible = False
                page.update()
                page.go("/profile")
                return

            # Acumula mensagens de erro
            erros = []

            # Verificações de campos obrigatórios
            if not nome_completo_field.value.strip():
                erros.append("• O campo 'Nome Completo' é obrigatório.")
            if not telefone_field.value.strip():
                erros.append("• O campo 'Telefone' é obrigatório.")
            if not cargo_interesse_field.value.strip():
                erros.append("• O campo 'Cargo de Interesse' é obrigatório.")

            # Verificações dos checkboxes
            if not checkbox_termos.value:
                erros.append("• Você deve aceitar os termos de uso.")
            if not checkbox_privacidade.value:
                erros.append("• Você deve aceitar a política de privacidade.")
            if not checkbox_cookies.value:
                erros.append("• Você deve aceitar a política de cookies.")

            if erros:
                # Atualiza o Container de erros com as mensagens acumuladas
                error_message.content.controls = [ft.Text(erro, color="red") for erro in erros]
                error_message.visible = True
                # Limpa a mensagem de sucesso
                success_message.value = ""
            else:
                # Adiciona o novo usuário
                new_row = {
                    "nome_completo": nome_completo_field.value,
                    "email": user_email,
                    "telefone": telefone_field.value,
                    "senha": "",
                    "confirmar_senha": "",
                    "cargo_interesse": cargo_interesse_field.value,
                }

                data_usuario = pd.concat([data_usuario, pd.DataFrame([new_row])], ignore_index=True)
                data_usuario.to_parquet("data/users_dataframe.parquet")

                # Atualiza o estado de login
                user_logged_in = True
                page.client_storage.set("user_logged_in", True)
                success_message.value = "Cadastro concluído com sucesso!"
                # Limpa as mensagens de erro
                error_message.content.controls = []
                error_message.visible = False
                page.update()
                page.go("/profile")

            page.update()

        return ft.View(
            "/profile/finalizar-cadastro",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),

                # Coluna principal que conterá todo o layout (header, meio, footer)
                ft.Column(
                    expand=True,  # Ocupa toda a altura disponível
                    alignment=ft.MainAxisAlignment.CENTER,
                    horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                    spacing=0,
                    controls=[
                        # ---------------------
                        # 1) Conteúdo principal
                        # ---------------------
                        ft.Container(
                            expand=True,
                            alignment=ft.alignment.center,
                            padding=ft.padding.symmetric(horizontal=20, vertical=20),
                            content=ft.ResponsiveRow(
                                # 3 colunas: lateral esquerda, central (formulário), lateral direita
                                #
                                # - Em telas pequenas (xs), as colunas laterais têm largura 0 (somem).
                                # - Em telas médias (md) ou maiores, cada lateral tem 2 colunas,
                                #   e o centro fica com 8 colunas (2+8+2 = 12 no total).
                                controls=[
                                    # Lateral esquerda
                                    ft.Column(
                                        col={"xs": 0, "md": 2},
                                        controls=[],
                                    ),
                                    # Coluna central (onde ficará o formulário)
                                    ft.Column(
                                        col={"xs": 12, "md": 8},
                                        controls=[
                                            ft.Text(
                                                "Finalize seu cadastro",
                                                size=28,
                                                weight=ft.FontWeight.BOLD,
                                                text_align=ft.TextAlign.CENTER
                                            ),
                                            ft.Text(
                                                "Complete suas informações para continuar.",
                                                size=18,
                                                text_align=ft.TextAlign.CENTER
                                            ),
                                            # Container com os campos do formulário
                                            ft.Container(
                                                alignment=ft.alignment.center,
                                                content=ft.Column(
                                                    spacing=10,
                                                    alignment=ft.MainAxisAlignment.CENTER,
                                                    horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                                    controls=[
                                                        nome_completo_field,
                                                        email_field,
                                                        telefone_field,
                                                        cargo_interesse_field,
                                                    ],
                                                ),
                                            ),
                                            ft.Container(
                                                # Mensagens de erro e sucesso
                                                error_message,
                                                success_message,
                                                alignment=ft.alignment.center,
                                            ),
                                            # Container dos checkboxes e links em duas colunas lado a lado
                                            ft.ResponsiveRow(
                                                controls=[
                                                    # Coluna dos Checkboxes
                                                    ft.Column(
                                                        col={"xs": 12, "md": 6},
                                                        controls=[
                                                            checkbox_termos,
                                                            checkbox_privacidade,
                                                            checkbox_cookies,
                                                        ],
                                                    ),
                                                    # Coluna dos Links
                                                    ft.Column(
                                                        col={"xs": 12, "md": 6},
                                                        controls=[
                                                            ft.TextButton(
                                                                "Leia os termos de uso",
                                                                on_click=lambda e: page.launch_url(f"{BASE_URL}/#/termos-de-uso", web_window_name="_blank"),
                                                                style=ft.ButtonStyle(
                                                                    color="blue",
                                                                    text_style=ft.TextStyle(
                                                                        decoration=ft.TextDecoration.UNDERLINE
                                                                    )
                                                                ),
                                                            ),
                                                            ft.TextButton(
                                                                "Leia a política de privacidade",
                                                                on_click=lambda e: page.launch_url(f"{BASE_URL}/#/politica-de-privacidade", web_window_name="_blank"),
                                                                style=ft.ButtonStyle(
                                                                    color="blue",
                                                                    text_style=ft.TextStyle(
                                                                        decoration=ft.TextDecoration.UNDERLINE
                                                                    )
                                                                ),
                                                            ),
                                                            ft.TextButton(
                                                                "Leia a política de cookies",
                                                                on_click=lambda e: page.launch_url(f"{BASE_URL}/#/politica-de-cookies", web_window_name="_blank"),
                                                                style=ft.ButtonStyle(
                                                                    color="blue",
                                                                    text_style=ft.TextStyle(
                                                                        decoration=ft.TextDecoration.UNDERLINE
                                                                    )
                                                                ),
                                                            ),
                                                        ],
                                                    ),
                                                ],
                                                alignment=ft.MainAxisAlignment.CENTER,
                                                spacing=20
                                            ),

                                            # Botões de ação
                                            ft.Row(
                                                alignment=ft.MainAxisAlignment.CENTER,
                                                controls=[
                                                    ft.ElevatedButton(
                                                        "Cancelar",
                                                        style=BOTAO_STYLE,
                                                        on_click=lambda e: page.go("/")
                                                    ),
                                                    ft.ElevatedButton(
                                                        "Concluir Cadastro",
                                                        style=BOTAO_STYLE,
                                                        on_click=concluir_cadastro
                                                    ),
                                                ],
                                                spacing=20
                                            ),
                                        ],
                                    ),
                                    # Lateral direita
                                    ft.Column(
                                        col={"xs": 0, "md": 2},
                                        controls=[],
                                    ),
                                ]
                            ),
                        ),

                        # ----------------
                        # 2) Footer fixo
                        # ----------------
                        create_footer(page),
                    ]
                )
            ]
        )


    # ---- Nova Senha (Esqueci a Senha) ----
    def nova_senha_view(page):
        email_field = ft.TextField(
            hint_text='Informe o e-mail que utilizou no momento do cadastro',
            fill_color="#fefefe",
            on_change=validate_email  # Valida em tempo real
        )

        error_message = ft.Text("", color="red")
        success_message = ft.Text("", color="green")

        def enviar_email(e):
            global user_email
            error_message.value = ""  # Limpa mensagens de erro anteriores
            success_message.value = ""  # Limpa mensagens de sucesso anteriores
            
            if not email_field.value:  # Verifica se o campo está vazio
                error_message.value = "Por favor, insira um e-mail válido."
                page.update()
                return

            # Valida o formato do e-mail
            if email_field.error_text:
                error_message.value = "E-mail inválido!"
                page.update()
                return

            # Consulta no banco de dados se o e-mail existe
            user_email = email_field.value
            if not verificar_email_no_banco(user_email):  # Substitua pela sua função de consulta
                error_message.value = "Este e-mail não está cadastrado."
                page.update()
                return

            # Caso o e-mail exista, envia o código de verificação
            send_verification_code(user_email)
            time.sleep(1)
            success_message.value = "Código enviado com sucesso."
            page.go("/nova-senha/codigo")
            page.update()

        return ft.View(
            "/nova-senha",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),

                # Container principal (ocupa toda a tela, alinhado ao topo para evitar espaços vazios)
                ft.Container(
                    expand=True,
                    alignment=ft.alignment.top_center,
                    padding=ft.padding.symmetric(horizontal=16, vertical=16),
                    content=ft.Column(
                        controls=[
                            ft.ResponsiveRow(
                                alignment=ft.MainAxisAlignment.START,
                                vertical_alignment=ft.CrossAxisAlignment.START,
                                controls=[
                                    # Coluna vazia (esquerda), visível só em telas maiores
                                    ft.Column(
                                        col={"xs": 0, "md": 2, "lg": 3},
                                        controls=[],
                                    ),
                                    # Coluna principal (conteúdo)
                                    ft.Column(
                                        col={"xs": 12, "md": 8, "lg": 6},
                                        spacing=20,
                                        alignment=ft.MainAxisAlignment.START,      # Alinha elementos ao topo
                                        horizontal_alignment=ft.CrossAxisAlignment.CENTER,  # Centraliza horizontal
                                        controls=[
                                            ft.Text(
                                                "Redefinir Senha",
                                                size=28,
                                                weight="bold",
                                                text_align="center",
                                            ),
                                            ft.Container(
                                                alignment=ft.alignment.center,
                                                padding=ft.padding.all(0),  # Remove o espaçamento interno
                                                content=ft.Column(
                                                    spacing=0,  # Remove o espaçamento entre os controles
                                                    alignment=ft.MainAxisAlignment.CENTER,
                                                    horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                                    controls=[
                                                        email_field,       # Campo de e-mail
                                                        error_message,     # Mensagem de erro
                                                        success_message,   # Mensagem de sucesso
                                                    ],
                                                ),
                                            ),
                                            ft.Row(
                                                controls=[
                                                    ft.ElevatedButton(
                                                        "Voltar",
                                                        style=BOTAO_STYLE,
                                                        on_click=lambda e: page.go("/login"),
                                                    ),
                                                    ft.ElevatedButton(
                                                        "Enviar Código",
                                                        style=BOTAO_STYLE,
                                                        on_click=enviar_email,
                                                    ),
                                                ],
                                                alignment=ft.MainAxisAlignment.CENTER,
                                                spacing=10,
                                            ),
                                        ],
                                    ),
                                    # Coluna vazia (direita), visível só em telas maiores
                                    ft.Column(
                                        col={"xs": 0, "md": 2, "lg": 3},
                                        controls=[],
                                    ),
                                ],
                            ),
                            # Espaço fixo (ex: 80px) para empurrar o footer para baixo
                            ft.Column(
                                col={"xs": 0, "md": 2, "lg": 3},
                                height=240,          # <- Aqui é onde você especifica a altura
                                controls=[
                                ]
                            )
                        ],
                    ),
                ),

                create_footer(page),
            ],
        )
    def nova_senha_codigo_view(page):
        codigo_field = ft.TextField(
            hint_text="Digite o código enviado ao seu e-mail",
            fill_color="#fefefe"
        )
        error_message = ft.Text("", color="red")

        def validar_codigo(e):
            if codigo_field.value == verification_code:
                error_message.value = "Código validado com sucesso!"
                page.go("/nova-senha/cadastro")
            else:
                error_message.value = "Código inválido. Tente novamente."
            page.update()

        def reenviar_email(e):
            global user_email
            send_verification_code(user_email)
            error_message.value = "E-mail reenviado com sucesso!"
            page.update()

        return ft.View(
            "/nova-senha/codigo",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),
                ft.Container(
                    expand=True,
                    alignment=ft.alignment.top_center,
                    padding=ft.padding.symmetric(horizontal=16, vertical=16),
                    content=ft.ResponsiveRow(
                        alignment=ft.MainAxisAlignment.START,
                        vertical_alignment=ft.CrossAxisAlignment.START,
                        controls=[
                            # Coluna vazia (esquerda)
                            ft.Column(
                                col={"xs": 0, "md": 2, "lg": 3},
                                controls=[],
                            ),
                            # Coluna principal
                            ft.Column(
                                col={"xs": 12, "md": 8, "lg": 6},
                                spacing=10,
                                alignment=ft.MainAxisAlignment.START,
                                horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                controls=[
                                    ft.Text(
                                        "Digite o código recebido.",
                                        size=28,
                                        text_align="center",
                                    ),
                                    codigo_field,
                                    error_message,
                                    ft.Row(
                                        alignment=ft.MainAxisAlignment.CENTER,
                                        controls=[
                                            ft.Text("Não recebeu o e-mail?"),
                                            ft.TextButton(
                                                "Clique aqui para reenviar",
                                                on_click=reenviar_email,
                                            ),
                                        ],
                                    ),
                                    ft.Row(
                                        alignment=ft.MainAxisAlignment.CENTER,
                                        controls=[
                                            ft.ElevatedButton(
                                                "Voltar",
                                                style=BOTAO_STYLE,
                                                on_click=lambda e: page.go("/nova-senha"),
                                            ),
                                            ft.ElevatedButton(
                                                "Validar Código",
                                                style=BOTAO_STYLE,
                                                on_click=validar_codigo,
                                            ),
                                        ],
                                    ),
                                    # Espaço fixo abaixo
                                    ft.Container(height=200),
                                ],
                            ),
                            # Coluna vazia (direita)
                            ft.Column(
                                col={"xs": 0, "md": 2, "lg": 3},
                                controls=[],
                            ),
                        ],
                    ),
                ),
                create_footer(page)
            ],
        )


    def alterar_profile_view(page):
        global usuario, data_usuario, user_email, user_name

        # Carregar os dados dos usuários
        data_usuario = pd.read_parquet("data/users_dataframe.parquet")

        # Obter o email do usuário atual (assumindo que está armazenado em client_storage)
        user_email = page.client_storage.get("user_email")
        if user_email:
            usuario = data_usuario[data_usuario['email'] == user_email].iloc[0].to_dict()
        else:
            usuario = {}

        # Campos de texto
        nome_completo_field = ft.TextField(
            value=usuario.get('nome_completo', ''),
            label="Nome Completo",
            hint_text="Digite seu nome completo",
            expand=True,
            fill_color="#fefefe",
            on_change=validate_full_name
        )
        telefone_field = ft.TextField(
            value=usuario.get('telefone', ''),
            label="Telefone",
            hint_text="Digite seu telefone",
            expand=True,
            fill_color="#fefefe",
            on_blur=mask_phone_on_blur,
            keyboard_type="number",
            max_length=11
        )
        email_field = ft.TextField(
            value=usuario.get('email', ''),
            label="E-mail",
            hint_text="Digite seu e-mail",
            expand=True,
            fill_color="#fefefe",
            on_change=validate_email
        )
        cargo_interesse_field = ft.TextField(
            value=usuario.get('cargo_interesse', ''),
            label="Cargo de Interesse",
            hint_text="Digite seu cargo de interesse",
            expand=True,
            fill_color="#fefefe"
        )

        # Container para mensagens de erro
        error_message = ft.Container(
            visible=False,
            padding=10,
            border_radius=8,
            bgcolor="#FFCDD2",
            content=ft.Column([], spacing=5)
        )

        # Container para mensagem de sucesso
        success_message = ft.Container(
            visible=False,
            padding=10,
            border_radius=8,
            bgcolor="#C8E6C9",
            content=ft.Text("", color="green", text_align="center")
        )

        def salvar_alteracoes(e):
            global data_usuario, usuario

            erros = []
            if not nome_completo_field.value.strip():
                erros.append("• O campo 'Nome Completo' é obrigatório.")
            if not telefone_field.value.strip():
                erros.append("• O campo 'Telefone' é obrigatório.")
            if not cargo_interesse_field.value.strip():
                erros.append("• O campo 'Cargo de Interesse' é obrigatório.")

            if erros:
                error_message.content.controls = [ft.Text(erro, color="red") for erro in erros]
                error_message.visible = True
                success_message.visible = False
            else:
                # Se quiser incluir a lógica de atualizar e-mail e fazer logout, pode ir aqui.
                data_usuario.loc[data_usuario['email'] == user_email, 'nome_completo'] = nome_completo_field.value
                data_usuario.loc[data_usuario['email'] == user_email, 'telefone'] = telefone_field.value
                data_usuario.loc[data_usuario['email'] == user_email, 'cargo_interesse'] = cargo_interesse_field.value

                # Salva as alterações no arquivo parquet
                data_usuario.to_parquet("data/users_dataframe.parquet")

                # Atualiza a variável usuario
                usuario.update({
                    'nome_completo': nome_completo_field.value,
                    'telefone': telefone_field.value,
                    'cargo_interesse': cargo_interesse_field.value
                })

                # Mostra mensagem de sucesso
                success_message.content = ft.Text("Dados atualizados com sucesso!", color="green", text_align="center")
                success_message.visible = True
                error_message.content.controls = []
                error_message.visible = False

                page.go("/profile")  # Se quiser manter o usuário na mesma página, remova esta linha.

            page.update()

        return ft.View(
            "/profile/edicao",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),
                ft.Column(
                    expand=True,
                    alignment=ft.MainAxisAlignment.CENTER,
                    horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                    spacing=0,
                    controls=[
                        ft.Container(
                            expand=True,
                            alignment=ft.alignment.center,
                            padding=ft.padding.symmetric(horizontal=20, vertical=20),
                            content=ft.ResponsiveRow(
                                controls=[
                                    ft.Column(
                                        col={"xs": 0, "md": 2},
                                        controls=[],
                                    ),
                                    ft.Column(
                                        col={"xs": 12, "md": 8},
                                        controls=[
                                            ft.Text(
                                                "Editar Perfil",
                                                size=28,
                                                weight=ft.FontWeight.BOLD,
                                                text_align=ft.TextAlign.CENTER
                                            ),
                                            ft.Text(
                                                "Atualize suas informações pessoais.",
                                                size=18,
                                                text_align=ft.TextAlign.CENTER
                                            ),
                                            # Container com os campos do formulário
                                            ft.Container(
                                                alignment=ft.alignment.center,
                                                content=ft.Column(
                                                    spacing=10,
                                                    alignment=ft.MainAxisAlignment.CENTER,
                                                    horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                                    controls=[
                                                        nome_completo_field,
                                                        telefone_field,
                                                        email_field,
                                                        cargo_interesse_field,
                                                    ],
                                                ),
                                            ),
                                            error_message,
                                            success_message,
                                            # ---------------------------------
                                            # Coluna para agrupar botões e o "Alterar Senha"
                                            # ---------------------------------
                                            ft.Column(
                                                alignment=ft.MainAxisAlignment.CENTER,
                                                horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                                spacing=15,
                                                controls=[
                                                    ft.Row(
                                                        alignment=ft.MainAxisAlignment.CENTER,
                                                        spacing=20,
                                                        controls=[
                                                            ft.ElevatedButton(
                                                                "Cancelar",
                                                                style=BOTAO_STYLE_BACK,
                                                                on_click=lambda e: page.go("/profile")
                                                            ),
                                                                ft.ElevatedButton(
                                                                "Alterar Senha",
                                                                style=BOTAO_STYLE,
                                                                # Ajuste a rota para a página de alteração de senha
                                                                on_click=lambda e: page.go("/profile/alterar-senha")
                                                            ),
                                                            ft.ElevatedButton(
                                                                "Salvar Alterações",
                                                                style=BOTAO_STYLE,
                                                                on_click=salvar_alteracoes
                                                            ),
                                                        ],
                                                    ),

                                                ]
                                            ),
                                        ],
                                    ),
                                    ft.Column(
                                        col={"xs": 0, "md": 2},
                                        controls=[],
                                    ),
                                ]
                            ),
                        ),
                        ft.Container(
                            ft.Column(
                                col={"xs": 0, "md": 1},
                                height=70
                            )
                        ),
                        create_footer(page),
                    ]
                )
            ]
        )

    def nova_senha_cadastro_view(page):
        senha_field = ft.TextField(
            hint_text="Digite sua nova senha",
            password=True,
            fill_color="#fefefe"
        )
        confirmar_senha_field = ft.TextField(
            hint_text="Confirme sua nova senha",
            password=True,
            fill_color="#fefefe"
        )
        error_message = ft.Text("", color="red")

        def salvar_senha(e):
            global user_password
            if senha_field.value == confirmar_senha_field.value:
                user_password = senha_field.value
                error_message.value = "Senha atualizada com sucesso!"
                page.go("/login")
            else:
                error_message.value = "As senhas não coincidem. Tente novamente."
            page.update()

        return ft.View(
            "/nova-senha/cadastro",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),
                ft.Container(
                    expand=True,
                    alignment=ft.alignment.top_center,
                    padding=ft.padding.symmetric(horizontal=16, vertical=16),
                    content=ft.ResponsiveRow(
                        alignment=ft.MainAxisAlignment.START,
                        vertical_alignment=ft.CrossAxisAlignment.START,
                        controls=[
                            ft.Column(
                                col={"xs": 0, "md": 2, "lg": 3},
                                controls=[],
                            ),
                            ft.Column(
                                col={"xs": 12, "md": 8, "lg": 6},
                                spacing=10,
                                alignment=ft.MainAxisAlignment.START,
                                horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                controls=[
                                    ft.Text(
                                        "Cadastrar Nova Senha",
                                        size=28,
                                        weight=ft.FontWeight.BOLD,
                                        text_align="center"
                                    ),
                                    senha_field,
                                    confirmar_senha_field,
                                    error_message,
                                    ft.ElevatedButton(
                                        "Salvar Nova Senha",
                                        style=BOTAO_STYLE,
                                        on_click=salvar_senha
                                    ),
                                    # Espaço fixo abaixo do último botão
                                    ft.Container(height=220),
                                ],
                            ),
                            ft.Column(
                                col={"xs": 0, "md": 2, "lg": 3},
                                controls=[],
                            ),
                        ],
                    ),
                ),
                create_footer(page),
            ]
        )

    # ---- Alterar Senha Perfil ----
    def profile_alterar_senha(page):
        global data_usuario, user_email

        senha_antiga_field = ft.TextField(
            hint_text="Digite sua senha antiga",
            password=True,
            fill_color="#fefefe"
        )
        senha_nova_field = ft.TextField(
            hint_text="Digite sua nova senha",
            password=True,
            fill_color="#fefefe"
        )
        confirmar_senha_nova_field = ft.TextField(
            hint_text="Confirme sua nova senha",
            password=True,
            fill_color="#fefefe"
        )
        error_message = ft.Text("", color="red")
        success_message = ft.Text("", color="green")

        def salvar_nova_senha(e):
            global data_usuario, user_email

            user_index = data_usuario.index[data_usuario['email'] == user_email].tolist()
            if not user_index:
                error_message.value = "Usuário não encontrado!"
                success_message.value = ""
                page.update()
                return

            user_idx = user_index[0]
            stored_password_hash = data_usuario.at[user_idx, 'senha']

            # Verificar a senha antiga
            if not verify_password(stored_password_hash, senha_antiga_field.value):
                error_message.value = "Senha antiga incorreta!"
                success_message.value = ""
                page.update()
                return

            # Verificar se as novas senhas coincidem
            if senha_nova_field.value != confirmar_senha_nova_field.value:
                error_message.value = "As senhas novas não coincidem!"
                success_message.value = ""
                page.update()
                return

            # Verificar se a nova senha é diferente da antiga
            if senha_antiga_field.value == senha_nova_field.value:
                error_message.value = "A nova senha não pode ser igual à antiga!"
                success_message.value = ""
                page.update()
                return

            # Verificar tamanho mínimo da senha
            if len(senha_nova_field.value) < 6:
                error_message.value = "A nova senha deve ter pelo menos 6 caracteres!"
                success_message.value = ""
                page.update()
                return

            # Gerar hash e salvar
            novo_hash = hash_password(senha_nova_field.value)
            data_usuario.at[user_idx, 'senha'] = novo_hash

            try:
                data_usuario.to_parquet("data/users_dataframe.parquet", index=False)
                error_message.value = ""
                success_message.value = "Senha alterada com sucesso!"
                # Limpar campos
                senha_antiga_field.value = ""
                senha_nova_field.value = ""
                confirmar_senha_nova_field.value = ""
                time.sleep(2)
                page.go("/profile")
            except Exception as ex:
                error_message.value = f"Erro ao salvar a nova senha: {ex}"
                success_message.value = ""

            page.update()

        return ft.View(
            "/profile/alterar-senha",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),

                ft.Container(
                    expand=True,
                    alignment=ft.alignment.top_center,  # Conteúdo começa no topo
                    padding=ft.padding.symmetric(horizontal=16, vertical=16),
                    content=ft.Column(
                        # Uma única coluna que contém nosso ResponsiveRow + container final
                        controls=[
                            ft.ResponsiveRow(
                                alignment=ft.MainAxisAlignment.START,
                                vertical_alignment=ft.CrossAxisAlignment.START,
                                controls=[
                                    # Coluna vazia (esquerda)
                                    ft.Column(
                                        col={"xs": 0, "md": 2, "lg": 3},
                                        controls=[]
                                    ),
                                    # Coluna principal (onde ficam campos e botões)
                                    ft.Column(
                                        col={"xs": 12, "md": 8, "lg": 6},
                                        spacing=20,
                                        alignment=ft.MainAxisAlignment.START,
                                        horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                                        controls=[
                                            ft.Text(
                                                "Alterar Senha",
                                                size=28,
                                                weight=ft.FontWeight.BOLD,
                                                text_align=ft.TextAlign.CENTER
                                            ),
                                            senha_antiga_field,
                                            senha_nova_field,
                                            confirmar_senha_nova_field,
                                            error_message,
                                            success_message,
                                            ft.Row(
                                                alignment=ft.MainAxisAlignment.CENTER,
                                                spacing=20,
                                                controls=[
                                                    ft.ElevatedButton(
                                                        "Cancelar",
                                                        style=BOTAO_STYLE,
                                                        on_click=lambda e: page.go("/profile")
                                                    ),
                                                    ft.ElevatedButton(
                                                        "Salvar Nova Senha",
                                                        style=BOTAO_STYLE,
                                                        on_click=salvar_nova_senha
                                                    ),
                                                ]
                                            ),
                                            # Container para empurrar o footer
                                            ft.Container(height=60),
                                        ],
                                    ),
                                    # Coluna vazia (direita)
                                    ft.Column(
                                        col={"xs": 0, "md": 2, "lg": 3},
                                        controls=[]
                                    ),
                                ],
                            ),
                        ],
                    ),
                ),

                create_footer(page),
            ]
        )

    # ---- Filtro de vagas (página /vagas) ----
    def filter_jobs_vagas(search_bar_title_field, search_bar_city_field):
        global jobs_df
        global modelo_trabalho_selecionado_str, salario_selecionado_str

        filtered_jobs = jobs_df.copy()

        # Filtrar por título e cidade
        if search_bar_title_field.value:
            filtered_jobs = filtered_jobs[
                filtered_jobs["title"].str.contains(search_bar_title_field.value, case=False, na=False)
            ]
        if search_bar_city_field.value:
            filtered_jobs = filtered_jobs[
                filtered_jobs["location"].str.contains(search_bar_city_field.value, case=False, na=False)
            ]

        # Filtrar por modelo de trabalho
        if modelo_trabalho_selecionado_str != "Todos":
            filtered_jobs = filtered_jobs[
                ((filtered_jobs["job_type"] == "None") & (modelo_trabalho_selecionado_str == "Presencial")) |
                ((filtered_jobs["job_type"] != "None") & (modelo_trabalho_selecionado_str == "Remoto"))
            ]

        # Filtrar por dias da vaga
        if dias_selecionados_str != "Todos":
            dias = int(dias_selecionados_str)
            limite_data = datetime.now() - timedelta(days=dias)
            filtered_jobs = filtered_jobs[
                pd.to_datetime(filtered_jobs["date_posted"], errors="coerce") >= limite_data
            ]

        # Filtrar por faixa salarial
        if salario_selecionado_str != "Todos":
            if salario_selecionado_str == "< R$2.000,00":
                filtered_jobs = filtered_jobs[filtered_jobs["salary_source"].apply(parse_salary) < 2000]
            elif salario_selecionado_str == "R$2.000 - R$4.000":
                filtered_jobs = filtered_jobs[
                    (filtered_jobs["salary_source"].apply(parse_salary) >= 2000)
                    & (filtered_jobs["salary_source"].apply(parse_salary) <= 4000)
                ]
            elif salario_selecionado_str == "> R$6.000":
                filtered_jobs = filtered_jobs[filtered_jobs["salary_source"].apply(parse_salary) > 6000]

        # Filtrar por estado
        if estado_selecionado_str != "Todos":
            if estado_selecionado_str == "Outros":
                estados_principais = "|".join([estado for estado in ESTADOS_BRASILEIROS if estado not in ["Todos", "Outros"]])
                filtered_jobs = filtered_jobs[
                    ~filtered_jobs["location"].str.contains(estados_principais, case=False, na=False)
                ]
            else:
                filtered_jobs = filtered_jobs[
                    filtered_jobs["location"].str.contains(fr"\b{estado_selecionado_str}\b", case=False, na=False)
                ]

        # Limpar a lista de vagas antes de adicionar os resultados filtrados
        job_list_view.controls.clear()

        if filtered_jobs.empty:
            # Se não houver vagas, exibe a mensagem no lado esquerdo
            job_list_view.controls.append(
                ft.Container(
                    content=ft.Text(
                        "Nenhuma vaga localizada com este filtro",
                        size=16,
                        weight=ft.FontWeight.BOLD,
                        text_align=ft.TextAlign.CENTER,
                    ),
                    padding=20,
                    alignment=ft.alignment.center,
                )
            )
        else:
            # Adicionar as vagas filtradas normalmente
            job_list_view.controls.append(
                ft.Container(
                    content=ft.Column(
                        controls=[
                            ft.Container(
                                content=ft.Column(
                                    controls=[
                                        ft.Text(job["title"], size=18, weight=ft.FontWeight.BOLD),
                                        ft.Text(f"{job['location']}"),
                                        ft.Text(f"{job['company']}"),
                                        ft.ResponsiveRow(
                                            controls=[
                                                ft.Container(
                                                    content=ft.ElevatedButton(
                                                        "Ver Detalhes",
                                                        style=BOTAO_STYLE_VER_DETALHES,
                                                        on_click=lambda e, job=job.to_dict(): select_job(job, page),
                                                    ),
                                                    col={"xs": 0, "md": 6},
                                                ),
                                                ft.Container(
                                                    content=ft.ElevatedButton(
                                                        "Ver Detalhes",
                                                        style=BOTAO_STYLE,
                                                        on_click=lambda e, job=job.to_dict(), index=index: page.go(
                                                            f"/vagas/{generate_slug(job['title'], job['location'], index)}"
                                                        ),
                                                    ),
                                                    col={"xs": 12, "md": 0},
                                                ),
                                            ],
                                            alignment=ft.MainAxisAlignment.START,
                                            spacing=5,
                                        ),
                                    ],
                                    spacing=5,
                                ),
                                border=ft.border.all(1, BORDER_COLOR),
                                border_radius=BORDER_RADIUS,
                                padding=10,
                                margin=ft.margin.symmetric(vertical=3),
                                height=150,
                            )
                            for index, job in filtered_jobs.iterrows()
                        ],
                        spacing=5,
                        scroll=ft.ScrollMode.AUTO,
                        horizontal_alignment=ft.CrossAxisAlignment.STRETCH,
                    ),
                    height=500,
                    border_radius=BORDER_RADIUS,
                    padding=10,
                    margin=ft.margin.symmetric(vertical=1),
                    expand=True,
                )
            )
        # >>>>>>>>>>>>>>>>>> ATUALIZA O BANNER <<<<<<<<<<<<<<<<
        # Atualiza o texto do cargo selecionado de acordo com o que foi digitado
        if search_bar_title_field.value.strip():
            cargo_selecionado_text.value = search_bar_title_field.value
        else:
            cargo_selecionado_text.value = "Nome do cargo selecionado"
        cargo_selecionado_text.update()

        # Atualiza o texto da quantidade de vagas
        quantidade = len(filtered_jobs)
        quantidade_vagas_text.value = f"+ de {quantidade} vagas"
        quantidade_vagas_text.update()
        
        # Atualizar a página
        page.update()

    # ---- Página /vagas ----
    def vagas_view(page: ft.Page):
        global modelo_trabalho_selecionado_str, salario_selecionado_str
        global cargo_selecionado_text, quantidade_vagas_text
        

        # Campos de busca
        search_bar_title_field = ft.TextField(
            fill_color=ft.colors.WHITE70,
            hint_text="Buscar vagas por título...",
            expand=True,
            prefix_icon=ft.icons.SEARCH,
            on_change=lambda e: filter_jobs_vagas(search_bar_title_field, search_bar_city_field),
        )
        search_bar_city_field = ft.TextField(
            fill_color="#fefefe",
            hint_text="Buscar vagas por cidade...",
            expand=True,
            prefix_icon=ft.icons.LOCATION_ON,
            on_change=lambda e: filter_jobs_vagas(search_bar_title_field, search_bar_city_field),
        )
        cargo_selecionado_text = ft.Text(
            value="Nome do cargo selecionado",  # Valor inicial
            weight=ft.FontWeight.W_100
        )

        quantidade_vagas_text = ft.Text(
            value="Quantidade de vagas disponíveis",  # Valor inicial
            weight=ft.FontWeight.W_200
        )
        # search_bar_title_field.width = 300
        # search_bar_city_field.width = 300
        # Textos que serão exibidos como conteúdo dos PopupMenuButton
        modelo_trabalho_text = ft.Text("Modelo", color="#FFFFFF")
        # salario_text = ft.Text("Faixa de Salário", color="#FFFFFF")
        dias_da_vaga_menu_text = ft.Text("Publicação", color="#FFFFFF")
        estado_text = ft.Text("Localização", color="#FFFFFF")

        # Funções de atualização
        def update_modelo_trabalho(valor: str):
            global modelo_trabalho_selecionado_str
            modelo_trabalho_selecionado_str = valor
            
            # Se "Todos" for selecionado, exibir o texto padrão "Modelo"
            modelo_trabalho_text.value = "Modelo" if valor == "Todos" else valor
            modelo_trabalho_text.update()
            
            filter_jobs_vagas(search_bar_title_field, search_bar_city_field)

        # def update_salario(valor: str):
        #     global salario_selecionado_str
        #     salario_selecionado_str = valor
        #     # Atualiza o texto que aparece no Popup
        #     salario_text.value = valor
        #     salario_text.update()
        #     filter_jobs_vagas(search_bar_title_field, search_bar_city_field)
        
        def update_dias_vaga(dias: str):
            global dias_selecionados_str
            dias_selecionados_str = dias

            # Se "Todos" for selecionado, exibir o texto padrão "Publicação"
            if dias == "Todos":
                dias_da_vaga_menu_text.value = "Publicação"
            else:
                try:
                    dias_int = int(dias)  # Tenta converter para int
                    dias_da_vaga_menu_text.value = f"{dias_int} dias"
                except ValueError:
                    dias_da_vaga_menu_text.value = dias  # Mantém o texto original

            dias_da_vaga_menu_text.update()
            filter_jobs_vagas(search_bar_title_field, search_bar_city_field)

        def update_estado(estado: str):
            global estado_selecionado_str
            estado_selecionado_str = estado

            # Se "Todos" for selecionado, exibir o texto padrão "Localização"
            estado_text.value = "Localização" if estado == "Todos" else estado
            estado_text.update()

            filter_jobs_vagas(search_bar_title_field, search_bar_city_field)



        # PopupMenuButton para Modelo de Trabalho
        modelo_trabalho_dropdown = ft.PopupMenuButton(
            tooltip="",
            content=ft.Container(
                content=modelo_trabalho_text,
                bgcolor="#013764",
                border_radius=8,
                padding=ft.padding.symmetric(horizontal=8, vertical=8),
                alignment=ft.alignment.center,
            ),
            items=[
                ft.PopupMenuItem(text="Todos", on_click=lambda e: update_modelo_trabalho("Todos")),
                ft.PopupMenuItem(),
                ft.PopupMenuItem(text="Remoto", on_click=lambda e: update_modelo_trabalho("Remoto")),
                ft.PopupMenuItem(text="Presencial", on_click=lambda e: update_modelo_trabalho("Presencial")),
            ],
            menu_position="under",
            
            expand=True,
        )
        dias_da_vaga_menu = ft.PopupMenuButton(
            tooltip="",
            content=ft.Container(
                content=dias_da_vaga_menu_text,
                bgcolor="#013764",
                border_radius=8,
                padding=ft.padding.symmetric(horizontal=8, vertical=8),
                alignment=ft.alignment.center,
            ),
            items=[
                ft.PopupMenuItem(text="Todos", on_click=lambda e: update_dias_vaga("Todos")),
                ft.PopupMenuItem(text="Últimos 3 dias", on_click=lambda e: update_dias_vaga(3)),
                ft.PopupMenuItem(text="Últimos 7 dias", on_click=lambda e: update_dias_vaga(7)),
                ft.PopupMenuItem(text="Últimos 15 dias", on_click=lambda e: update_dias_vaga(15)),
                ft.PopupMenuItem(text="Último Mês", on_click=lambda e: update_dias_vaga(31)),
            ],
            menu_position="under",
            expand=True,
        )

        # # PopupMenuButton para Faixa Salarial
        # salario_dropdown = ft.PopupMenuButton(
        #     content=ft.Container(
        #         content=salario_text,
        #         bgcolor="#013764",
        #         border_radius=8,
        #         padding=ft.padding.symmetric(horizontal=8, vertical=8),
        #         alignment=ft.alignment.center,
        #     ),
        #     items=[
        #         ft.PopupMenuItem(text="Todos", on_click=lambda e: update_salario("Todos")),
        #         ft.PopupMenuItem(),
        #         ft.PopupMenuItem(text="< R$2.000,00", on_click=lambda e: update_salario("< R$2.000,00")),
        #         ft.PopupMenuItem(text="R$2.000 - R$4.000", on_click=lambda e: update_salario("R$2.000 - R$4.000")),
        #         ft.PopupMenuItem(text="> R$6.000", on_click=lambda e: update_salario("> R$6.000")),
        #     ],
        #     expand=True,
        # )

        estado_vaga_menu = ft.PopupMenuButton(
            tooltip="",
            content=ft.Container(
                content=estado_text,
                bgcolor="#013764",
                border_radius=8,
                padding=ft.padding.symmetric(horizontal=8, vertical=8),
                alignment=ft.alignment.center,
            ),
            items=[
                ft.PopupMenuItem(
                    text=estado,
                    on_click=lambda e, est=estado: update_estado(est)
                )
                for estado in ESTADOS_BRASILEIROS
            ],
            menu_position="under",
            # expand=True,
        )

        # Layout da página
        return ft.View(
            "/vagas",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),
                ft.Container(
                    content=ft.Column(
                        controls=[
                            # Campos de busca centralizados
                            ft.Container(
                                content=ft.ResponsiveRow(
                                    controls=[
                                        ft.Container(
                                            content=search_bar_title_field,
                                            col={"xs": 12, "md": 3},
                                            alignment=ft.alignment.center,
                                        ),
                                        ft.Container(
                                            content=search_bar_city_field,
                                            col={"xs": 12, "md": 3},
                                            alignment=ft.alignment.center,
                                        ),
                                        ft.Container(
                                            content=ft.ElevatedButton(
                                                "Buscar Vagas",
                                                height=48,
                                                style=BOTAO_STYLE,
                                                on_click=lambda e: filter_jobs_vagas(
                                                    search_bar_title_field, search_bar_city_field
                                                ),
                                            ),
                                            col={"xs": 12, "md": 2},
                                            alignment=ft.alignment.center_left,
                                        ),
                                    ],
                                    spacing=10,
                                    alignment=ft.MainAxisAlignment.CENTER,
                                ),
                                padding=ft.padding.symmetric(vertical=10),
                                alignment=ft.alignment.center,
                            ),

                            # Filtros centralizados
                            ft.Container(
                                content=ft.ResponsiveRow(
                                    controls=[
                                        ft.Container(
                                            content=modelo_trabalho_dropdown,
                                            col={"xs": 12, "md": 2},
                                            alignment=ft.alignment.center,
                                            margin=ft.margin.symmetric(horizontal=5),
                                        ),
                                        ft.Container(
                                            content=dias_da_vaga_menu,
                                            col={"xs": 12, "md": 2},
                                            alignment=ft.alignment.center,
                                            margin=ft.margin.symmetric(horizontal=5),
                                        ),
                                        ft.Container(
                                            content=estado_vaga_menu,
                                            col={"xs": 12, "md": 2},
                                            alignment=ft.alignment.center,
                                            margin=ft.margin.symmetric(horizontal=5),
                                        ),
                                        ft.Container(
                                            content=ft.ElevatedButton(
                                                "Limpar Filtros",
                                                style=BOTAO_STYLE,
                                                on_click=lambda e: limpar_filtros_vagas(
                                                    search_bar_title_field,
                                                    search_bar_city_field,
                                                    modelo_trabalho_text,
                                                    # salario_text,
                                                    dias_da_vaga_menu_text,
                                                    estado_text,
                                                ),
                                            ),
                                            col={"xs": 12, "md": 2},
                                            alignment=ft.alignment.center,
                                            margin=ft.margin.symmetric(horizontal=5),
                                        ),
                                    ],
                                    spacing=5,  # Reduz o espaçamento entre os elementos
                                    alignment=ft.MainAxisAlignment.CENTER,  # Centraliza os elementos no eixo principal
                                ),
                                padding=ft.padding.symmetric(vertical=5),  # Reduz o espaçamento vertical do container
                                alignment=ft.alignment.center,
                            ),

                            # Lista de vagas e descrição (já estavam boas)
                            ft.Container(
                                content=ft.ResponsiveRow(
                                    controls=[
                                        # Primeiro container (com banner + job_list_view)
                                        ft.Container(
                                            content=ft.Column(
                                                controls=[
                                                    # Row que contém o banner de cargo + quantidade de vagas
                                                    ft.Row(
                                                        controls=[
                                                            cargo_selecionado_text,
                                                            quantidade_vagas_text,
                                                        ],
                                                        alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
                                                    ),
                                                    ft.Divider(height=1),
                                                    # Aqui vem a lista de vagas
                                                    ft.Container(
                                                        content=job_list_view,
                                                        height=450,
                                                    ),
                                                ],
                                                spacing=10,
                                            ),
                                            col={"xs": 12, "md": 5},
                                        ),

                                        # Segundo container (somente job_description)
                                        ft.Container(
                                            content=job_description,
                                            col={"xs": 12, "md": 5},
                                            height=500,
                                        ),
                                    ],
                                    spacing=20,
                                    alignment=ft.MainAxisAlignment.CENTER,
                                ),
                                padding=ft.padding.symmetric(vertical=10),
                            ),
                        ],
                        spacing=20,
                        alignment=ft.MainAxisAlignment.CENTER,
                    ),
                    expand=True,
                    padding=ft.padding.symmetric(horizontal=30),
                    alignment=ft.alignment.center,
                ),
                create_footer(page),
            ],
        )
    
    def limpar_filtros_vagas(search_bar_title_field, search_bar_city_field, 
                         modelo_trabalho_text, dias_da_vaga_menu_text, estado_text):
        """
        Limpa os filtros e atualiza a lista de vagas.
        """
        global modelo_trabalho_selecionado_str, salario_selecionado_str, dias_selecionados_str, estado_selecionado_str

        # Resetando variáveis string
        modelo_trabalho_selecionado_str = "Todos"
        salario_selecionado_str = "Todos"
        dias_selecionados_str = "Todos"
        estado_selecionado_str = "Todos"  # Novo filtro para estado

        # Resetando campos de texto
        search_bar_title_field.value = ""
        search_bar_city_field.value = ""
        search_bar_title_field.update()
        search_bar_city_field.update()

        # Resetando o texto exibido nos botões
        modelo_trabalho_text.value = "Modelo"
        modelo_trabalho_text.update()

        # salario_text.value = "Faixa de Salário"
        # salario_text.update()

        dias_da_vaga_menu_text.value = "Publicação"
        dias_da_vaga_menu_text.update()

        estado_text.value = "Localização"  # Atualiza o texto do menu de estados
        estado_text.update()

        # Atualiza a listagem
        filter_jobs_vagas(search_bar_title_field, search_bar_city_field)

    # --- Politicas do Site ---
    def privacy_policy_view(page: ft.Page):
        """Página da Política de Privacidade."""

        # Carregar o texto da Política de Privacidade do arquivo
        privacy_text = carregar_texto(
            nome_arquivo='politica_privacidade.txt',
            texto_padrao="Texto da Política de Privacidade não disponível."
        )

        return ft.View(
            "/politica-de-privacidade",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),  # Certifique-se de que esta função está definida
                # Container principal com padding para margens laterais
                ft.Container(
                    padding=ft.padding.symmetric(horizontal=20, vertical=20),
                    alignment=ft.alignment.center,
                    content=ft.Column(
                        alignment=ft.MainAxisAlignment.START,
                        horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                        spacing=20,
                        controls=[
                            # Frase específica abaixo da logo
                            ft.Text(
                                "POLÍTICA DE PRIVACIDADE",
                                size=24,
                                weight=ft.FontWeight.BOLD,
                                text_align=ft.TextAlign.CENTER,
                            ),
                            # Container para o conteúdo da política com max_width
                            ft.Container(
                                content=ft.Text(
                                    privacy_text,
                                    size=16,
                                    text_align=ft.TextAlign.JUSTIFY,
                                ),
                                padding=10,
                                width=1000,  # Define a largura máxima do conteúdo
                            ),
                            # Botão para voltar
                            ft.ElevatedButton(
                                "Voltar",
                                style=BOTAO_STYLE,  # Certifique-se de que BOTAO_STYLE está definido
                                on_click=lambda e: page.go("/"),
                            ),
                        ],
                    ),
                ),
                create_footer(page),
            ],
        )
    def terms_of_service_view(page: ft.Page):
        """Página dos Termos de Uso."""
        
        # Carregar o texto dos Termos de Uso do arquivo
        terms_text = carregar_texto(
            nome_arquivo='termos_uso.txt',
            texto_padrao="Texto dos Termos de Uso não disponível."
        )
        
        return ft.View(
            "/termos-de-uso",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),
                # Container principal com padding para margens laterais
                ft.Container(
                    padding=ft.padding.symmetric(horizontal=20, vertical=20),
                    alignment=ft.alignment.center,
                    content=ft.Column(
                        alignment=ft.MainAxisAlignment.START,
                        horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                        spacing=20,
                        controls=[
                            # Frase específica abaixo da logo
                            ft.Text(
                                "TERMOS DE USO",
                                size=24,
                                weight=ft.FontWeight.BOLD,
                                text_align=ft.TextAlign.CENTER,
                            ),
                            # Container para o conteúdo dos termos com max_width
                            ft.Container(
                                content=ft.Text(
                                    terms_text,
                                    size=16,
                                    text_align=ft.TextAlign.JUSTIFY,
                                ),
                                padding=10,
                                width=1000,  # Define a largura máxima do conteúdo
                            ),
                            # Botão para voltar
                            ft.ElevatedButton(
                                "Voltar",
                                style=BOTAO_STYLE,  # Certifique-se de que BOTAO_STYLE está definido
                                on_click=lambda e: page.go("/"),
                            ),
                        ],
                    ),
                ),
                create_footer(page),
            ],
        )
    def cookie_policy_view(page: ft.Page):
        """Página da Política de Cookies e Ferramentas de Coleta Automática de Dados."""
        
        # Carregar o texto da Política de Cookies do arquivo
        cookies_text = carregar_texto(
            nome_arquivo='politica_cookies.txt',
            texto_padrao="Texto da Política de Cookies não disponível."
        )        
        return ft.View(
            "/politica-de-cookies",
            scroll=ft.ScrollMode.AUTO,
            controls=[
                create_header(page, user_logged_in),
                # Container principal com padding para margens laterais
                ft.Container(
                    padding=ft.padding.symmetric(horizontal=20, vertical=20),
                    alignment=ft.alignment.center,
                    content=ft.Column(
                        alignment=ft.MainAxisAlignment.START,
                        horizontal_alignment=ft.CrossAxisAlignment.CENTER,
                        spacing=20,
                        controls=[
                            # Frase específica abaixo da logo
                            ft.Text(
                                "POLÍTICA DE COOKIES E FERRAMENTAS DE COLETA AUTOMÁTICA DE DADOS",
                                size=24,
                                weight=ft.FontWeight.BOLD,
                                text_align=ft.TextAlign.CENTER,
                            ),
                            # Container para o conteúdo da política de cookies com max_width
                            ft.Container(
                                content=ft.Text(
                                    cookies_text,
                                    size=16,
                                    text_align=ft.TextAlign.JUSTIFY,
                                ),
                                padding=10,
                                width=1000,  # Define a largura máxima do conteúdo
                            ),
                            # Botão para voltar
                            ft.ElevatedButton(
                                "Voltar",
                                style=BOTAO_STYLE,
                                on_click=lambda e: page.go("/"),
                            ),
                        ],
                    ),
                ),
                create_footer(page),

            ],
        )

    # ---- Roteamento ----
    def route_change(route, page):
        page.views.clear()
        
        if "?" in route:
            route = route.split("?")[0]

        if route == "/":
            page.views.append(main_view(page))
        elif route == "/login":
            page.views.append(login_view(page))
        elif route == "/profile":
            page.views.append(profile_view(page))
        elif route == "/profile/edicao":
            page.views.append(alterar_profile_view(page))
        elif route == "/profile/alterar-senha":
            page.views.append(profile_alterar_senha(page))
        elif route == "/profile/foto":
            page.views.append(profile_foto_view(page))
        elif route == "/profile/google":
            page.views.append(profile_google_view(page))
        elif route == "/profile/finalizar-cadastro":
            page.views.append(profile_finalizar_cadastro(page))
        elif route == "/cadastro":
            page.views.append(cadastro_view(page))
        elif route == "/vagas":
            page.views.append(vagas_view(page))
        elif route.startswith("/vagas/"):
            slug = route.split("/vagas/")[-1]
            page.views.append(generate_job_page_by_slug(page, slug))
        elif route == "/nova-senha":
            page.views.append(nova_senha_view(page))
        elif route == "/nova-senha/codigo":
            page.views.append(nova_senha_codigo_view(page))
        elif route == "/nova-senha/cadastro":
            page.views.append(nova_senha_cadastro_view(page))
        elif route == "/politica-de-privacidade":
            page.views.append(privacy_policy_view(page))
        elif route == "/termos-de-uso":
            page.views.append(terms_of_service_view(page))
        elif route == "/politica-de-cookies":
            page.views.append(cookie_policy_view(page))
        else:
            page.views.append(ft.View("/", controls=[ft.Text("Página não encontrada!")]))
        
        page.update()

    page.on_route_change = lambda _: route_change(page.route, page)
    route_change(page.route, page)

if __name__=="__main__":
    ft.app(target=main ,view=ft.AppView.WEB_BROWSER, assets_dir="assets", upload_dir="assets/uploads", route_url_strategy="hash")

Error message

No response

------------------------------------------------------

• I have searched for answers to my question both in the issues and in previous discussions.