using System.Globalization;
using System.Text.Json;
using System.Text.RegularExpressions;
using Lagerbestand.Models;

namespace Lagerbestand.Services;

/// <summary>
/// Parsed data of a tire measurement report (Launch TTS01 tread depth scanner).
/// </summary>
public class TireReportData
{
    public string RecordSn { get; set; } = string.Empty;
    public string ReportUrl { get; set; } = string.Empty;
    public DateTime? MeasuredAt { get; set; }
    public string? LicensePlate { get; set; }
    public int? Mileage { get; set; }
    public decimal? TreadDepthFL { get; set; }
    public decimal? TreadDepthFR { get; set; }
    public decimal? TreadDepthRL { get; set; }
    public decimal? TreadDepthRR { get; set; }
    public TireMeasureRating RatingFL { get; set; }
    public TireMeasureRating RatingFR { get; set; }
    public TireMeasureRating RatingRL { get; set; }
    public TireMeasureRating RatingRR { get; set; }
    public decimal? WarningThreshold { get; set; }
    public decimal? CriticalThreshold { get; set; }
    public decimal? BrakingDistanceDelta { get; set; }
    public string? Recommendation { get; set; }
    public string? DeviceSerial { get; set; }
    public string? RawJson { get; set; }

    /// <summary>True if the report itself contained tread depth values.</summary>
    public bool HasTreadData => TreadDepthFL.HasValue || TreadDepthFR.HasValue || TreadDepthRL.HasValue || TreadDepthRR.HasValue;

    public TireInspection ToInspection(Guid tireStackId, Guid? userId) => new()
    {
        TireStackId = tireStackId,
        Source = "Launch TTS01",
        RecordSn = Truncate(RecordSn, 100),
        ReportUrl = Truncate(ReportUrl, 500),
        MeasuredAt = MeasuredAt,
        LicensePlate = Truncate(LicensePlate?.Trim().ToUpperInvariant(), 20),
        Mileage = Mileage is < 0 ? null : Mileage,
        TreadDepthFL = TreadDepthFL,
        TreadDepthFR = TreadDepthFR,
        TreadDepthRL = TreadDepthRL,
        TreadDepthRR = TreadDepthRR,
        RatingFL = RatingFL,
        RatingFR = RatingFR,
        RatingRL = RatingRL,
        RatingRR = RatingRR,
        Recommendation = Truncate(Recommendation, 1000),
        RawJson = RawJson,
        CreatedByUserId = userId
    };

    /// <summary>
    /// Re-evaluates the per-wheel ratings from the current tread depths using the
    /// thresholds delivered by the device (falls back to legal defaults).
    /// </summary>
    public void RecomputeRatings()
    {
        RatingFL = TireInspection.RateDepth(TreadDepthFL, CriticalThreshold, WarningThreshold);
        RatingFR = TireInspection.RateDepth(TreadDepthFR, CriticalThreshold, WarningThreshold);
        RatingRL = TireInspection.RateDepth(TreadDepthRL, CriticalThreshold, WarningThreshold);
        RatingRR = TireInspection.RateDepth(TreadDepthRR, CriticalThreshold, WarningThreshold);
    }

    private static string? Truncate(string? s, int max)
    {
        if (string.IsNullOrEmpty(s)) return s;
        return s.Length <= max ? s : s[..max];
    }
}

public interface ITireReportService
{
    /// <summary>
    /// Tries to extract the report record number from a scanned QR text
    /// (full share URL or bare record number).
    /// </summary>
    bool TryParseReportUrl(string? qrText, out string recordSn, out string reportUrl);

    /// <summary>
    /// Loads and parses the report. Returns a data object with at least
    /// RecordSn/ReportUrl; HasTreadData indicates whether values could be read.
    /// Throws <see cref="TireReportException"/> with a user-friendly message on failure.
    /// </summary>
    Task<TireReportData> FetchAsync(string recordSn, CancellationToken cancellationToken = default);
}

public class TireReportException : Exception
{
    public TireReportException(string message, Exception? inner = null) : base(message, inner) { }
}

public class TireReportService : ITireReportService
{
    private const string DefaultShareUrl = "https://files.cnlaunch.com/assets/TTS01DetectReportShare.html?dataRecordSn=";
    private const string DefaultApiUrl = "https://files.cnlaunch.com/api/ttm/getTtmReportData";

    private static readonly Regex RecordSnRegex = new(@"dataRecordSn=([A-Za-z0-9_-]+)", RegexOptions.IgnoreCase | RegexOptions.Compiled);
    private static readonly Regex BareSnRegex = new(@"^[A-Za-z0-9_-]{16,64}$", RegexOptions.Compiled);

    private readonly IHttpClientFactory _httpClientFactory;
    private readonly ILogger<TireReportService> _logger;
    private readonly string _apiUrl;
    private readonly string _shareUrl;

    public TireReportService(IHttpClientFactory httpClientFactory, IConfiguration configuration, ILogger<TireReportService> logger)
    {
        _httpClientFactory = httpClientFactory;
        _logger = logger;
        _apiUrl = configuration["LaunchReport:ApiUrl"] ?? DefaultApiUrl;
        _shareUrl = configuration["LaunchReport:ShareUrl"] ?? DefaultShareUrl;
    }

    public bool TryParseReportUrl(string? qrText, out string recordSn, out string reportUrl)
    {
        recordSn = string.Empty;
        reportUrl = string.Empty;
        if (string.IsNullOrWhiteSpace(qrText)) return false;

        var text = qrText.Trim();
        var m = RecordSnRegex.Match(text);
        if (m.Success)
        {
            recordSn = m.Groups[1].Value;
            reportUrl = text.StartsWith("http", StringComparison.OrdinalIgnoreCase) ? text : _shareUrl + recordSn;
            return true;
        }

        if (BareSnRegex.IsMatch(text))
        {
            recordSn = text;
            reportUrl = _shareUrl + recordSn;
            return true;
        }

        return false;
    }

    public async Task<TireReportData> FetchAsync(string recordSn, CancellationToken cancellationToken = default)
    {
        var result = new TireReportData
        {
            RecordSn = recordSn,
            ReportUrl = _shareUrl + recordSn
        };

        var client = _httpClientFactory.CreateClient("LaunchReport");
        string json;
        try
        {
            using var response = await client.PostAsJsonAsync(_apiUrl, new { dataRecordSn = recordSn }, cancellationToken);
            if (!response.IsSuccessStatusCode)
            {
                _logger.LogWarning("Launch report {Sn}: HTTP {Status}", recordSn, (int)response.StatusCode);
                throw new TireReportException($"Report-Server antwortete mit HTTP {(int)response.StatusCode}.");
            }
            json = await response.Content.ReadAsStringAsync(cancellationToken);
        }
        catch (TireReportException) { throw; }
        catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
        {
            throw new TireReportException("Zeitüberschreitung beim Laden des Reports.");
        }
        catch (HttpRequestException ex)
        {
            _logger.LogWarning(ex, "Launch report {Sn}: Netzwerkfehler", recordSn);
            throw new TireReportException("Report-Server nicht erreichbar. Bitte Internetverbindung prüfen.", ex);
        }

        result.RawJson = json;

        try
        {
            using var doc = JsonDocument.Parse(json);
            var root = doc.RootElement;

            if (root.TryGetProperty("code", out var codeEl) && codeEl.ValueKind == JsonValueKind.Number && codeEl.GetInt32() != 200)
            {
                _logger.LogWarning("Launch report {Sn} returned code {Code}", recordSn, codeEl.GetInt32());
                return result;
            }

            JsonElement report;
            if (root.TryGetProperty("data", out var dataEl) && dataEl.ValueKind == JsonValueKind.Object
                && dataEl.TryGetProperty("reportInfoData", out var rid))
            {
                report = rid;
            }
            else if (root.TryGetProperty("detectData", out var dd))
            {
                report = dd;
            }
            else
            {
                return result;
            }

            Parse(report, result);
        }
        catch (JsonException ex)
        {
            _logger.LogWarning(ex, "Launch report {Sn}: JSON konnte nicht gelesen werden", recordSn);
        }

        return result;
    }

    private static void Parse(JsonElement report, TireReportData result)
    {
        if (report.TryGetProperty("t", out var t))
        {
            long seconds = t.ValueKind == JsonValueKind.Number ? t.GetInt64()
                : long.TryParse(t.GetString(), out var ls) ? ls : 0;
            if (seconds > 100000)
                result.MeasuredAt = DateTimeOffset.FromUnixTimeSeconds(seconds).UtcDateTime;
        }

        if (report.TryGetProperty("sn", out var sn) && sn.ValueKind == JsonValueKind.String)
            result.DeviceSerial = sn.GetString();

        if (report.TryGetProperty("i", out var info) && info.ValueKind == JsonValueKind.Object)
        {
            if (info.TryGetProperty("cn", out var cn) && cn.ValueKind == JsonValueKind.String)
                result.LicensePlate = NullIfEmpty(cn.GetString());
            if (info.TryGetProperty("dt", out var dt))
            {
                if (dt.ValueKind == JsonValueKind.Number && dt.TryGetInt32(out var km)) result.Mileage = km;
                else if (dt.ValueKind == JsonValueKind.String && int.TryParse(dt.GetString(), out var km2)) result.Mileage = km2;
            }
        }

        if (!report.TryGetProperty("dr", out var dr) || dr.ValueKind != JsonValueKind.Object)
            return;

        // Thresholds "critical-warning", e.g. "1.6-2.5"
        if (dr.TryGetProperty("ts", out var ts) && ts.ValueKind == JsonValueKind.String)
        {
            var parts = ts.GetString()!.Split('-');
            if (parts.Length == 2)
            {
                result.CriticalThreshold = ParseDecimal(parts[0]);
                result.WarningThreshold = ParseDecimal(parts[1]);
            }
        }

        if (dr.TryGetProperty("d", out var d))
            result.BrakingDistanceDelta = d.ValueKind == JsonValueKind.Number ? d.GetDecimal() : ParseDecimal(d.GetString());

        // Minimum values per wheel: l1 = front left, r1 = front right, ll1 = rear left, rr1 = rear right
        if (dr.TryGetProperty("rl", out var rl) && rl.ValueKind == JsonValueKind.Object)
        {
            result.TreadDepthFL = GetDecimal(rl, "l1");
            result.TreadDepthFR = GetDecimal(rl, "r1");
            result.TreadDepthRL = GetDecimal(rl, "ll1");
            result.TreadDepthRR = GetDecimal(rl, "rr1");
        }

        // Fallback: compute minimum from raw readings (z = axle, p = side, gd = readings)
        if (!result.HasTreadData && dr.TryGetProperty("r", out var r) && r.ValueKind == JsonValueKind.Array)
        {
            foreach (var tire in r.EnumerateArray())
            {
                var z = tire.TryGetProperty("z", out var ze) ? ze.GetInt32() : 0;
                var p = tire.TryGetProperty("p", out var pe) ? pe.GetInt32() : 0;
                decimal? min = null;
                if (tire.TryGetProperty("gd", out var gd) && gd.ValueKind == JsonValueKind.Array)
                {
                    foreach (var s in gd.EnumerateArray())
                    {
                        foreach (var v in (s.GetString() ?? "").Split(',', StringSplitOptions.RemoveEmptyEntries))
                        {
                            var dv = ParseDecimal(v);
                            if (dv.HasValue && (!min.HasValue || dv < min)) min = dv;
                        }
                    }
                }
                switch (z, p)
                {
                    case (1, 1): result.TreadDepthFL = min; break;
                    case (1, 2): result.TreadDepthFR = min; break;
                    case (2, 1): result.TreadDepthRL = min; break;
                    case (2, 2): result.TreadDepthRR = min; break;
                }
            }
        }

        result.RecomputeRatings();

        result.Recommendation = BuildRecommendation(result);
    }

    private static string? BuildRecommendation(TireReportData d)
    {
        var worst = new[] { d.RatingFL, d.RatingFR, d.RatingRL, d.RatingRR }.Max();
        var parts = new List<string>();

        switch (worst)
        {
            case TireMeasureRating.Critical:
                parts.Add("Profiltiefe unter Mindestwert – Reifen umgehend ersetzen.");
                break;
            case TireMeasureRating.Warning:
                parts.Add("Profiltiefe im Grenzbereich – Reifenwechsel empfohlen.");
                break;
            case TireMeasureRating.Ok:
                parts.Add("Profiltiefe in Ordnung.");
                break;
        }

        var depths = new[] { d.TreadDepthFL, d.TreadDepthFR, d.TreadDepthRL, d.TreadDepthRR }.Where(x => x.HasValue).Select(x => x!.Value).ToList();
        if (depths.Count >= 2 && depths.Max() - depths.Min() >= 2m)
            parts.Add("Ungleichmäßige Abnutzung (Differenz ≥ 2 mm) – Achsvermessung/Rotation prüfen.");

        if (d.BrakingDistanceDelta is > 0)
            parts.Add($"Bremsweg ca. +{d.BrakingDistanceDelta.Value.ToString("0.#", CultureInfo.GetCultureInfo("de-DE"))} m gegenüber Neureifen.");

        return parts.Count == 0 ? null : string.Join(" ", parts);
    }

    private static decimal? GetDecimal(JsonElement obj, string name)
    {
        if (!obj.TryGetProperty(name, out var el)) return null;
        return el.ValueKind switch
        {
            JsonValueKind.Number => el.GetDecimal(),
            JsonValueKind.String => ParseDecimal(el.GetString()),
            _ => null
        };
    }

    private static decimal? ParseDecimal(string? s)
    {
        if (string.IsNullOrWhiteSpace(s)) return null;
        return decimal.TryParse(s.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var v) ? v : null;
    }

    private static string? NullIfEmpty(string? s) => string.IsNullOrWhiteSpace(s) ? null : s.Trim();
}