using System;
using System.Diagnostics;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace JobTrackerApi.Services
{
    public sealed record AiServiceMetrics(
        bool Healthy,
        string? Model,
        string? Device,
        bool? GpuAvailable,
        string? GpuName,
        bool? OcrAvailable,
        string? OcrLanguages,
        bool? OllamaConfigured,
        bool? OllamaReachable,
        string? OllamaModel,
        bool? OllamaModelAvailable,
        string? OllamaVersion,
        IReadOnlyList<string>? OllamaInstalledModels,
        IReadOnlyList<string>? OllamaLoadedModels,
        int? OllamaLoadedCount,
        double? HealthLatencyMs,
        double? ProbeLatencyMs,
        DateTimeOffset? LastProbeAt,
        DateTimeOffset? LastProbeSuccessAt,
        DateTimeOffset? LastProbeFailureAt,
        int ProbeFailures,
        int Requests,
        int CacheHits,
        int CacheMisses,
        int Failures,
        double? AverageLatencyMs,
        int OcrRequests,
        int OcrFailures,
        double? AverageOcrLatencyMs,
        DateTimeOffset? LastOcrSuccessAt,
        DateTimeOffset? LastOcrFailureAt,
        DateTimeOffset? LastSuccessAt,
        DateTimeOffset? LastFailureAt,
        string? LastError
    );

    public sealed record AiTextExtractionResult(
        string? Text,
        bool OcrUsed,
        string? ContentType,
        int? PageCount,
        int Characters,
        string? FileName
    );

    public interface IAiService
    {
        Task<string?> SummarizeAsync(string text, int maxLength = 150, int minLength = 30);
        Task<string?> SummarizeSectionAsync(string instruction, string text, int maxLength = 180, int minLength = 40);
        Task<AiTextExtractionResult?> ExtractTextAsync(Stream stream, string fileName, string? contentType = null, CancellationToken cancellationToken = default);
        Task RunProbeAsync(CancellationToken cancellationToken = default);
        Task<AiServiceMetrics> GetMetricsAsync(CancellationToken cancellationToken = default);
    }

    public interface ISummarizerService : IAiService
    {
        new Task<string?> SummarizeSectionAsync(string instruction, string text, int maxLength = 180, int minLength = 40);
    }

    public class SummarizerService : ISummarizerService
    {
        private const int AiSummarizeMaxInputChars = 20000;
        private const int AiServiceMaxSummaryLength = 256;
        private const int AiServiceMaxMinLength = 180;
        private const int AiServiceMinSummaryLength = 24;
        private const int AiServiceMinMinLength = 8;
        private readonly IHttpClientFactory _httpFactory;
        private readonly IMemoryCache _cache;
        private readonly object _metricsLock = new();
        private int _requests;
        private int _cacheHits;
        private int _cacheMisses;
        private int _failures;
        private long _totalLatencyTicks;
        private DateTimeOffset? _lastSuccessAt;
        private DateTimeOffset? _lastFailureAt;
        private double? _lastProbeLatencyMs;
        private DateTimeOffset? _lastProbeAt;
        private DateTimeOffset? _lastProbeSuccessAt;
        private DateTimeOffset? _lastProbeFailureAt;
        private int _probeFailures;
        private int _ocrRequests;
        private int _ocrFailures;
        private long _totalOcrLatencyTicks;
        private DateTimeOffset? _lastOcrSuccessAt;
        private DateTimeOffset? _lastOcrFailureAt;
        private string? _lastError;

        public SummarizerService(IHttpClientFactory httpFactory, IMemoryCache cache)
        {
            _httpFactory = httpFactory;
            _cache = cache;
        }

        private static string BuildCacheKey(string text, int maxLength, int minLength)
        {
            var payload = $"{text}\n::{maxLength}:{minLength}";
            var hash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(payload))).ToLowerInvariant();
            return $"summ:{hash}";
        }


        private static async Task<string> ReadErrorBodyAsync(HttpResponseMessage response, CancellationToken cancellationToken = default)
        {
            var body = await response.Content.ReadAsStringAsync(cancellationToken);
            if (string.IsNullOrWhiteSpace(body))
            {
                return $"HTTP {(int)response.StatusCode}";
            }

            try
            {
                using var doc = JsonDocument.Parse(body);
                if (doc.RootElement.TryGetProperty("detail", out var detailEl) && detailEl.ValueKind == JsonValueKind.String)
                {
                    return $"HTTP {(int)response.StatusCode}: {detailEl.GetString()}";
                }
                if (doc.RootElement.TryGetProperty("message", out var messageEl) && messageEl.ValueKind == JsonValueKind.String)
                {
                    return $"HTTP {(int)response.StatusCode}: {messageEl.GetString()}";
                }
            }
            catch (JsonException)
            {
            }

            body = body.Length <= 400 ? body : body[..400];
            return $"HTTP {(int)response.StatusCode}: {body}";
        }

        public async Task<string?> SummarizeAsync(string text, int maxLength = 150, int minLength = 30)
        {
            if (string.IsNullOrWhiteSpace(text)) return null;
            return await SummarizeCoreAsync(text, maxLength, minLength);
        }

        public Task<string?> SummarizeSectionAsync(string instruction, string text, int maxLength = 180, int minLength = 40)
        {
            if (string.IsNullOrWhiteSpace(instruction) || string.IsNullOrWhiteSpace(text)) return Task.FromResult<string?>(null);
            return RewriteCoreAsync(instruction.Trim(), text.Trim(), maxLength, minLength);
        }

        private static string ComposeBoundedPrompt(string instruction, string text)
        {
            var prefix = $"{instruction}\n\n";
            if (prefix.Length >= AiSummarizeMaxInputChars)
            {
                return prefix[..AiSummarizeMaxInputChars];
            }

            var remaining = AiSummarizeMaxInputChars - prefix.Length;
            if (text.Length <= remaining)
            {
                return prefix + text;
            }

            return prefix + text[..remaining];
        }

        private async Task<string?> RewriteCoreAsync(string instruction, string text, int maxLength, int minLength)
        {
            var normalizedMaxLength = Math.Clamp(maxLength, AiServiceMinSummaryLength, AiServiceMaxSummaryLength);
            var normalizedMinLength = Math.Clamp(minLength, AiServiceMinMinLength, AiServiceMaxMinLength);
            if (normalizedMinLength >= normalizedMaxLength)
            {
                normalizedMinLength = Math.Max(AiServiceMinMinLength, normalizedMaxLength - 1);
            }

            var composed = ComposeBoundedPrompt(instruction, text);
            var key = BuildCacheKey($"rewrite::{composed}", normalizedMaxLength, normalizedMinLength);
            Interlocked.Increment(ref _requests);

            if (_cache.TryGetValue<string>(key, out var cached))
            {
                Interlocked.Increment(ref _cacheHits);
                lock (_metricsLock)
                {
                    _lastSuccessAt = DateTimeOffset.UtcNow;
                    _lastError = null;
                }
                return cached;
            }

            Interlocked.Increment(ref _cacheMisses);

            var client = _httpFactory.CreateClient("ai-service");
            var payload = JsonSerializer.Serialize(new
            {
                instruction,
                text,
                max_length = normalizedMaxLength,
                min_length = normalizedMinLength,
            });
            using var content = new StringContent(payload, Encoding.UTF8, "application/json");
            var sw = Stopwatch.StartNew();

            try
            {
                var res = await client.PostAsync("/cv/rewrite", content);
                sw.Stop();
                Interlocked.Add(ref _totalLatencyTicks, sw.ElapsedTicks);
                if (!res.IsSuccessStatusCode)
                {
                    var errorBody = await ReadErrorBodyAsync(res);
                    Interlocked.Increment(ref _failures);
                    lock (_metricsLock)
                    {
                        _lastFailureAt = DateTimeOffset.UtcNow;
                        _lastError = $"AI rewrite failed: {errorBody}";
                    }
                    return null;
                }

                using var stream = await res.Content.ReadAsStreamAsync();
                using var doc = await JsonDocument.ParseAsync(stream);
                if (doc.RootElement.TryGetProperty("rewritten_text", out var el))
                {
                    var s = el.GetString();
                    if (!string.IsNullOrWhiteSpace(s)) _cache.Set(key, s, TimeSpan.FromHours(6));
                    lock (_metricsLock)
                    {
                        _lastSuccessAt = DateTimeOffset.UtcNow;
                        _lastError = null;
                    }
                    return s;
                }

                lock (_metricsLock)
                {
                    _lastFailureAt = DateTimeOffset.UtcNow;
                    _lastError = "AI rewrite failed: response did not contain rewritten_text.";
                }
                return null;
            }
            catch (Exception ex)
            {
                sw.Stop();
                Interlocked.Add(ref _totalLatencyTicks, sw.ElapsedTicks);
                Interlocked.Increment(ref _failures);
                lock (_metricsLock)
                {
                    _lastFailureAt = DateTimeOffset.UtcNow;
                    _lastError = ex.Message;
                }
                return null;
            }
        }

        private async Task<string?> SummarizeCoreAsync(string text, int maxLength, int minLength)
        {
            var normalizedMaxLength = Math.Clamp(maxLength, AiServiceMinSummaryLength, AiServiceMaxSummaryLength);
            var normalizedMinLength = Math.Clamp(minLength, AiServiceMinMinLength, AiServiceMaxMinLength);
            if (normalizedMinLength >= normalizedMaxLength)
            {
                normalizedMinLength = Math.Max(AiServiceMinMinLength, normalizedMaxLength - 1);
            }

            var key = BuildCacheKey(text, normalizedMaxLength, normalizedMinLength);
            Interlocked.Increment(ref _requests);

            if (_cache.TryGetValue<string>(key, out var cached))
            {
                Interlocked.Increment(ref _cacheHits);
                lock (_metricsLock)
                {
                    _lastSuccessAt = DateTimeOffset.UtcNow;
                    _lastError = null;
                }
                return cached;
            }

            Interlocked.Increment(ref _cacheMisses);

            var client = _httpFactory.CreateClient("ai-service");
            var payload = JsonSerializer.Serialize(new { text, max_length = normalizedMaxLength, min_length = normalizedMinLength });
            using var content = new StringContent(payload, Encoding.UTF8, "application/json");
            var sw = Stopwatch.StartNew();

            try
            {
                var res = await client.PostAsync("/summarize", content);
                sw.Stop();
                Interlocked.Add(ref _totalLatencyTicks, sw.ElapsedTicks);
                if (!res.IsSuccessStatusCode)
                {
                    var errorBody = await ReadErrorBodyAsync(res);
                    Interlocked.Increment(ref _failures);
                    lock (_metricsLock)
                    {
                        _lastFailureAt = DateTimeOffset.UtcNow;
                        _lastError = $"AI summarize failed: {errorBody}";
                    }
                    return null;
                }

                using var stream = await res.Content.ReadAsStreamAsync();
                using var doc = await JsonDocument.ParseAsync(stream);
                if (doc.RootElement.TryGetProperty("summary", out var el))
                {
                    var s = el.GetString();
                    if (!string.IsNullOrWhiteSpace(s)) _cache.Set(key, s, TimeSpan.FromHours(6));
                    lock (_metricsLock)
                    {
                        _lastSuccessAt = DateTimeOffset.UtcNow;
                        _lastError = null;
                    }
                    return s;
                }

                return null;
            }
            catch (Exception ex)
            {
                sw.Stop();
                Interlocked.Add(ref _totalLatencyTicks, sw.ElapsedTicks);
                Interlocked.Increment(ref _failures);
                lock (_metricsLock)
                {
                    _lastFailureAt = DateTimeOffset.UtcNow;
                    _lastError = ex.Message;
                }
                return null;
            }
        }

        public async Task<AiTextExtractionResult?> ExtractTextAsync(Stream stream, string fileName, string? contentType = null, CancellationToken cancellationToken = default)
        {
            ArgumentNullException.ThrowIfNull(stream);
            if (string.IsNullOrWhiteSpace(fileName)) fileName = "document";

            Interlocked.Increment(ref _ocrRequests);
            var client = _httpFactory.CreateClient("ai-service");
            var sw = Stopwatch.StartNew();

            try
            {
                using var form = new MultipartFormDataContent();
                using var fileContent = new StreamContent(stream);
                if (!string.IsNullOrWhiteSpace(contentType))
                {
                    fileContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(contentType);
                }
                form.Add(fileContent, "file", fileName);

                using var response = await client.PostAsync("/extract-text", form, cancellationToken);
                sw.Stop();
                Interlocked.Add(ref _totalOcrLatencyTicks, sw.ElapsedTicks);
                if (!response.IsSuccessStatusCode)
                {
                    var errorBody = await ReadErrorBodyAsync(response, cancellationToken);
                    Interlocked.Increment(ref _ocrFailures);
                    lock (_metricsLock)
                    {
                        _lastOcrFailureAt = DateTimeOffset.UtcNow;
                        _lastError = $"AI extraction failed: {errorBody}";
                    }
                    return null;
                }

                await using var responseStream = await response.Content.ReadAsStreamAsync(cancellationToken);
                using var doc = await JsonDocument.ParseAsync(responseStream, cancellationToken: cancellationToken);
                var text = doc.RootElement.TryGetProperty("text", out var textEl) ? textEl.GetString() : null;
                var ocrUsed = doc.RootElement.TryGetProperty("ocr_used", out var ocrEl) && ocrEl.ValueKind is JsonValueKind.True or JsonValueKind.False && ocrEl.GetBoolean();
                var detectedContentType = doc.RootElement.TryGetProperty("content_type", out var contentTypeEl) ? contentTypeEl.GetString() : contentType;
                int? pageCount = doc.RootElement.TryGetProperty("page_count", out var pageCountEl) && pageCountEl.ValueKind == JsonValueKind.Number ? pageCountEl.GetInt32() : null;
                var characters = doc.RootElement.TryGetProperty("characters", out var charactersEl) && charactersEl.ValueKind == JsonValueKind.Number ? charactersEl.GetInt32() : (text?.Length ?? 0);
                var returnedFileName = doc.RootElement.TryGetProperty("file_name", out var fileNameEl) ? fileNameEl.GetString() : fileName;

                lock (_metricsLock)
                {
                    _lastOcrSuccessAt = DateTimeOffset.UtcNow;
                    _lastError = null;
                }

                return new AiTextExtractionResult(text, ocrUsed, detectedContentType, pageCount, characters, returnedFileName);
            }
            catch (Exception ex)
            {
                sw.Stop();
                Interlocked.Add(ref _totalOcrLatencyTicks, sw.ElapsedTicks);
                Interlocked.Increment(ref _ocrFailures);
                lock (_metricsLock)
                {
                    _lastOcrFailureAt = DateTimeOffset.UtcNow;
                    _lastError = ex.Message;
                }
                return null;
            }
        }

        public async Task RunProbeAsync(CancellationToken cancellationToken = default)
        {
            const string probeText = "AI service latency probe for Jobbjakt telemetry.";
            var client = _httpFactory.CreateClient("ai-service");
            var payload = JsonSerializer.Serialize(new { text = probeText, max_length = 48, min_length = 12 });
            using var content = new StringContent(payload, Encoding.UTF8, "application/json");
            var sw = Stopwatch.StartNew();

            try
            {
                using var res = await client.PostAsync("/summarize", content, cancellationToken);
                sw.Stop();

                lock (_metricsLock)
                {
                    _lastProbeAt = DateTimeOffset.UtcNow;
                    _lastProbeLatencyMs = Math.Round(sw.Elapsed.TotalMilliseconds, 1);
                }

                if (!res.IsSuccessStatusCode)
                {
                    var errorBody = await ReadErrorBodyAsync(res, cancellationToken);
                    Interlocked.Increment(ref _probeFailures);
                    lock (_metricsLock)
                    {
                        _lastProbeFailureAt = DateTimeOffset.UtcNow;
                        _lastError = $"AI probe failed: {errorBody}";
                    }
                    return;
                }

                using var stream = await res.Content.ReadAsStreamAsync(cancellationToken);
                using var doc = await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken);
                if (!doc.RootElement.TryGetProperty("summary", out var summaryEl) || string.IsNullOrWhiteSpace(summaryEl.GetString()))
                {
                    Interlocked.Increment(ref _probeFailures);
                    lock (_metricsLock)
                    {
                        _lastProbeFailureAt = DateTimeOffset.UtcNow;
                        _lastError = "Probe returned an empty summary.";
                    }
                    return;
                }

                lock (_metricsLock)
                {
                    _lastProbeSuccessAt = DateTimeOffset.UtcNow;
                    _lastError = null;
                }
            }
            catch (Exception ex)
            {
                sw.Stop();
                Interlocked.Increment(ref _probeFailures);
                lock (_metricsLock)
                {
                    _lastProbeAt = DateTimeOffset.UtcNow;
                    _lastProbeLatencyMs = Math.Round(sw.Elapsed.TotalMilliseconds, 1);
                    _lastProbeFailureAt = DateTimeOffset.UtcNow;
                    _lastError = ex.Message;
                }
            }
        }

        public async Task<AiServiceMetrics> GetMetricsAsync(CancellationToken cancellationToken = default)
        {
            var client = _httpFactory.CreateClient("ai-service");
            string? model = null;
            string? device = null;
            bool? gpuAvailable = null;
            string? gpuName = null;
            bool? ocrAvailable = null;
            string? ocrLanguages = null;
            bool? ollamaConfigured = null;
            bool? ollamaReachable = null;
            string? ollamaModel = null;
            bool? ollamaModelAvailable = null;
            string? ollamaVersion = null;
            List<string>? ollamaInstalledModels = null;
            List<string>? ollamaLoadedModels = null;
            int? ollamaLoadedCount = null;
            double? healthLatencyMs = null;
            var healthy = false;
            string? healthError = null;
            bool? summarizeAvailable = null;
            string? modelLoadError = null;

            try
            {
                var sw = Stopwatch.StartNew();
                using var res = await client.GetAsync("/health", cancellationToken);
                sw.Stop();
                healthLatencyMs = Math.Round(sw.Elapsed.TotalMilliseconds, 1);
                healthy = res.IsSuccessStatusCode;

                if (healthy)
                {
                    using var stream = await res.Content.ReadAsStreamAsync(cancellationToken);
                    using var doc = await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken);
                    if (doc.RootElement.TryGetProperty("model", out var modelEl)) model = modelEl.GetString();
                    if (doc.RootElement.TryGetProperty("device", out var deviceEl)) device = deviceEl.GetString();
                    if (doc.RootElement.TryGetProperty("gpu_available", out var gpuAvailableEl) && gpuAvailableEl.ValueKind is JsonValueKind.True or JsonValueKind.False) gpuAvailable = gpuAvailableEl.GetBoolean();
                    if (doc.RootElement.TryGetProperty("gpu_name", out var gpuNameEl)) gpuName = gpuNameEl.GetString();
                    if (doc.RootElement.TryGetProperty("ocr_available", out var ocrAvailableEl) && ocrAvailableEl.ValueKind is JsonValueKind.True or JsonValueKind.False) ocrAvailable = ocrAvailableEl.GetBoolean();
                    if (doc.RootElement.TryGetProperty("ocr_languages", out var ocrLanguagesEl)) ocrLanguages = ocrLanguagesEl.GetString();
                    if (doc.RootElement.TryGetProperty("summarize_available", out var summarizeAvailableEl) && summarizeAvailableEl.ValueKind is JsonValueKind.True or JsonValueKind.False) summarizeAvailable = summarizeAvailableEl.GetBoolean();
                    if (doc.RootElement.TryGetProperty("model_load_error", out var modelLoadErrorEl) && modelLoadErrorEl.ValueKind == JsonValueKind.String) modelLoadError = modelLoadErrorEl.GetString();
                    if (doc.RootElement.TryGetProperty("ollama_configured", out var ollamaConfiguredEl) && ollamaConfiguredEl.ValueKind is JsonValueKind.True or JsonValueKind.False) ollamaConfigured = ollamaConfiguredEl.GetBoolean();
                    if (doc.RootElement.TryGetProperty("ollama_reachable", out var ollamaReachableEl) && ollamaReachableEl.ValueKind is JsonValueKind.True or JsonValueKind.False) ollamaReachable = ollamaReachableEl.GetBoolean();
                    if (doc.RootElement.TryGetProperty("ollama_model", out var ollamaModelEl)) ollamaModel = ollamaModelEl.GetString();
                    if (doc.RootElement.TryGetProperty("ollama_model_available", out var ollamaModelAvailableEl) && ollamaModelAvailableEl.ValueKind is JsonValueKind.True or JsonValueKind.False) ollamaModelAvailable = ollamaModelAvailableEl.GetBoolean();
                    if (doc.RootElement.TryGetProperty("ollama_version", out var ollamaVersionEl)) ollamaVersion = ollamaVersionEl.GetString();
                    if (doc.RootElement.TryGetProperty("ollama_installed_models", out var ollamaInstalledModelsEl) && ollamaInstalledModelsEl.ValueKind == JsonValueKind.Array)
                    {
                        ollamaInstalledModels = ollamaInstalledModelsEl.EnumerateArray().Where(x => x.ValueKind == JsonValueKind.String).Select(x => x.GetString()).Where(x => !string.IsNullOrWhiteSpace(x)).Cast<string>().ToList();
                    }
                    if (doc.RootElement.TryGetProperty("ollama_loaded_models", out var ollamaLoadedModelsEl) && ollamaLoadedModelsEl.ValueKind == JsonValueKind.Array)
                    {
                        ollamaLoadedModels = ollamaLoadedModelsEl.EnumerateArray().Where(x => x.ValueKind == JsonValueKind.String).Select(x => x.GetString()).Where(x => !string.IsNullOrWhiteSpace(x)).Cast<string>().ToList();
                    }
                    if (doc.RootElement.TryGetProperty("ollama_loaded_count", out var ollamaLoadedCountEl) && ollamaLoadedCountEl.ValueKind == JsonValueKind.Number) ollamaLoadedCount = ollamaLoadedCountEl.GetInt32();
                    if (summarizeAvailable == false)
                    {
                        healthy = false;
                        healthError = string.IsNullOrWhiteSpace(modelLoadError)
                            ? "AI summarize capability is unavailable."
                            : modelLoadError;
                    }
                }
                else
                {
                    healthError = $"Health check returned {(int)res.StatusCode}.";
                }
            }
            catch (Exception ex)
            {
                healthError = ex.Message;
            }

            var requests = Volatile.Read(ref _requests);
            var cacheHits = Volatile.Read(ref _cacheHits);
            var cacheMisses = Volatile.Read(ref _cacheMisses);
            var failures = Volatile.Read(ref _failures);
            var totalLatencyTicks = Volatile.Read(ref _totalLatencyTicks);
            var ocrRequests = Volatile.Read(ref _ocrRequests);
            var ocrFailures = Volatile.Read(ref _ocrFailures);
            var totalOcrLatencyTicks = Volatile.Read(ref _totalOcrLatencyTicks);

            DateTimeOffset? lastSuccessAt;
            DateTimeOffset? lastFailureAt;
            double? probeLatencyMs;
            DateTimeOffset? lastProbeAt;
            DateTimeOffset? lastProbeSuccessAt;
            DateTimeOffset? lastProbeFailureAt;
            DateTimeOffset? lastOcrSuccessAt;
            DateTimeOffset? lastOcrFailureAt;
            string? lastError;
            lock (_metricsLock)
            {
                lastSuccessAt = _lastSuccessAt;
                lastFailureAt = _lastFailureAt;
                probeLatencyMs = _lastProbeLatencyMs;
                lastProbeAt = _lastProbeAt;
                lastProbeSuccessAt = _lastProbeSuccessAt;
                lastProbeFailureAt = _lastProbeFailureAt;
                lastOcrSuccessAt = _lastOcrSuccessAt;
                lastOcrFailureAt = _lastOcrFailureAt;
                lastError = _lastError;
            }

            if (!healthy && !string.IsNullOrWhiteSpace(healthError))
            {
                lastError = healthError;
            }

            double? averageLatencyMs = requests > 0 ? Math.Round(TimeSpan.FromTicks(totalLatencyTicks).TotalMilliseconds / requests, 1) : null;
            double? averageOcrLatencyMs = ocrRequests > 0 ? Math.Round(TimeSpan.FromTicks(totalOcrLatencyTicks).TotalMilliseconds / ocrRequests, 1) : null;

            return new AiServiceMetrics(
                Healthy: healthy,
                Model: model,
                Device: device,
                GpuAvailable: gpuAvailable,
                GpuName: gpuName,
                OcrAvailable: ocrAvailable,
                OcrLanguages: ocrLanguages,
                OllamaConfigured: ollamaConfigured,
                OllamaReachable: ollamaReachable,
                OllamaModel: ollamaModel,
                OllamaModelAvailable: ollamaModelAvailable,
                OllamaVersion: ollamaVersion,
                OllamaInstalledModels: ollamaInstalledModels,
                OllamaLoadedModels: ollamaLoadedModels,
                OllamaLoadedCount: ollamaLoadedCount,
                HealthLatencyMs: healthLatencyMs,
                ProbeLatencyMs: probeLatencyMs,
                LastProbeAt: lastProbeAt,
                LastProbeSuccessAt: lastProbeSuccessAt,
                LastProbeFailureAt: lastProbeFailureAt,
                ProbeFailures: Volatile.Read(ref _probeFailures),
                Requests: requests,
                CacheHits: cacheHits,
                CacheMisses: cacheMisses,
                Failures: failures,
                AverageLatencyMs: averageLatencyMs,
                OcrRequests: ocrRequests,
                OcrFailures: ocrFailures,
                AverageOcrLatencyMs: averageOcrLatencyMs,
                LastOcrSuccessAt: lastOcrSuccessAt,
                LastOcrFailureAt: lastOcrFailureAt,
                LastSuccessAt: lastSuccessAt,
                LastFailureAt: lastFailureAt,
                LastError: lastError
            );
        }
    }

    public sealed class SummarizerProbeHostedService : BackgroundService
    {
        private readonly IServiceScopeFactory _scopeFactory;
        private readonly ILogger<SummarizerProbeHostedService> _logger;
        private readonly IConfiguration _cfg;

        public SummarizerProbeHostedService(IServiceScopeFactory scopeFactory, ILogger<SummarizerProbeHostedService> logger, IConfiguration cfg)
        {
            _scopeFactory = scopeFactory;
            _logger = logger;
            _cfg = cfg;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            var enabled = _cfg.GetValue("Ai:ProbeEnabled", _cfg.GetValue("Summarizer:ProbeEnabled", true));
            if (!enabled) return;

            var intervalSeconds = Math.Clamp(_cfg.GetValue("Ai:ProbeIntervalSeconds", _cfg.GetValue("Summarizer:ProbeIntervalSeconds", 300)), 30, 3600);
            var initialDelaySeconds = Math.Clamp(_cfg.GetValue("Ai:ProbeInitialDelaySeconds", _cfg.GetValue("Summarizer:ProbeInitialDelaySeconds", 15)), 0, 600);

            if (initialDelaySeconds > 0)
            {
                await Task.Delay(TimeSpan.FromSeconds(initialDelaySeconds), stoppingToken);
            }

            using var timer = new PeriodicTimer(TimeSpan.FromSeconds(intervalSeconds));
            do
            {
                try
                {
                    using var scope = _scopeFactory.CreateScope();
                    var aiService = scope.ServiceProvider.GetRequiredService<ISummarizerService>();
                    await aiService.RunProbeAsync(stoppingToken);
                }
                catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
                {
                    break;
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "AI service latency probe failed.");
                }
            }
            while (await timer.WaitForNextTickAsync(stoppingToken));
        }
    }
}