vr-app/unity-overlay/Assets/Scripts/Net/ContentService.cs

using System;
using System.Threading.Tasks;
using UnityEngine;

namespace MyInfoMate.Vr.Net
{
    /// <summary>
    /// Le contenu d'un lieu, servi <b>cache d'abord</b> — item <b>E4</b> du lot XR-4.
    ///
    /// Deux chemins, jamais mélangés :
    /// <list type="bullet">
    ///   <item><b>Au démarrage</b> — le cache s'il existe, affiché tout de suite ;
    ///         le réseau seulement s'il n'y a rien en cache.</item>
    ///   <item><b>Ensuite</b> — un rafraîchissement en tâche de fond, dont l'échec est
    ///         silencieux : une borne hors ligne affiche son contenu de la veille, et
    ///         ce n'est pas une erreur à montrer au visiteur.</item>
    /// </list>
    ///
    /// C'est aussi ce qui rendra la reprise après coupure gratuite : au redémarrage, le
    /// cache est déjà là.
    /// </summary>
    public class ContentService
    {
        readonly ApiClient _client;
        readonly string _configurationId;

        /// <summary>
        /// Ce casque. Il désigne le lien application/configuration côté serveur, donc
        /// l'agencement qui lui est propre : ordre des sections, tailles de panneaux et
        /// sections masquées pour le canal VR seulement. Sans lui, l'export rend la
        /// configuration nue, telle que la voient le mobile et le web.
        /// </summary>
        readonly string _deviceId;

        public ContentService(ApiClient client, string configurationId, string deviceId = null)
        {
            _client = client;
            _configurationId = configurationId;
            _deviceId = deviceId;
        }

        public class Loaded
        {
            public ConfigurationExport Export;

            /// <summary>Vrai si le contenu vient du disque et non du serveur.</summary>
            public bool FromCache;

            /// <summary>Date du cache servi, pour l'afficher en mode dégradé.</summary>
            public DateTime? CachedAt;

            public string Error;

            public bool Ok => Error == null;
        }

        public async Task<Loaded> LoadAsync()
        {
            var cached = ContentCache.ReadExport(_configurationId);

            if (cached != null)
            {
                var parsed = ConfigurationExport.Parse(cached);
                if (parsed.Ok)
                    return new Loaded
                    {
                        Export = parsed.Value,
                        FromCache = true,
                        CachedAt = ContentCache.ExportDate(_configurationId)
                    };

                // Un cache illisible est un cache mort : on ne le garde pas pour
                // rejouer le même échec au prochain démarrage.
                Debug.LogWarning("[Content] Cache illisible, il est écarté.");
            }

            return await FetchAsync();
        }

        string ExportPath => string.IsNullOrEmpty(_deviceId)
            ? $"/api/configuration/{_configurationId}/export"
            : $"/api/configuration/{_configurationId}/export?deviceId={_deviceId}";

        /// <summary>
        /// Rafraîchit le cache sans bloquer l'affichage. Renvoie le contenu neuf, ou null
        /// si rien n'a changé ou si le serveur n'a pas répondu — dans les deux cas
        /// l'appelant garde ce qu'il montre.
        /// </summary>
        public async Task<ConfigurationExport> RefreshAsync()
        {
            var before = ContentCache.ReadExport(_configurationId);
            var raw = await _client.GetRawAsync(ExportPath);

            if (!raw.Ok)
            {
                Debug.Log($"[Content] Rafraîchissement impossible ({raw.Error}) — " +
                          "le contenu en cache reste affiché.");
                return null;
            }

            if (raw.Value == before) return null;

            var parsed = ConfigurationExport.Parse(raw.Value);
            if (!parsed.Ok) return null;

            ContentCache.WriteExport(_configurationId, raw.Value);
            return parsed.Value;
        }

        async Task<Loaded> FetchAsync()
        {
            var raw = await _client.GetRawAsync(ExportPath);

            if (!raw.Ok) return new Loaded { Error = raw.Error };

            var parsed = ConfigurationExport.Parse(raw.Value);
            if (!parsed.Ok) return new Loaded { Error = parsed.Error };

            ContentCache.WriteExport(_configurationId, raw.Value);
            return new Loaded { Export = parsed.Value };
        }
    }
}