Demo first draft

.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+database/

__init__.py

@@ -0,0 +1,3 @@
+import os
+
+RESOURCE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "resources")

app.py

@@ -0,0 +1,822 @@
+import argparse
+import json
+import os
+import random
+from functools import partial
+
+import gradio as gr
+
+from app import RESOURCE_DIR
+from app.utils.poi_search_utils import (
+    clear_all_selections,
+    get_selection_summary,
+    pois_list,
+    search_pois,
+    toggle_poi_selection,
+)
+from app.utils.recommender_poi_utils import (
+    add_poi_to_completed,
+    back_to_recommendations,
+    get_recommendations_ui,
+    show_recommendation_list,
+    view_poi_details,
+)
+from app.utils.survey_utils import (
+    feedback_message,
+    handle_all_answered_responses,
+    handle_next_navigation,
+    handle_prev_navigation,
+    handle_submit_survey,
+    submit_exp_feedback,
+    submit_rec_feedback,
+    update_advanced_responses,
+)
+from app.utils.user_profile_utils import (
+    login_user,
+    mark_profile_complete,
+    update_user_selected_pois,
+    update_user_sensory_aversions
+)
+
+with open(os.path.join(RESOURCE_DIR, "aversion_config_questions.json"), "r") as f:
+    AVERSIONS_QUESTIONS = json.load(f)
+with open(os.path.join(RESOURCE_DIR, "aversions.json"), "r") as f:
+    AVERSIONS = json.load(f)
+AVERSIONS = {v["Name"]: v for v in AVERSIONS}
+
+
+feedback_message_delay = 1500
+js_feedback_message_delay = f"""() => {{
+    return new Promise(resolve => {{
+        setTimeout(() => {{
+            resolve();
+        }}, {feedback_message_delay});
+    }});
+}}"""
+
+
+def create_main_app(self):
+    with gr.Blocks(
+        title="Sistema di Raccomandazione di Punti di Interesse con Personalizzazione Sensoriale",
+        theme=gr.themes.Soft(),
+        css="""
+        footer{display:none !important}
+        .navigation-container {
+            background: #f8f9fa;
+            padding: 15px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+            border-left: 4px solid #007bff;
+        }
+        .page-container {
+            min-height: 500px;
+            padding: 20px;
+        }
+        .poi-card {
+            transition: all 0.3s ease;
+        }
+        .poi-card:hover {
+            transform: scale(1.02);
+            box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+        }
+        .search-container {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            padding: 30px;
+            border-radius: 15px;
+            color: white;
+            margin-bottom: 30px;
+        }
+        .continue-button {
+            background-color: #28a745 !important;
+            border-color: #28a745 !important;
+            font-size: 16px !important;
+            padding: 12px 24px !important;
+        }
+        .continue-button:hover {
+            background-color: #218838 !important;
+            border-color: #1e7e34 !important;
+        }
+        .clear-button {
+            background-color: #dc3545 !important;
+            border-color: #dc3545 !important;
+        }
+        .clear-button:hover {
+            background-color: #c82333 !important;
+            border-color: #bd2130 !important;
+        }
+        .sensory-config-main-container {
+            max-width: 900px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        .header-section {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 12px;
+            margin-bottom: 25px;
+            text-align: center;
+        }
+        .radio-aversion-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+            gap: 20px;
+            margin-bottom: 25px;
+        }
+        .radio-aversion-card {
+            background: #f8f9fa;
+            border: 1px solid #e9ecef;
+            border-radius: 12px;
+            padding: 15px;
+        }
+        .continue-to-recommendations-button {
+            background-color: #28a745 !important;
+            border-color: #28a745 !important;
+            font-size: 16px !important;
+            padding: 12px 30px !important;
+            width: 100% !important;
+        }
+        .continue-to-recommendations-button:hover {
+            background-color: #218838 !important;
+            border-color: #1e7e34 !important;
+        }
+        .feedback-indicator {
+            margin-top: 5px;
+        }
+        .back-button-custom {       
+            background-color: #32568f !important;
+            border-color: #32568f !important;
+            color: white !important;
+        }
+        .back-button-custom:hover {
+            background-color: #132137 !important;
+            border-color: #132137 !important;
+        }
+        .login-button {
+            background-color: #007bff !important;
+            border-color: #007bff !important;
+        }
+        .login-button:hover {
+            background-color: #0056b3 !important;
+            border-color: #004085 !important;
+        }
+        #poi-search-input {
+            color: black;
+        }
+        """,
+    ) as app:
+        # Stati globali dell'applicazione
+        app_user_id = gr.State("")
+        current_page = gr.State("login")  # "login", "poi_selection", "sensory_config", "recommendations"
+        selected_poi_names = gr.State(set())
+        recommendations_state = gr.State([])
+        selected_poi_index = gr.State(-1)
+        completed_survey_pois = gr.State(set())
+        current_poi_info = gr.State({})  # Store current POI info for survey
+        user_status = gr.State("")  # "new_user", "existing_incomplete", "existing_complete"
+
+        # Container per le diverse pagine
+        with gr.Column(elem_classes="page-container"):
+            # Pagina 1: Login/Profile
+            with gr.Column(visible=True) as login_page:
+                gr.Markdown("# 👤 Login / Registrazione")
+
+                # Interfaccia di login semplificata
+                with gr.Row():
+                    user_id_input = gr.Textbox(
+                        placeholder="es: mario_rossi, alice_123, user001...",
+                        label="🆔 Inserisci il tuo ID Utente",
+                        info="Scegli un ID univoco che userai per accedere al sistema",
+                        elem_id="user-id-input",
+                        scale=2
+                    )
+                    login_button = gr.Button(
+                        "🚀 Accedi / Registrati",
+                        variant="primary",
+                        elem_classes="action-button login-button",
+                    )
+
+                login_status_message = gr.Markdown("", visible=False)
+
+                with gr.Row(visible=False) as login_actions:
+                    start_setup_btn = gr.Button(
+                        "📝 Configura Profilo", variant="secondary"
+                    )
+                    go_to_recommendations_btn = gr.Button(
+                        "🎯 Vai alle Raccomandazioni", variant="primary"
+                    )
+
+            with gr.Column(visible=False) as poi_selection_page:
+                with gr.Column(elem_classes="search-container"):
+                    gr.Markdown("# 🔍 Cerca e seleziona i **Luoghi di Interesse** che preferisci cliccando sulla card corrispondente")
+                    gr.Markdown(
+                        "Esplora i luoghi disponibili e seleziona quelli che preferisci maggiormente. La ricerca è dinamica: inizia a digitare per filtrare i risultati."
+                    )
+
+                    # Search input (dynamic, no button needed)
+                    search_input = gr.Textbox(
+                        placeholder="Cerca per nome, descrizione o località...",
+                        label="",
+                        show_label=False,
+                        container=False,
+                        elem_id="poi-search-input",
+                    )
+
+                with gr.Column():
+                    # Selection summary
+                    selection_summary = gr.Markdown(get_selection_summary(set()))
+
+                    # Navigation buttons
+                    with gr.Row():
+                        clear_button = gr.Button(
+                            "🗑️ Cancella Selezioni",
+                            variant="secondary",
+                            elem_classes="clear-button",
+                            scale=1,
+                        )
+                        continue_to_sensory_btn = gr.Button(
+                            "Continua alla Configurazione Sensoriale ➡️",
+                            variant="primary",
+                            elem_classes="continue_to_sensory_btn",
+                            scale=3,
+                        )
+
+                    # POI display area
+                    poi_display = gr.HTML(
+                        value=search_pois("", set()), elem_id="poi-display-area"
+                    )
+
+                    # Create hidden buttons for each POI
+                    poi_buttons = {}
+                    for poi in pois_list:
+                        poi_name = poi["name"]
+                        safe_name = (
+                            poi_name.replace(" ", "-").replace("'", "").replace('"', "")
+                        )
+                        button = gr.Button(
+                            poi_name, visible=False, elem_id=f"poi-btn-{safe_name}"
+                        )
+                        poi_buttons[poi_name] = button
+
+            with gr.Column(
+                visible=False, elem_classes="sensory-config-main-container"
+            ) as sensory_config_page:
+                # Header compatto
+                gr.HTML("""
+                <div class="header-section">
+                    <h2 style="margin: 0 0 10px 0;">⚙️ Configura le tue Preferenze Sensoriali</h2>
+                    <p style="margin: 0; opacity: 0.9;">Indica il tuo livello di sensibilità per ogni caratteristica</p>
+                </div>
+                """)
+
+                aversion_radios = []
+                with gr.Column():
+                    for i, aversion_question in enumerate(AVERSIONS_QUESTIONS):
+                        question = aversion_question.get("question", "")
+                        aversion_name = aversion_question.get("aversion_name", "")
+                        aversion = AVERSIONS[aversion_name]
+
+                        with gr.Group(elem_classes="radio-aversion-card"):
+                            with gr.Column():
+                                # Titolo compatto con icona
+                                gr.HTML(f"""
+                                <div style="display: flex; align-items: center; margin-bottom: 8px;">
+                                    <span style="font-size: 20px; margin-right: 10px;">{aversion['Icon']} {aversion_name}</span>
+                                    <div>
+                                        <div style="font-size: 14px; color: #D7D7D7; margin-top: 2px;">{question}</div>
+                                    </div>
+                                </div>
+                                """)
+
+                                # Quanto ti dà fastidio questo fenomeno sensoriale?
+                                av_radio = gr.Radio(
+                                    choices=[("Nessuno", 1), ("Poco", 2), ("Moderato", 3), ("Molto", 4), ("Estremo", 5)],
+                                    value=3,
+                                    show_label=False,
+                                    interactive=True,
+                                    elem_id=f"radio-{aversion_name.lower().replace(' ', '-')}",
+                                )
+
+                            aversion_radios.append(av_radio)
+
+                # Pulsante continua
+                with gr.Row():
+                    continue_to_recommendations_button = gr.Button(
+                        "Continua alle Raccomandazioni →",
+                        variant="primary",
+                        elem_classes="continue-to-recommendations-button",
+                        size="lg",
+                    )
+
+            with gr.Column(visible=False) as recommendations_page:
+                with gr.Column(visible=True) as recommendations_list_page:
+                    gr.Markdown(
+                        "# Sistema di Raccomandazione di Punti di Interesse"
+                    )
+                    gr.Markdown("""
+                    Questo sistema raccomanda punti di interesse personalizzati per le preferenze sensoriali degli utenti.
+                    Ogni raccomandazione include informazioni sensoriali dettagliate e spiegazioni personalizzate.
+                    """)
+
+                    recommendation_list = gr.HTML(label="Raccomandazioni")
+
+                    with gr.Row(visible=False):
+                        select_buttons = [
+                            gr.Button(f"Select_{i}", elem_id=f"select-button-{i}")
+                            for i in range(args.top_k)
+                        ]
+
+                with gr.Column(visible=False) as details_page_block:
+                    gr.Markdown("# Dettagli POI")
+                    poi_details = gr.HTML(label="Dettagli Punto di Interesse")
+
+                with gr.Column(visible=False) as recommendation_feedback_block:
+                    gr.Markdown("## Ti è piaciuto questo luogo che ti abbiamo suggerito?")
+
+                    with gr.Row(equal_height=True):
+                        with gr.Column(scale=1):
+                            rec_like_btn = gr.Button("👍 Sì", size="lg")
+                        with gr.Column(scale=1):
+                            rec_dislike_btn = gr.Button("👎 No", size="lg")
+
+                    recommendation_feedback_result = gr.State(False)
+                    recommendation_feedback_submitted = gr.State(False)
+                    recommendation_feedback_message = gr.HTML(visible=False)
+
+                # SIMPLE SURVEY
+                with gr.Column(visible=False) as simple_survey_block:
+                    gr.Markdown("## Ti è stata utile questa spiegazione?")
+
+                    with gr.Row(equal_height=True):
+                        with gr.Column(scale=1):
+                            exp_like_btn = gr.Button("👍 Sì", size="lg")
+                        with gr.Column(scale=1):
+                            exp_dislike_btn = gr.Button("👎 No", size="lg")
+
+                    simple_survey_result = gr.State(False)
+                    simple_feedback_submitted = gr.State(False)
+                    simple_feedback_message = gr.HTML(visible=False)
+
+                # ADVANCED SURVEY
+                with gr.Column(visible=False) as advanced_survey_block:
+                    gr.Markdown("## Valuta questa spiegazione della raccomandazione")
+
+                    # Stato per tenere traccia del gruppo corrente
+                    advanced_current_group_idx = gr.State(0)
+
+                    # Carica i dati del questionario
+                    from app.utils.survey_utils import LIKERT_OPTIONS, SURVEY_STATEMENTS
+
+                    # Contenitori per i gruppi di affermazioni
+                    advanced_containers = []
+                    advanced_responses = [[], [], []]
+                    statements = SURVEY_STATEMENTS.copy()
+                    random.shuffle(statements)
+
+                    # Prendiamo il massimo di affermazioni per gruppo
+                    max_statements_per_group = 2  # Per i primi due gruppi
+                    for i in range(3):
+                        with gr.Column(visible=(i == 0)) as container:
+                            gr.Markdown(f"### Parte {i + 1} di 3")
+
+                            group_responses = []
+                            # Creiamo spazio per il massimo numero di affermazioni possibili
+                            for j in range(3 if i == 2 else max_statements_per_group):
+                                response = gr.Radio(
+                                    choices=LIKERT_OPTIONS,
+                                    label=statements[i * max_statements_per_group + j],
+                                    type="value",
+                                    value=None,
+                                )
+                                group_responses.append(response)
+
+                            advanced_responses[i] = group_responses
+                        advanced_containers.append(container)
+
+                    # Navigazione tra i gruppi
+                    with gr.Row():
+                        advanced_prev_btn = gr.Button("← Indietro", interactive=False)
+                        advanced_next_btn = gr.Button("Avanti →")
+                        advanced_submit_btn = gr.Button(
+                            "Conferma Risposte", visible=False
+                        )
+
+                    advanced_feedback_submitted = gr.State(False)
+                    advanced_feedback_message = gr.HTML(visible=False)
+
+                with gr.Column(visible=False) as back_to_recommendations_block:
+                    gr.HTML(
+                        '<hr style="margin: 80px 0 2px 0; border-top: 1px solid #ddd;">'
+                    )
+                    back_to_recommendations_button = gr.Button(
+                        "← Torna alla lista di raccomandazioni",
+                        variant="secondary",
+                        elem_classes="back-button-custom",
+                    )
+
+        def handle_login(user_id_value):
+            """Gestisce il processo di login"""
+            success, message, login_status = login_user(user_id_value)
+
+            if not success:
+                return (
+                    gr.update(value=message, visible=True),  # status_message
+                    gr.update(visible=False),  # login_actions
+                    gr.update(visible=False),  # setup_profile_button
+                    gr.update(visible=False),  # proceed_to_recommendations_button
+                    user_id_value,  # current_user_id
+                    login_status,  # login_status
+                )
+
+            # Determina quale pulsante mostrare
+            show_setup = login_status in ["new_user", "existing_incomplete"]
+            show_proceed = login_status == "existing_complete"
+
+            return (
+                gr.update(value=message, visible=True),  # status_message
+                gr.update(visible=True),  # login_actions
+                gr.update(visible=show_setup),  # setup_profile_button
+                gr.update(visible=show_proceed),  # proceed_to_recommendations_button
+                user_id_value,  # current_user_id
+                login_status,  # login_status
+            )
+
+        def handle_poi_click(poi_name, selected_names, query):
+            """Handle POI click - toggle selection"""
+            print(f"🔥 POI Button clicked: {poi_name}")
+            return toggle_poi_selection(poi_name, selected_names, query)
+        
+        def handle_proceed_to_sensory_config(user_id, selected_names):
+            """Handle proceeding to next step"""
+            if not selected_names:
+                gr.Warning("⚠️ Seleziona la card di almeno un Punto di Interesse per continuare!")
+                return
+
+            update_user_selected_pois(user_id, selected_names)
+            gr.Info(f"✅ Procedendo con {len(selected_names)} Punti di Interesse selezionati")
+            return navigate_to_sensory_config()
+
+        def navigate_to_poi_selection():
+            """Naviga alla selezione POI"""
+            return (
+                gr.update(visible=False),  # login_page
+                gr.update(visible=True),  # poi_selection_page
+                gr.update(visible=False),  # sensory_config_page
+                gr.update(visible=False),  # recommendations_page
+                "poi_selection",  # current_page
+            )
+
+        def navigate_to_sensory_config():
+            """Naviga alla configurazione sensoriale"""
+            return (
+                gr.update(visible=False),  # login_page
+                gr.update(visible=False),  # poi_selection_page
+                gr.update(visible=True),  # sensory_config_page
+                gr.update(visible=False),  # recommendations_page
+                "sensory_config",  # current_page
+            )
+
+        def navigate_to_recommendations():
+            """Naviga alle raccomandazioni"""
+            return (
+                gr.update(visible=False),  # login_page
+                gr.update(visible=False),  # poi_selection_page
+                gr.update(visible=False),  # sensory_config_page
+                gr.update(visible=True),  # recommendations_page
+                "recommendations",  # current_page
+            )
+
+        def complete_profile_setup(user_id):
+            """Completa la configurazione del profilo"""
+            if user_id:
+                mark_profile_complete(user_id)
+                gr.Info(f"✅ Profilo {user_id} completato con successo!")
+            return navigate_to_recommendations()
+
+        login_button.click(
+            fn=handle_login,
+            inputs=[user_id_input],
+            outputs=[
+                login_status_message,
+                login_actions,
+                start_setup_btn,
+                go_to_recommendations_btn,
+                app_user_id,
+                user_status,
+            ],
+        )
+        
+        start_setup_btn.click(
+            fn=navigate_to_poi_selection,
+            outputs=[
+                login_page,
+                poi_selection_page,
+                sensory_config_page,
+                recommendations_page,
+                current_page,
+            ],
+        )
+        
+        go_to_recommendations_btn.click(
+            fn=complete_profile_setup,
+            inputs=[app_user_id],
+            outputs=[
+                login_page,
+                poi_selection_page,
+                sensory_config_page,
+                recommendations_page,
+                current_page,
+            ],
+        ).then(
+            fn=partial(get_recommendations_ui, k=args.top_k),
+            inputs=[app_user_id],
+            outputs=[recommendations_state, app_user_id, recommendation_list],
+        )
+
+        # Dynamic search - triggers on every keystroke
+        search_input.change(
+            fn=search_pois,
+            inputs=[search_input, selected_poi_names],
+            outputs=[poi_display],
+        )
+
+        # Set up click handlers for each POI button
+        for poi_name, button in poi_buttons.items():
+            button.click(
+                fn=partial(handle_poi_click, poi_name),
+                inputs=[selected_poi_names, search_input],
+                outputs=[selected_poi_names, poi_display, selection_summary],
+            )
+
+        # Clear all selections
+        clear_button.click(
+            fn=clear_all_selections,
+            inputs=[search_input],
+            outputs=[selected_poi_names, poi_display, selection_summary],
+        )
+
+        continue_to_sensory_btn.click(
+            fn=handle_proceed_to_sensory_config,
+            inputs=[app_user_id, selected_poi_names],
+            outputs=[
+                login_page,
+                poi_selection_page,
+                sensory_config_page,
+                recommendations_page,
+                current_page,
+            ],
+        )
+
+        # Salva preferenze
+        continue_to_recommendations_button.click(
+            fn=update_user_sensory_aversions,
+            inputs=[app_user_id, *aversion_radios],
+        ).then(
+            fn=complete_profile_setup,
+            inputs=[app_user_id],
+            outputs=[
+                login_page,
+                poi_selection_page,
+                sensory_config_page,
+                recommendations_page,
+                current_page,
+            ],
+        ).then(
+            fn=partial(get_recommendations_ui, k=args.top_k),
+            inputs=[app_user_id],
+            outputs=[recommendations_state, app_user_id, recommendation_list],
+        )
+
+        for i, btn in enumerate(select_buttons):
+            btn.click(
+                fn=lambda current_idx=i: current_idx,
+                inputs=[],
+                outputs=[selected_poi_index],
+            ).then(
+                fn=view_poi_details,
+                inputs=[recommendations_state, app_user_id, selected_poi_index, completed_survey_pois],
+                outputs=[
+                    recommendations_list_page,
+                    details_page_block,
+                    poi_details,
+                    recommendation_feedback_block,
+                    back_to_recommendations_block,
+                    current_poi_info,
+                ],
+            )
+
+        surveys_objects = [
+            recommendation_feedback_result,
+            recommendation_feedback_submitted,
+            recommendation_feedback_message,
+            simple_survey_result,
+            simple_feedback_submitted,
+            simple_feedback_message,
+            advanced_current_group_idx,
+            advanced_feedback_submitted,
+            advanced_feedback_message,
+        ]
+
+        back_to_recommendations_button.click(
+            fn=lambda: back_to_recommendations(advanced_responses, advanced_containers),
+            inputs=[],
+            outputs=[
+                recommendations_list_page,
+                details_page_block,
+                poi_details,
+                recommendation_feedback_block,
+                simple_survey_block,
+                advanced_survey_block,
+                back_to_recommendations_block,
+                *surveys_objects,
+                *[radio for group in advanced_responses for radio in group],
+                *advanced_containers,
+            ],
+        ).then(
+            fn=show_recommendation_list,
+            inputs=[recommendations_state, completed_survey_pois],
+            outputs=[recommendation_list]
+        )
+
+        rec_like_btn.click(
+            fn=feedback_message,
+            inputs=[],
+            outputs=[
+                recommendation_feedback_message,
+            ],
+            show_progress="hidden",
+        ).then(
+            fn=lambda: submit_rec_feedback(True),
+            inputs=[],
+            outputs=[
+                recommendation_feedback_result,
+                recommendation_feedback_submitted,
+                recommendation_feedback_message,
+                simple_survey_block,
+                recommendation_feedback_block,
+            ],
+            js=js_feedback_message_delay,
+            show_progress="hidden",
+        )
+
+        rec_dislike_btn.click(
+            fn=feedback_message,
+            inputs=[],
+            outputs=[
+                recommendation_feedback_message,
+            ],
+            show_progress="hidden",
+        ).then(
+            fn=lambda: submit_rec_feedback(False),
+            inputs=[],
+            outputs=[
+                recommendation_feedback_result,
+                recommendation_feedback_submitted,
+                recommendation_feedback_message,
+                simple_survey_block,
+                recommendation_feedback_block,
+            ],
+            js=js_feedback_message_delay,
+            show_progress="hidden",
+        )
+
+        # Configurazione eventi per il questionario semplice
+        exp_like_btn.click(
+            fn=feedback_message,
+            inputs=[],
+            outputs=[
+                simple_feedback_message,
+            ],
+            show_progress="hidden",
+        ).then(
+            fn=lambda: submit_exp_feedback(True),
+            inputs=[],
+            outputs=[
+                simple_survey_result,
+                simple_feedback_submitted,
+                simple_feedback_message,
+                advanced_survey_block,
+                simple_survey_block,
+                advanced_prev_btn,
+                advanced_next_btn,
+                advanced_submit_btn,
+            ],
+            js=js_feedback_message_delay,
+            show_progress="hidden",
+        )
+
+        exp_dislike_btn.click(
+            fn=feedback_message,
+            inputs=[],
+            outputs=[
+                simple_feedback_message,
+            ],
+            show_progress="hidden",
+        ).then(
+            fn=lambda: submit_exp_feedback(False),
+            inputs=[],
+            outputs=[
+                simple_survey_result,
+                simple_feedback_submitted,
+                simple_feedback_message,
+                advanced_survey_block,
+                simple_survey_block,
+                advanced_prev_btn,
+                advanced_next_btn,
+                advanced_submit_btn,
+            ],
+            js=js_feedback_message_delay,
+            show_progress="hidden",
+        )
+
+        # Create a list of outputs for navigation functions
+        navigation_outputs = [
+            advanced_current_group_idx,  # next_group_idx
+            advanced_prev_btn,  # prev_btn interactivity update
+            advanced_next_btn,  # next_btn visibility update
+            advanced_submit_btn,  # submit_btn visibility update
+        ] + advanced_containers  # container updates
+
+        advanced_next_btn.click(
+            fn=partial(handle_next_navigation, advanced_responses, advanced_containers),
+            inputs=[advanced_current_group_idx],
+            outputs=navigation_outputs,
+        ).then(
+            fn=partial(handle_all_answered_responses, advanced_responses),
+            inputs=[advanced_current_group_idx],
+            outputs=[advanced_submit_btn, advanced_next_btn],
+        )
+
+        advanced_prev_btn.click(
+            fn=partial(handle_prev_navigation, advanced_containers),
+            inputs=[
+                advanced_current_group_idx,
+            ],
+            outputs=navigation_outputs,
+        )
+
+        for group_idx, radio_group in enumerate(advanced_responses):
+            for radio_idx, radio_button in enumerate(radio_group):
+                radio_button.change(
+                    fn=partial(
+                        update_advanced_responses,
+                        group_idx,
+                        radio_idx,
+                        advanced_responses,
+                    ),
+                    inputs=[radio_button],
+                    outputs=[],
+                ).then(
+                    fn=partial(handle_all_answered_responses, advanced_responses),
+                    inputs=[advanced_current_group_idx],
+                    outputs=[advanced_submit_btn, advanced_next_btn],
+                )
+
+        advanced_submit_btn.click(
+            fn=partial(
+                handle_submit_survey,
+                advanced_responses,
+            ),
+            inputs=[
+                app_user_id,
+                current_poi_info,
+                recommendation_feedback_result,
+                simple_survey_result,
+            ],
+            outputs=[
+                advanced_feedback_submitted,
+                advanced_feedback_message,
+                advanced_prev_btn,
+                advanced_next_btn,
+                advanced_submit_btn,
+                *advanced_containers,
+            ],
+        ).then(
+            fn=add_poi_to_completed,
+            inputs=[selected_poi_index, completed_survey_pois],
+            outputs=[completed_survey_pois],
+        )
+
+        return app
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run the POI Search UI")
+    parser.add_argument(
+        "user_type",
+        choices=["autistic", "neurotypical"],
+        help="Type of user for the interface",
+    )
+    parser.add_argument(
+        "--top-k",
+        type=int,
+        default=5,
+        help="Number of top recommendations to show",
+    )
+    parser.add_argument(
+        "--port", type=int, default=7860, help="Port to run the Gradio app on"
+    )
+    parser.add_argument("--share", action="store_true", help="Share the app publicly")
+    args = parser.parse_args()
+    app = create_main_app(args.user_type)
+    app.launch()

html_items.py

@@ -0,0 +1,226 @@
+import json
+import os
+
+from app import RESOURCE_DIR
+from app.utils.utils import get_aversion_color, get_qualitative_aversion
+
+with open(os.path.join(RESOURCE_DIR, "aversions.json"), "r") as f:
+    aversions_data = json.load(f)
+AVERSIONS = {item["Name"]: item for item in aversions_data}
+
+
+def create_poi_html(poi: dict, user_id: str) -> str:
+    """Create HTML representation of a POI with sensory features"""
+    html = f"""
+    <div style="border: 1px solid #ddd; padding: 15px; border-radius: 10px; margin-bottom: 20px;">
+        <div style="display: flex; flex-direction: row; gap: 20px;">
+            <div style="flex: 0 0 300px;">
+                <img src="{poi["image_url"]}" style="width: 100%; height: auto; border-radius: 8px; object-fit: cover;" alt="{poi["name"]}">
+            </div>
+            <div style="flex: 1;">
+                <h3 style="margin-top: 0;">{poi["name"]}</h3>
+                <p><strong>Descrizione:</strong> {poi["description"]}</p>
+                <p><strong>Luogo:</strong> {poi["location"]}</p>
+                
+                <div style="margin: 15px 0;">
+                    <h4>Caratteristiche Sensoriali:</h4>
+                    <table style="width: 100%; border-collapse: collapse;">
+                        <thead>
+                            <tr style="background-color: #4a4a4a; color: white;">
+                                <th style="text-align: left; padding: 8px; border: 1px solid #ddd; width: 35%;">Caratteristica</th>
+                                <th style="text-align: center; padding: 8px; border: 1px solid #ddd; width: 65%;">Livello (1-5)</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+    """
+
+    for feature, level in poi["sensory_features"].items():
+        icon = AVERSIONS[feature]["Icon"]
+        bar_color = get_aversion_color(level, AVERSIONS[feature]["Type"])
+        html += f"""
+                            <tr>
+                                <td style="text-align: left; padding: 8px; border: 1px solid #ddd;">
+                                    <div style="display: flex; align-items: center;">
+                                        <span style="font-size: 18px; margin-right: 8px;">{icon}</span>
+                                        {feature}
+                                    </div>
+                                </td>
+                                <td style="text-align: left; padding: 8px; border: 1px solid #ddd;">
+                                    <div style="position: relative; background-color: #f0f0f0; width: 100%; height: 24px; border-radius: 12px;">
+                                        <div style="position: absolute; background-color: {bar_color}; width: {level * 20}%; height: 100%; border-radius: 12px; display: flex; align-items: center;">
+                                            <span style="position: absolute; left: 50%; color: 'black'; font-weight: bold; text-shadow: 0px 0px 2px black;">{level}</span>
+                                        </div>
+                                        <div style="position: absolute; width: 100%; height: 100%; display: flex; justify-content: space-between; align-items: center; padding: 0 10px; box-sizing: border-box; pointer-events: none;">
+                                            <span style="font-size: 10px; opacity: 0.9; color: black">Basso</span>
+                                            <span style="font-size: 10px; opacity: 0.9; color: black">Alto</span>
+                                        </div>
+                                    </div>
+                                </td>
+                            </tr>
+    """
+    html += f"""        </tbody>
+                    </table>
+                    <div style="margin: 15px 0; padding: 10px; background-color: #3a3a3a; color: white; border-left: 5px solid #7FB77E; border-radius: 5px;" --explanation_type="{poi["explanation_type"]}">
+                        <h3>Spiegazione della raccomandazione: ti suggeriamo questo luogo perché ...</h3>
+                        <p>{poi["explanation"]}</p>
+                    </div>
+                </div>  
+            </div>
+        </div>
+    </div>
+    """
+
+    return html
+
+
+def create_recommendation_item(rec, index, selected=False) -> str:
+    """Create HTML for a single recommendation item"""
+    return f"""
+    <div onclick="document.getElementById('select-button-{index}').click();" 
+         style="display: flex; align-items: center; padding: 10px; margin-bottom: 10px; border: 1px solid #ddd; 
+                border-radius: 10px; cursor: pointer; transition: background-color 0.3s; background-color: {'#888888' if selected else 'transparent'};"
+         onmouseover="this.style.backgroundColor='{'#888888' if selected else '#393939'}';" 
+         onmouseout="this.style.backgroundColor='{'#888888' if selected else 'transparent'}';">
+        <div style="width: 80px; height: 80px; overflow: hidden; border-radius: 8px; margin-right: 15px;">
+            <img src="{rec["image_url"]}" style="width: 100%; height: 100%; object-fit: cover;" alt="{rec["name"]}">
+        </div>
+        <div>
+            <h3 style="margin: 0 0 5px 0;">{rec["name"]}</h3>
+            <p style="margin: 0 0 5px 0; font-size: 0.9em;">{rec["description"]}</p>
+        </div>
+        <div style="margin-left: 50px; font-size: 40px; color: white; font-weight: bold; z-index: 10; text-shadow: 0 0 4px white;">
+            {"✓" if selected else ""}
+        </div>
+    </div>
+    """
+
+
+def create_poi_card_selectable(poi: dict, is_selected: bool = False) -> str:
+    """Create HTML representation of a selectable POI card for search interface"""
+
+    # Enhanced visual feedback based on selection state
+    if is_selected:
+        border_color = "#30892F"
+        background_color = "#f0f8f0"  # Slightly darker green tint
+        tick_icon = "✓"
+        # Dark overlay for selected state
+        overlay_style = "background-color: rgba(0, 0, 0, 0.15);"
+        # Darker content background
+        content_bg = "#e8f5e8"
+        # Darker text colors for selected state
+        title_color = "#2c5530"
+        location_color = "#4a5c4d"
+        description_color = "#5a6b5d"
+    else:
+        border_color = "#ddd"
+        background_color = "white"
+        tick_icon = ""
+        overlay_style = ""
+        content_bg = "white"
+        title_color = "#333"
+        location_color = "#666"
+        description_color = "#777"
+
+    # Create compact sensory features display
+    sensory_html = ""
+    if poi.get("sensory_features"):
+        sensory_items = []
+        for feature, level in poi["sensory_features"].items():
+            icon = AVERSIONS[feature]["Icon"]
+            color = get_aversion_color(level, AVERSIONS[feature]["Type"])
+            qualitative_level = get_qualitative_aversion(
+                level, AVERSIONS[feature]["Type"]
+            )
+            qualitative_level = {"GOOD": "Basso", "ACCEPTABLE": "Medio", "BAD": "Alto"}[
+                qualitative_level
+            ]
+
+            sensory_items.append(
+                f'<span style="color: {color}; margin-right: 8px;" title="{feature}: {level}/5">{icon} {feature}: {qualitative_level}</span>'
+            )
+
+        sensory_html = f"""
+        <div style="margin: 8px 0; padding: 8px; background: white; border-radius: 6px; border-left: 3px solid #7FB77E;">
+            <div style="font-size: 12px; color: #666; margin-bottom: 4px;">Caratteristiche Sensoriali:</div>
+            <div style="font-size: 14px;"><ul><li>{"</li><li>".join(sensory_items)}</li></ul></div>
+        </div>
+        """
+
+    # Escape single quotes in POI name for JavaScript
+    poi_name_escaped = poi["name"].replace("'", "\\'")
+    
+    html = f"""
+    <div class="poi-card" data-poi-name="{poi["name"]}" 
+         style="border: 2px solid {border_color}; 
+                background-color: {background_color};
+                padding: 0; 
+                border-radius: 12px; 
+                margin-bottom: 20px; 
+                cursor: pointer;
+                transition: all 0.3s ease;
+                position: relative;
+                overflow: hidden;
+                box-shadow: 0 2px 8px rgba(0,0,0,0.1);"
+         onclick="document.getElementById('poi-btn-{poi_name_escaped.replace(" ", "-")}').click();"
+         onmouseover="this.style.transform='scale(1.02)'; this.style.boxShadow='0 4px 12px rgba(0,0,0,0.15)';" 
+         onmouseout="this.style.transform='scale(1)'; this.style.boxShadow='0 2px 8px rgba(0,0,0,0.1)';">
+        
+        <!-- Dark overlay for selected state -->
+        <div style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; z-index: 1; {overlay_style} pointer-events: none;"></div>
+        
+        <div style="position: absolute; top: 15px; right: 15px; font-size: 28px; color: #7FB77E; font-weight: bold; z-index: 10; text-shadow: 0 0 4px white;">
+            {tick_icon}
+        </div>
+        
+        <!-- Image filling horizontally -->
+        <div style="width: 100%; height: 200px; overflow: hidden; position: relative;">
+            <img src="{poi["image_url"]}" 
+                 style="width: 100%; height: 100%; object-fit: cover;" 
+                 alt="{poi["name"]}">
+        </div>
+        
+        <!-- Content below image -->
+        <div style="padding: 15px; background-color: {content_bg}; position: relative; z-index: 2;">
+            <h3 style="margin: 0 0 8px 0; color: {title_color}; font-size: 18px;">{poi["name"]}</h3>
+            <p style="margin: 0 0 8px 0; color: {location_color}; font-size: 14px; font-weight: 500;">
+                📍 {poi["location"]}
+            </p>
+            <p style="margin: 0 0 12px 0; color: {description_color}; font-size: 14px; line-height: 1.4;">
+                {poi["description"][:120]}{"..." if len(poi["description"]) > 120 else ""}
+            </p>
+            
+            {sensory_html}
+            
+            <div style="display: flex; justify-content: space-between; align-items: center; margin-top: 12px;">
+                <span style="display: inline-block; padding: 6px 12px; background-color: {"#d4edda" if is_selected else "#e8f4e8"}; color: {title_color}; border-radius: 20px; font-size: 12px; font-weight: bold;">
+                    {("✓ Selezionato" if is_selected else "Clicca per selezionare")}
+                </span>
+            </div>
+        </div>
+    </div>
+    """
+
+    return html
+
+
+def create_poi_cards_list(pois: list, selected_names: set) -> str:
+    if not pois:
+        return "<div style='text-align:center; color:#666; margin: 40px; padding: 40px; background: #f8f9fa; border-radius: 12px;'><h3>🔍 Nessun punto di interesse trovato</h3><p>Prova con termini di ricerca diversi</p></div>"
+
+    # Genera HTML per i POI filtrati
+    poi_cards_html = []
+    for poi in pois:
+        is_selected = poi.get("name") in selected_names
+        card_html = create_poi_card_selectable(poi, is_selected)
+        poi_cards_html.append(card_html)
+
+    html = f"""
+    <div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(320px, 1fr)); gap: 20px; margin: 20px 0;">
+        {"".join(poi_cards_html)}
+    </div>
+    <div style='text-align: center; color: black; margin-top: 20px; padding: 15px; background: #f0f0f0; border-radius: 8px;'>
+        <strong style='color: black;'>Trovati {len(pois)} punti di interesse</strong> • <span style='color: #7FB77E;'>{len(selected_names)} selezionati</span>
+    </div>
+    """
+
+    return html

resources/_defaults.json

@@ -0,0 +1,7 @@
+{
+    "aversion_levels_colors": {
+        "BAD": "#f9cecc",
+        "ACCEPTABLE": "#ffe6cd",
+        "GOOD": "#d5e9d1"
+    }
+}

resources/aversion_config_questions.json

@@ -0,0 +1,30 @@
+[
+    {
+        "question": "Da 1 a 5, quanto ti dà fastidio in un luogo che ci sia tanto rumore?",
+        "aversion_name": "Livello di Rumore"
+    },
+    {
+        "question": "Da 1 a 5, quanto ti dà fastidio in un luogo che ci siano odori forti?",
+        "aversion_name": "Stimolazione Olfattiva"
+    },
+    {
+        "question": "Da 1 a 5, quanto ti dà fastidio in un luogo che ci sia tanta gente?",
+        "aversion_name": "Densità di Persone"
+    },
+    {
+        "question": "Da 1 a 5, quanto ti dà fastidio in un luogo avere poca luce?",
+        "aversion_name": "Intensità Luminosa"
+    },
+    {
+        "question": "Da 1 a 5, quanto ti dà fastidio in un luogo avere molta luce?",
+        "aversion_name": "Intensità Luminosa"
+    },
+    {
+        "question": "Da 1 a 5, quanto ti dà fastidio che in un luogo ci siano spazi stretti?",
+        "aversion_name": "Dimensione degli Spazi"
+    },
+    {
+        "question": "Da 1 a 5, quanto ti dà fastidio che in un luogo ci siano spazi ampi?",
+        "aversion_name": "Dimensione degli Spazi"
+    }
+]

resources/aversions.json

@@ -0,0 +1,32 @@
+[
+    {
+        "Name": "Livello di Rumore",
+        "Type": "HIGH",
+        "Description": "Luoghi con rumore elevato possono essere fastidiosi per chi ha sensibilità uditive.",
+        "Icon": "🔊"
+    },
+    {
+        "Name": "Stimolazione Olfattiva",
+        "Type": "HIGH",
+        "Description": "Luoghi con forti odori possono risultare sgradevoli per chi ha sensibilità olfattive.",
+        "Icon": "👃"
+    },
+    {
+        "Name": "Densità di Persone",
+        "Type": "HIGH",
+        "Description": "Luoghi affollati possono causare disagio a chi è sensibile alla sovrapposizione di stimoli.",
+        "Icon": "👥"
+    },
+    {
+        "Name": "Intensità Luminosa",
+        "Type": "LOW-HIGH",
+        "Description": "L'illuminazione intensa o limitata può essere fastidiosa e causare disagio.",
+        "Icon": "💡"
+    },
+    {
+        "Name": "Dimensione degli Spazi",
+        "Type": "LOW-HIGH",
+        "Description": "Spazi ristretti o spazi ampi possono far sentire a disagio.",
+        "Icon": "🏛️"
+    }
+]

resources/explanation_types.json

@@ -0,0 +1,18 @@
+[
+    {
+        "type": 2,
+        "template": "Ti suggeriamo questo luogo perchè ti è piaciuto un altro luogo con caratteristiche sensoriali simili."
+    },
+    {
+        "type": 4,
+        "template": "Ti suggeriamo questo luogo perché è piaciuto ad una persona che ha i tuoi stessi gusti."
+    },
+    {
+        "type": 6,
+        "template": "Ti suggeriamo questo luogo perché ha caratteristiche sensoriali che non ti danno fastidio."
+    },
+    {
+        "type": 7,
+        "template": "Ti suggeriamo questo luogo perché è piaciuto ad una persona a cui, come te, danno fastidio le stesse caratteristiche sensoriali."
+    }
+]

resources/mock_data.json

@@ -0,0 +1,130 @@
+[
+  {
+    "name": "Mole Antonelliana",
+    "image_url": "https://images.unsplash.com/photo-1578072445064-bd0b3f83b847?q=80&w=1000",
+    "description": "Un simbolo iconico di Torino, con un museo del cinema e una vista panoramica sulla città.",
+    "location": "Via Montebello, 20, Torino",
+    "coordinates": "45.070, 7.686",
+    "sensory_features": {
+      "Livello di Rumore": 3,
+      "Stimolazione Olfattiva": 5,
+      "Densità di Persone": 4,
+      "Intensità Luminosa": 4,
+      "Dimensione degli Spazi": 5
+    },
+    "explanation": "Ti suggeriamo questo luogo perché è piaciuto ad una persona che ha i tuoi stessi gusti. Questo luogo ha un'alta stimolazione olfattiva e luminosa, con una densità di persone moderata. La struttura è ben definita, ma potrebbe risultare un po' caotica per chi cerca tranquillità.",
+    "explanation_type": 4
+  },
+  {
+    "name": "Parco del Valentino",
+    "image_url": "https://plus.unsplash.com/premium_photo-1733436277181-a19049e64753?q=80&w=1000",
+    "description": "Un grande parco urbano con sentieri lungo il fiume Po e un castello medievale.",
+    "location": "Corso Massimo d'Azeglio, Torino",
+    "coordinates": "45.054, 7.694",
+    "sensory_features": {
+      "Livello di Rumore": 3,
+      "Stimolazione Olfattiva": 3,
+      "Densità di Persone": 2,
+      "Intensità Luminosa": 4,
+      "Dimensione degli Spazi": 3
+    },
+    "explanation": "Ti suggeriamo questo luogo perchè ti è piaciuto un altro luogo con caratteristiche sensoriali simili. Questo parco offre un ambiente con un livello moderato di stimolazione sensoriale e sentieri ben definiti che permettono di esplorare liberamente.",
+    "explanation_type": 2
+  },
+  {
+    "name": "La Teiera Caffè Eccentrico",
+    "image_url": "https://images.unsplash.com/photo-1550305080-4e029753abcf?q=80&w=1000",
+    "description": "Un accogliente caffè con sale tranquille separate e spazi adatti a persone con sensibilità sensoriali.",
+    "location": "Via Bertola, 29, Torino",
+    "coordinates": "45.071, 7.675",
+    "sensory_features": {
+      "Livello di Rumore": 2,
+      "Stimolazione Olfattiva": 2,
+      "Densità di Persone": 2,
+      "Intensità Luminosa": 2,
+      "Dimensione degli Spazi": 4
+    },
+    "explanation": "Ti suggeriamo questo luogo perché ha caratteristiche sensoriali che non ti danno fastidio. Il layout prevedibile e la bassa stimolazione sensoriale (tutte le caratteristiche sono valutate 2/5 tranne la struttura) creano un ambiente confortevole per te.",
+    "explanation_type": 6
+  },
+  {
+    "name": "Libreria di Lucia",
+    "image_url": "https://images.unsplash.com/photo-1552566626-52f8b828add9?q=80&w=1000",
+    "description": "Una libreria indipendente con angoli lettura e orari dedicati alla tranquillità.",
+    "location": "Via Po, 18, Torino",
+    "coordinates": "45.067, 7.693",
+    "sensory_features": {
+      "Livello di Rumore": 1,
+      "Stimolazione Olfattiva": 3,
+      "Densità di Persone": 2,
+      "Intensità Luminosa": 3,
+      "Dimensione degli Spazi": 4
+    },
+    "explanation": "Ti suggeriamo questo luogo perché è piaciuto ad una persona a cui, come te, danno fastidio le stesse caratteristiche sensoriali. Questa libreria offre un ambiente prevedibile e silenzioso (1/5) con una stimolazione olfattiva moderata, ideale per chi cerca spazi tranquilli.",
+    "explanation_type": 7
+  },
+  {
+    "name": "Orto Botanico",
+    "image_url": "https://www.guidatorino.com/wp-content/uploads/2020/05/orto-botanico-torino-3.jpg",
+    "description": "Un giardino tranquillo con percorsi ben segnalati e una sezione di piante sensoriali.",
+    "location": "Viale Mattioli, 25, Torino",
+    "coordinates": "45.063, 7.688",
+    "sensory_features": {
+      "Livello di Rumore": 1,
+      "Stimolazione Olfattiva": 4,
+      "Densità di Persone": 1,
+      "Intensità Luminosa": 4,
+      "Dimensione degli Spazi": 5
+    },
+    "explanation": "Ti suggeriamo questo luogo perché ha caratteristiche sensoriali che non ti danno fastidio. Questo giardino ha una densità di persone molto bassa (1/5) e un livello di rumore minimo (1/5). L'alta strutturazione (5/5) offre una navigazione chiara, anche se presenta una ricca stimolazione olfattiva e luminosa.",
+    "explanation_type": 6
+  },
+  {
+    "name": "Orto Botanico 2",
+    "image_url": "https://www.guidatorino.com/wp-content/uploads/2020/05/orto-botanico-torino-3.jpg",
+    "description": "Un giardino tranquillo con percorsi ben segnalati e una sezione di piante sensoriali.",
+    "location": "Viale Mattioli, 25, Torino",
+    "coordinates": "45.063, 7.688",
+    "sensory_features": {
+      "Livello di Rumore": 1,
+      "Stimolazione Olfattiva": 4,
+      "Densità di Persone": 1,
+      "Intensità Luminosa": 4,
+      "Dimensione degli Spazi": 5
+    },
+    "explanation": "Ti suggeriamo questo luogo perché ha caratteristiche sensoriali che non ti danno fastidio. Questo giardino ha una densità di persone molto bassa (1/5) e un livello di rumore minimo (1/5). L'alta strutturazione (5/5) offre una navigazione chiara, anche se presenta una ricca stimolazione olfattiva e luminosa.",
+    "explanation_type": 6
+  },
+  {
+    "name": "Orto Botanico 3",
+    "image_url": "https://www.guidatorino.com/wp-content/uploads/2020/05/orto-botanico-torino-3.jpg",
+    "description": "Un giardino tranquillo con percorsi ben segnalati e una sezione di piante sensoriali.",
+    "location": "Viale Mattioli, 25, Torino",
+    "coordinates": "45.063, 7.688",
+    "sensory_features": {
+      "Livello di Rumore": 1,
+      "Stimolazione Olfattiva": 4,
+      "Densità di Persone": 1,
+      "Intensità Luminosa": 4,
+      "Dimensione degli Spazi": 5
+    },
+    "explanation": "Ti suggeriamo questo luogo perché ha caratteristiche sensoriali che non ti danno fastidio. Questo giardino ha una densità di persone molto bassa (1/5) e un livello di rumore minimo (1/5). L'alta strutturazione (5/5) offre una navigazione chiara, anche se presenta una ricca stimolazione olfattiva e luminosa.",
+    "explanation_type": 6
+  },
+  {
+    "name": "Orto Botanico 4",
+    "image_url": "https://www.guidatorino.com/wp-content/uploads/2020/05/orto-botanico-torino-3.jpg",
+    "description": "Un giardino tranquillo con percorsi ben segnalati e una sezione di piante sensoriali.",
+    "location": "Viale Mattioli, 25, Torino",
+    "coordinates": "45.063, 7.688",
+    "sensory_features": {
+      "Livello di Rumore": 1,
+      "Stimolazione Olfattiva": 4,
+      "Densità di Persone": 1,
+      "Intensità Luminosa": 4,
+      "Dimensione degli Spazi": 5
+    },
+    "explanation": "Ti suggeriamo questo luogo perché ha caratteristiche sensoriali che non ti danno fastidio. Questo giardino ha una densità di persone molto bassa (1/5) e un livello di rumore minimo (1/5). L'alta strutturazione (5/5) offre una navigazione chiara, anche se presenta una ricca stimolazione olfattiva e luminosa.",
+    "explanation_type": 6
+  }
+]

resources/survey_statements.json

@@ -0,0 +1,18 @@
+{
+  "statements": [
+    "Mi ha aiutato a capire se mi piacerà quel posto.",
+    "Mi ha fatto decidere più velocemente se mi piace quel posto.",
+    "Mi ha fatto venire voglia di andare lì.",
+    "Mi è piaciuto come scelgono il posto da consigliare.",
+    "Mi ha fatto capire se i suggerimenti rispecchiano i miei gusti.",
+    "Mi ha fatto capire perché mi consigliano quel posto.",
+    "Mi ha fatto fidare del suggerimento."
+  ],
+  "likert_options": [
+    "In disaccordo",
+    "Parzialmente in disaccordo",
+    "Neutrale",
+    "Parzialmente d'accordo",
+    "D'accordo"
+  ]
+}

utils/poi_search_utils.py

@@ -0,0 +1,81 @@
+import datetime
+import json
+import os
+
+from app import RESOURCE_DIR
+from app.html_items import create_poi_cards_list
+
+# Carica i dati dei POI
+with open(os.path.join(RESOURCE_DIR, "mock_data.json"), "r") as f:
+    LOADED_MOCK_POIS = json.load(f)
+pois_list = LOADED_MOCK_POIS
+
+
+def search_pois(search_query: str, selected_names: set) -> str:
+    """Cerca POI basandosi sulla query di ricerca e restituisce HTML"""
+
+    # Filtra i POI basandosi sulla query
+    filtered_pois = []
+    if search_query is None or not search_query.strip():
+        # Se non c'è query, mostra tutti i POI
+        filtered_pois = pois_list
+    else:
+        query_lower = search_query.lower()
+        for poi in pois_list:
+            # Cerca nel nome e indirizzo
+            if (
+                query_lower in poi.get("name", "").lower()
+                or
+                # query_lower in poi.get("description", "").lower() or
+                query_lower in poi.get("location", "").lower()
+            ):
+                filtered_pois.append(poi)
+
+    return create_poi_cards_list(filtered_pois, selected_names)
+
+
+def toggle_poi_selection(
+    poi_name: str, selected_names: set, current_query: str
+) -> tuple[set, str, str]:
+    """Alterna la selezione di un POI e aggiorna il display"""
+
+    # Copia il set per evitare modifiche dirette
+    new_selected = selected_names.copy()
+
+    print(f"DEBUG: Toggling POI '{poi_name}'")
+    print(f"DEBUG: Current selected: {selected_names}")
+
+    if poi_name in new_selected:
+        new_selected.remove(poi_name)
+        print(f"DEBUG: Removed '{poi_name}' from selection")
+    else:
+        new_selected.add(poi_name)
+        print(f"DEBUG: Added '{poi_name}' to selection")
+
+    print(f"DEBUG: New selected: {new_selected}")
+
+    # Rigenera l'HTML con lo stato aggiornato
+    updated_html = search_pois(current_query, new_selected)
+    summary = get_selection_summary(new_selected)
+
+    print(f"DEBUG: Generated HTML length: {len(updated_html)}")
+    print(f"DEBUG: Summary: {summary}")
+
+    return new_selected, updated_html, summary
+
+
+def get_selection_summary(selected_names: set) -> str:
+    """Restituisce un riassunto dei POI selezionati"""
+    if not selected_names:
+        return "**Punti di Interesse selezionati: 0** - Seleziona i luoghi di tuo interesse cliccando sulle card"
+
+    names_list = list(selected_names)
+    return f"**Punti di Interesse selezionati: {len(selected_names)}** => {' - '.join(names_list[:3])}{' e altri...' if len(selected_names) > 3 else ''}"
+
+
+def clear_all_selections(current_query: str) -> tuple[set, str, str]:
+    """Cancella tutte le selezioni"""
+    empty_set = set()
+    updated_html = search_pois(current_query, empty_set)
+    summary = get_selection_summary(empty_set)
+    return empty_set, updated_html, summary

utils/recommender_poi_utils.py

@@ -0,0 +1,146 @@
+from functools import lru_cache
+import json
+import os
+import random
+
+import gradio as gr
+from app.html_items import create_poi_html, create_recommendation_item
+
+from app import RESOURCE_DIR
+from app.utils.survey_utils import reset_surveys
+
+# Carica i dati mock dei POI
+with open(os.path.join(RESOURCE_DIR, "mock_data.json"), "r") as f:
+    LOADED_MOCK_POIS = json.load(f)
+
+
+@lru_cache(maxsize=512)
+def get_recommendations(user_id: str, k: int = 10) -> list[dict]:
+    """Function to get recommendations from external system"""
+    raise NotImplementedError("This function should be implemented to fetch recommendations from an external system.")
+    recommendations = bla_bla
+    random.shuffle(recommendations)
+
+    return recommendations[:k]
+
+
+def display_recommendations(user_id: str, k: int = 10) -> list[dict]:
+    """Get recommendations for a user"""
+    try:
+        recommendations = get_recommendations(user_id, k=k)
+    except Exception as e:
+        print(f"Errore durante il recupero delle raccomandazioni: {str(e)}")
+        if not LOADED_MOCK_POIS:
+            recommendations = []
+        else:
+            available_pois = [poi.copy() for poi in LOADED_MOCK_POIS]
+            random.shuffle(available_pois)
+            recommendations = available_pois[:k]
+
+    for rec in recommendations:
+        if rec.get("image_url") is None:
+            rec["image_url"] = (
+                "https://developers.elementor.com/docs/assets/img/elementor-placeholder-image.png"  # Default placeholder
+            )
+    
+    return recommendations
+
+
+def get_recommendations_ui(user_id: str, k: int = 10, completed_pois: set = None) -> tuple[list[dict], str, str]:
+    recs = display_recommendations(user_id, k=k)
+    if not recs:
+        return (
+            [],
+            user_id,
+            "<p style='text-align:center; color:grey;'>Impossibile ottenere raccomandazioni per questo utente.</p>",
+        )
+    
+    if completed_pois is None:
+        completed_pois = set()
+
+    html_content = show_recommendation_list(recs, completed_pois=completed_pois)
+    return recs, user_id, html_content
+
+
+def show_recommendation_list(recommendations, completed_pois: set = None) -> str:
+    """Create a simple list of recommendations that users can click on"""
+    html = "<div>"
+
+    for i, rec in enumerate(recommendations):
+        print(f"DEBUG: Creating recommendation item {i} with POI name '{rec.get('name')}' and it {'is' if i in completed_pois else 'is not'} completed.")
+        html += create_recommendation_item(rec, i, selected=i in completed_pois)
+
+    html += "</div>"
+    return html
+
+
+def add_poi_to_completed(selected_poi_index, completed_set):
+    """Add current POI to the set of completed survey POIs"""
+    if selected_poi_index not in completed_set:
+        new_completed = completed_set.copy()
+        new_completed.add(selected_poi_index)
+        print(f"DEBUG: Added POI index {selected_poi_index} to completed set.")
+        return new_completed
+    return completed_set
+
+
+def view_poi_details(
+    recs: list[dict], user_id: str, poi_idx: int, completed_pois: set = None
+) -> tuple[gr.update, gr.update, gr.update, gr.update, gr.update, dict]:
+    if not recs or poi_idx < 0 or poi_idx >= len(recs):
+        return (
+            gr.update(visible=False),  # home_page_block
+            gr.update(visible=True),  # details_page_block
+            gr.update(
+                value="<p style='color:red;'>Errore: Punto di Interesse non trovato o raccomandazioni non caricate.</p>"
+            ),  # poi_details
+            gr.update(visible=False),  # simple_survey_block
+            gr.update(visible=False),  # advanced_survey_block
+            {},  # current_poi_info
+        )
+
+    poi = recs[poi_idx]
+    if poi.get("name") in completed_pois:
+        return
+
+    html = create_poi_html(poi, user_id)
+
+    # Ottieni il tipo di spiegazione dal POI
+    explanation_type = poi.get("explanation_type", 0)
+
+    # Salva le informazioni del POI corrente per il questionario
+    poi_info = {
+        "id": poi.get("id"),
+        "name": poi.get("name"),
+        "category": poi.get("category"),
+        "explanation_type": explanation_type,
+        "explanation": poi.get("explanation"),
+    }
+
+    return (
+        gr.update(visible=False),  # home_page_block
+        gr.update(visible=True),  # details_page_block
+        gr.update(value=html),  # poi_details
+        gr.update(visible=True),  # recommendation_feedback_block
+        gr.update(visible=True),  # back_to_recommendations_block
+        poi_info,  # current_poi_info
+    )
+
+
+def back_to_recommendations(
+    advanced_responses, advanced_containers
+) -> tuple[gr.update, gr.update, gr.update, gr.update, gr.update]:
+    survey_updates = reset_surveys(advanced_responses, advanced_containers)
+
+    return (
+        gr.update(visible=True),  # home_page_block
+        gr.update(visible=False),  # details_page_block
+        gr.update(
+            value="<p style='text-align:center; color:grey; margin-top: 20px;'>Seleziona un Punto di Interesse per vedere i dettagli.</p>"
+        ),  # poi_details
+        gr.update(visible=False),  # recommmendation_feedback_block
+        gr.update(visible=False),  # simple_survey_block
+        gr.update(visible=False),  # advanced_survey_block
+        gr.update(visible=False),  # back_to_recommendations_block
+        *survey_updates,
+    )

utils/sensory_config_utils.py

@@ -0,0 +1,80 @@
+import json
+import os
+
+from app import RESOURCE_DIR
+from app.utils import get_aversion_color, get_qualitative_aversion
+
+
+with open(os.path.join(RESOURCE_DIR, "aversion_config_questions.json"), "r") as f:
+    AVERSIONS_QUESTIONS = json.load(f)
+with open(os.path.join(RESOURCE_DIR, "aversions.json"), "r") as f:
+    AVERSIONS = json.load(f)
+AVERSIONS = {v["Name"]: v for v in AVERSIONS}
+
+
+def get_feedback_html(value: int, aversion_type: str) -> str:
+    """Genera HTML per il feedback colorato"""
+    color = get_aversion_color(value, aversion_type)
+    feedback = get_qualitative_aversion(value, aversion_type)
+
+    # Semplifica il feedback text
+    if feedback == "GOOD":
+        text = "✓ Ottimo"
+        bg_color = "#d4edda"
+    elif feedback == "ACCEPTABLE":
+        text = "⚠ Moderato"
+        bg_color = "#fff3cd"
+    else:
+        text = "⚡ Elevato"
+        bg_color = "#f8d7da"
+
+    return f"""
+    <div style="
+        background-color: {bg_color}; 
+        color: {color}; 
+        padding: 6px 12px; 
+        border-radius: 15px; 
+        text-align: center; 
+        font-weight: bold; 
+        font-size: 13px;
+        border: 1px solid {color}20;
+        margin-top: 5px;
+    ">
+        {text}
+    </div>
+    """
+
+
+# Funzioni per gestire gli eventi
+def extract_sensory_preferences(radio_values: list) -> dict:
+    """Estrae le preferenze sensoriali"""
+    preferences = {}
+    preferences["question_answers"] = []
+    print("TODO: Bisogna trasformare la risposta in un valore compatibile per le raccomandazioni come nei dati")
+    for question, value in zip(AVERSIONS_QUESTIONS, radio_values):
+        question_text = question["question"]
+        aversion_name = question["aversion_name"]
+        aversion = AVERSIONS.get(aversion_name, {})
+        preferences["question_answers"].append({
+            "question": question_text,
+            "answer": value,
+            "aversion_name": aversion_name,
+            "type": aversion.get("Type", ""),
+        })
+
+        # TODO: Bisogna trasformare la risposta in un valore compatibile per le raccomandazioni come nei dati
+        preferences[aversion_name] = {
+            "value": value,
+            "type": aversion.get("Type", ""),
+            "description": aversion.get("Description", ""),
+        }
+
+    return preferences
+
+
+def get_slider_values(aversion_sliders: dict) -> dict:
+    """Ottiene i valori correnti degli slider"""
+    values = {}
+    for name, slider in aversion_sliders.items():
+        values[name] = slider.value if hasattr(slider, "value") else 3
+    return values

utils/survey_utils.py

@@ -0,0 +1,260 @@
+import datetime
+import json
+import os
+
+import gradio as gr
+
+from app import RESOURCE_DIR
+
+# Carica le affermazioni per il questionario avanzato
+with open(os.path.join(RESOURCE_DIR, "survey_statements.json"), "r") as f:
+    survey_data = json.load(f)
+SURVEY_STATEMENTS = survey_data.get("statements", [])
+LIKERT_OPTIONS = survey_data.get("likert_options", [])
+
+
+def feedback_message():
+    return gr.update(
+        visible=True,
+        value="""
+        <div style="
+            background-color: #30892F; 
+            color: white; 
+            padding: 15px 20px; 
+            border-radius: 10px; 
+            text-align: center; 
+            width: 100%; 
+            box-sizing: border-box;
+            font-weight: 500;
+            margin: 10px 0;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            border: 1px solid #c3e6ba;
+        ">
+            ✅ Grazie per il tuo feedback!
+        </div>
+        """,
+    )
+
+
+def submit_simple_feedback(choice: bool) -> tuple:
+    """Registra un feedback semplice"""
+    return (
+        choice,
+        True,
+        gr.update(visible=False),
+        gr.update(visible=True),
+        gr.update(visible=False),
+    )
+
+
+def submit_rec_feedback(choice: bool) -> tuple:
+    """Registra il feedback semplice sulla raccomandazione"""
+    return submit_simple_feedback(choice)
+
+def submit_exp_feedback(choice: bool) -> tuple:
+    """Registra il feedback semplice sull'utilità della spiegazione"""
+    return (
+        *submit_simple_feedback(choice),
+        gr.update(visible=True, interactive=False),
+        gr.update(visible=True, interactive=True),
+        gr.update(visible=False),
+    )
+
+
+# Configurazione eventi per il questionario avanzato
+def handle_next_navigation(advanced_responses, advanced_containers, current_group_idx):
+    # Controlla che l'indice sia valido
+    if current_group_idx < 0 or current_group_idx >= len(advanced_responses):
+        print(
+            f"Errore: current_group_idx={current_group_idx} fuori range, max={len(advanced_responses) - 1}"
+        )
+        # Ritorna valori di default per evitare errori
+        empty_updates = [gr.update() for _ in range(len(advanced_containers))]
+        return (
+            0,
+            gr.update(interactive=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            *empty_updates,
+        )
+
+    next_group_idx = current_group_idx + 1
+
+    # Naviga al prossimo gruppo se possibile
+    container_updates = []
+    if current_group_idx < len(advanced_containers) - 1:
+        # Prepara gli aggiornamenti per i container
+        for i in range(len(advanced_containers)):
+            container_updates.append(gr.update(visible=(i == next_group_idx)))
+
+        ready_to_submit = next_group_idx == len(advanced_containers) - 1
+
+        return (
+            next_group_idx,
+            gr.update(interactive=True),
+            gr.update(visible=not ready_to_submit),
+            gr.update(visible=ready_to_submit, interactive=False),
+            *container_updates,
+        )
+
+
+def handle_prev_navigation(advanced_containers, current_group_idx):
+    # Controlla che l'indice sia valido
+    if current_group_idx <= 0:
+        return (
+            0,
+            gr.update(interactive=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            *[gr.update() for _ in range(len(advanced_containers))],
+        )
+
+    # Torna al gruppo precedente
+    prev_group_idx = current_group_idx - 1
+
+    # Prepara gli aggiornamenti per i container
+    container_updates = []
+    for i in range(len(advanced_containers)):
+        container_updates.append(gr.update(visible=(i == prev_group_idx)))
+
+    # Ritorna il nuovo indice, le risposte aggiornate e gli aggiornamenti dei pulsanti
+    return (
+        prev_group_idx,
+        gr.update(interactive=(prev_group_idx > 0)),
+        gr.update(interactive=True, visible=True),
+        gr.update(visible=False),
+        *container_updates,
+    )
+
+
+def update_advanced_responses(
+    current_group_idx, current_radio_idx, advanced_responses, radio_value
+):
+    advanced_responses[current_group_idx][current_radio_idx].value = radio_value
+
+
+def handle_all_answered_responses(advanced_responses, current_group_idx):
+    all_response_values = [resp.value for group in advanced_responses for resp in group]
+
+    all_answered = all(resp is not None for resp in all_response_values)
+    submit_visible = current_group_idx == len(advanced_responses) - 1
+
+    return (
+        gr.update(visible=submit_visible, interactive=all_answered),  # submit button
+        gr.update(visible=not submit_visible),  # next button
+    )
+
+
+def handle_submit_survey(
+    advanced_responses,
+    current_user_id,
+    current_poi_info,
+    recommendation_feedback,
+    simple_survey_feedback,
+):
+    survey_data = {
+        "user_id": current_user_id,
+        "poi_info": current_poi_info,
+        "recommendation_like": recommendation_feedback,
+        "explanation_useful": simple_survey_feedback,
+        "advanced_survey_feedback": {},
+    }
+    for resp in [resp for group in advanced_responses for resp in group]:
+        survey_data["advanced_survey_feedback"][resp.label] = resp.value
+
+    save_survey_response(survey_data)
+
+    return (
+        True,
+        gr.update(
+            visible=True,
+            value="""
+            <div style="
+                background-color: #30892F; 
+                color: white; 
+                padding: 15px 20px; 
+                border-radius: 10px; 
+                text-align: center; 
+                width: 100%; 
+                box-sizing: border-box;
+                font-weight: 500;
+                margin: 10px 0;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                border: 1px solid #c3e6ba;
+            ">
+                ✅ Grazie per aver completato il questionario!
+            </div>
+            """,
+        ),
+        gr.update(visible=False),  # prev button
+        gr.update(visible=False),  # next button
+        gr.update(visible=False),  # submit button
+        *[
+            gr.update(visible=False) for _ in range(len(advanced_responses))
+        ],  # hide all containers
+    )
+
+
+def save_survey_response(survey_data):
+    """Salva le risposte del questionario in un file JSON singolo per utente."""
+    # Crea directory se non esiste
+    survey_dir = os.path.join(RESOURCE_DIR, os.pardir, "database", "survey_responses")
+    os.makedirs(survey_dir, exist_ok=True)
+
+    # Nome file basato su user_id
+    user_id = survey_data.get("user_id", "anonymous")
+    filename = os.path.join(survey_dir, f"user_{user_id}_surveys.json")
+
+    # Prepara i dati della nuova risposta
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    survey_data["timestamp"] = timestamp
+
+    # Carica risposte esistenti o crea lista vuota
+    surveys = []
+    if os.path.exists(filename):
+        try:
+            with open(filename, "r", encoding="utf-8") as f:
+                surveys = json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            surveys = []
+
+    # Aggiungi la nuova risposta
+    surveys.append(survey_data)
+
+    # Ordina per timestamp (più recente per primo)
+    surveys.sort(key=lambda x: x["timestamp"], reverse=True)
+
+    # Salva il file aggiornato
+    with open(filename, "w", encoding="utf-8") as f:
+        json.dump(surveys, f, indent=2, ensure_ascii=False)
+
+    return filename
+
+
+def reset_surveys(advanced_responses, advanced_containers):
+    """Resetta lo stato dei questionari"""
+    reset_radio_buttons = []
+    for group_radios in advanced_responses:
+        for radio_button in group_radios:
+            reset_radio_buttons.append(
+                gr.Radio(
+                    label=radio_button.label,
+                    choices=radio_button.choices,
+                    value=None,  # Reset the value
+                    visible=True,  # Ensure visibility is reset
+                )
+            )
+
+    return (
+        False,
+        False,
+        "",
+        False,
+        False,
+        "",
+        0,
+        False,
+        "",
+        *reset_radio_buttons,
+        *[gr.update(visible=i == 0) for i in range(len(advanced_containers))],
+    )

utils/user_profile_utils.py

@@ -0,0 +1,158 @@
+import datetime
+import json
+import os
+from typing import Optional
+
+from app import RESOURCE_DIR
+from app.utils.sensory_config_utils import extract_sensory_preferences
+
+USER_PROFILES_FILE = os.path.join(RESOURCE_DIR, os.pardir, "database", "user_profiles.json")
+os.makedirs(os.path.dirname(USER_PROFILES_FILE), exist_ok=True)
+
+
+def load_user_profiles():
+    """Carica i profili utente dal file JSON"""
+    if os.path.exists(USER_PROFILES_FILE):
+        with open(USER_PROFILES_FILE, "r", encoding="utf-8") as f:
+            profiles = json.load(f)
+        return {profile["user_id"]: profile for profile in profiles}
+    return {}
+
+
+def save_user_profiles(profiles):
+    """Salva i profili utente nel file JSON"""
+    with open(USER_PROFILES_FILE, "w", encoding="utf-8") as f:
+        json.dump(list(profiles.values()), f, indent=2, ensure_ascii=False)
+
+
+def get_user_profile(user_id):
+    """Ottiene il profilo di un utente specifico"""
+    profiles = load_user_profiles()
+    return profiles.get(
+        user_id,
+        {
+            "user_metadata": {"created_at": None, "last_updated": None},
+            "selected_pois": [],
+            "sensory_aversions": {},
+        },
+    )
+
+
+def update_user_selected_pois(user_id, selected_pois):
+    """Aggiorna i POI selezionati per un utente"""
+    profiles = load_user_profiles()
+    current_time = datetime.datetime.now().isoformat()
+
+    if user_id not in profiles:
+        profiles[user_id] = {
+            "user_metadata": {
+                "created_at": current_time,
+                "last_updated": current_time,
+                "profile_complete": False,
+            },
+            "selected_pois": [],
+            "sensory_aversions": {},
+        }
+
+    profiles[user_id]["selected_pois"] = list(selected_pois)
+    profiles[user_id]["user_metadata"]["last_updated"] = current_time
+
+    save_user_profiles(profiles)
+
+
+def update_user_sensory_aversions(user_id, *radio_values):
+    """Aggiorna le aversioni sensoriali per un utente"""
+    profiles = load_user_profiles()
+    current_time = datetime.datetime.now().isoformat()
+    sensory_aversions = extract_sensory_preferences(radio_values)
+
+    if user_id not in profiles:
+        profiles[user_id] = {
+            "user_metadata": {
+                "created_at": current_time,
+                "last_updated": current_time,
+                "profile_complete": False,
+            },
+            "selected_pois": [],
+            "sensory_aversions": {},
+        }
+
+    profiles[user_id]["sensory_aversions"] = sensory_aversions
+    profiles[user_id]["user_metadata"]["last_updated"] = current_time
+
+    save_user_profiles(profiles)
+
+
+def mark_profile_complete(user_id):
+    """Marca il profilo di un utente come completo"""
+    profiles = load_user_profiles()
+    current_time = datetime.datetime.now().isoformat()
+
+    if user_id in profiles:
+        profiles[user_id]["user_metadata"]["profile_complete"] = True
+        profiles[user_id]["user_metadata"]["last_updated"] = current_time
+        save_user_profiles(profiles)
+        return profiles[user_id]
+
+    return None
+
+
+def create_new_user_profile(user_id: str) -> dict:
+    """Crea un nuovo profilo utente"""
+    current_time = datetime.datetime.now().isoformat()
+    return {
+        "user_id": user_id.strip(),
+        "user_metadata": {
+            "created_at": current_time,
+            "last_updated": current_time,
+            "profile_complete": False,
+        },
+        "selected_pois": [],
+        "sensory_aversions": {},
+    }
+
+
+def check_user_exists(user_id: str) -> tuple[bool, Optional[dict]]:
+    """Controlla se un utente esiste e restituisce il suo profilo"""
+    if not user_id or not user_id.strip():
+        return False, None
+
+    profiles = load_user_profiles()
+    user_profile = profiles.get(user_id.strip())
+
+    if user_profile:
+        return True, user_profile
+    else:
+        return False, None
+
+
+def login_user(user_id: str) -> tuple[bool, str, str, dict]:
+    """Gestisce il login dell'utente"""
+    if not user_id or not user_id.strip():
+        return False, "⚠️ Inserisci un ID utente valido", "", {}
+
+    user_id = user_id.strip()
+    user_exists, user_profile = check_user_exists(user_id)
+
+    if user_exists:
+        profile_complete = user_profile.get("user_metadata", {}).get(
+            "profile_complete", False
+        )
+        last_updated = user_profile.get("user_metadata", {}).get("last_updated", "N/A")
+
+        if profile_complete:
+            message = f"✅ Benvenuto/a {user_id}! Profilo completo trovato. Reindirizzamento al sistema di raccomandazione..."
+            return True, message, "existing_complete"
+        else:
+            message = f"📝 Utente {user_id} trovato ma profilo incompleto. Completare preferenze e aversioni sensoriali..."
+            return True, message, "existing_incomplete"
+    else:
+        message = f"🆕 Nuovo utente {user_id}. Creazione profilo in corso..."
+        new_profile = create_new_user_profile(user_id)
+
+        # Salva il nuovo profilo
+        profiles = load_user_profiles()
+        profiles[user_id] = new_profile
+        save_user_profiles(profiles)
+
+        return True, message, "new_user"

utils/utils.py

@@ -0,0 +1,59 @@
+import json
+import os
+
+from app import RESOURCE_DIR
+
+with open(os.path.join(RESOURCE_DIR, "_defaults.json"), "r") as f:
+    _defaults = json.load(f)
+
+
+def get_qualitative_aversion(level: float, aversion_type: str) -> str:
+    if aversion_type == "HIGH":
+        if level <= 2:
+            return "GOOD"
+        elif level <= 3:
+            return "ACCEPTABLE"
+        else:
+            return "BAD"
+    elif aversion_type == "LOW-HIGH":
+        if level <= 1 or level >= 5:
+            return "BAD"
+        elif level <= 2 or level >= 4:
+            return "ACCEPTABLE"
+        else:
+            return "GOOD"
+    else:
+        raise ValueError(f"Unknown aversion type: {aversion_type}")
+
+
+def get_aversion_color(value: float, aversion_type: str) -> str:
+    return _defaults["aversion_levels_colors"][
+        get_qualitative_aversion(value, aversion_type)
+    ]
+
+
+def get_aversion_feedback(value: float, aversion_type: str) -> str:
+    aversion_quality = _defaults["aversion_levels_colors"][
+        get_qualitative_aversion(value, aversion_type)
+    ]
+    if aversion_quality == "GOOD":
+        return "✓ Livello di avversione basso - Buono"
+    elif aversion_quality == "ACCEPTABLE":
+        return "⚠ Livello di avversione moderato - Attenzione"
+    elif aversion_quality == "BAD":
+        return "✗ Livello di avversione alto - Evitare"
+    else:
+        return "Livello di avversione registrato"
+
+
+def get_qualitative_compatibility(level: float) -> str:
+    if level >= 85:
+        return "GOOD"
+    elif level >= 70:
+        return "ACCEPTABLE"
+    else:
+        return "BAD"
+
+
+def get_compatibility_color(level: float) -> str:
+    return _defaults["aversion_levels_colors"][get_qualitative_compatibility(level)]