FormulaPersistenceManager.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using Newtonsoft.Json;

namespace WebToolsDataMonitor
{
    public class CustomFormula
    {
        public string Tool { get; set; }
        public string DeviceName { get; set; }
        public string MetricName { get; set; }

        public string CheckMethod { get; set; } // ">", "<", "=", "contains"
        public string TargetDataType { get; set; } // "Int", "Float", "Double", "String"
        public string ComparisonValue { get; set; }
        public string AssignedStatus { get; set; } // "disaster-bg", "average-bg", "warning-bg", "info-bg"
    }

    public static class FormulaPersistenceManager
    {
        private static readonly string FilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "formulas.json");
        private static List<CustomFormula> _formulas = new List<CustomFormula>();

        static FormulaPersistenceManager()
        {
            LoadFormulas();
        }

        public static void LoadFormulas()
        {
            try
            {
                if (File.Exists(FilePath))
                {
                    string json = File.ReadAllText(FilePath);
                    _formulas = JsonConvert.DeserializeObject<List<CustomFormula>>(json) ?? new List<CustomFormula>();
                }
            }
            catch { _formulas = new List<CustomFormula>(); }
        }

        public static void SaveFormula(CustomFormula formula)
        {
            // Remove existing match if overwriting a rule for the same specific target
            _formulas.RemoveAll(f => f.Tool == formula.Tool && f.DeviceName == formula.DeviceName && f.MetricName == formula.MetricName);
            _formulas.Add(formula);

            try
            {
                string json = JsonConvert.SerializeObject(_formulas, Formatting.Indented);
                File.WriteAllText(FilePath, json);
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"Failed to write formula matrix maps: {ex.Message}");
            }
        }

        // Evaluates incoming data against stored rule sets. Convenience overload for callers that don't
        // need the human-readable match description (e.g. existing tests) - delegates to the full overload.
        public static string EvaluateMetric(string tool, string device, string metricName, string rawValue)
        {
            return EvaluateMetric(tool, device, metricName, rawValue, out _);
        }

        // Same as above, but also reports a human-readable description of what matched (e.g. "230 is below
        // 250") when a rule fires - used to speak the actual triggering condition, not just the metric
        // name, for alerts driven by a custom rule (see Form2.TriggerAlert). Null when no rule matched, or
        // when it matched via "any" (there's no meaningful value comparison to describe for that operator).
        public static string EvaluateMetric(string tool, string device, string metricName, string rawValue, out string matchDescription)
        {
            matchDescription = null;

            var match = _formulas.Find(f => f.Tool == tool && f.DeviceName == device && f.MetricName == metricName);
            if (match == null) return null; // No custom user override exists

            // 🔥 ADDED: If operator is set to 'any', return the assigned status immediately
            if (string.Equals(match.CheckMethod, "any", StringComparison.OrdinalIgnoreCase))
            {
                return match.AssignedStatus;
            }

            try
            {
                // 🔥 FIXED: rawValue/ComparisonValue can legitimately be null (a script returning
                // value: null for a metric, or a hand-edited formulas.json) - these used to be Trim()'d
                // outside the try/catch, so a null here threw an uncaught NullReferenceException that
                // unwound the entire calling foreach loop in StatusLineDto.FromDeviceMeta, silently
                // dropping every remaining metric in that batch, not just the one with the bad value.
                string cleanInput = (rawValue ?? string.Empty).Trim();
                string cleanTarget = (match.ComparisonValue ?? string.Empty).Trim();

                switch (match.CheckMethod)
                {
                    case "contains":
                        if (cleanInput.IndexOf(cleanTarget, StringComparison.OrdinalIgnoreCase) < 0) return null;
                        matchDescription = $"{cleanInput} contains {cleanTarget}";
                        return match.AssignedStatus;

                    case "=":
                        if (match.TargetDataType == "String")
                        {
                            if (!string.Equals(cleanInput, cleanTarget, StringComparison.OrdinalIgnoreCase)) return null;
                            matchDescription = $"{cleanInput} equals {cleanTarget}";
                            return match.AssignedStatus;
                        }
                        return EvaluateNumeric(cleanInput, cleanTarget, match.TargetDataType, match.CheckMethod, out matchDescription) ? match.AssignedStatus : null;

                    case "!=":
                        if (match.TargetDataType == "String")
                        {
                            if (string.Equals(cleanInput, cleanTarget, StringComparison.OrdinalIgnoreCase)) return null;
                            matchDescription = $"{cleanInput} is not {cleanTarget}";
                            return match.AssignedStatus;
                        }
                        return EvaluateNumeric(cleanInput, cleanTarget, match.TargetDataType, match.CheckMethod, out matchDescription) ? match.AssignedStatus : null;

                    case ">":
                    case "<":
                        return EvaluateNumeric(cleanInput, cleanTarget, match.TargetDataType, match.CheckMethod, out matchDescription) ? match.AssignedStatus : null;
                }
            }
            catch { /* Gracefully skip corrupt comparison conversions */ }

            return null;
        }

        private static bool EvaluateNumeric(string input, string target, string type, string op, out string matchDescription)
        {
            matchDescription = null;

            // Extract decimal numbers out of raw string structures (e.g., "93 %" -> "93", "230.4 V" -> "230.4")
            string cleanIn = Regex.Match(input, @"[0-9.-]+").Value;
            string cleanTar = Regex.Match(target, @"[0-9.-]+").Value;

            if (string.IsNullOrEmpty(cleanIn) || string.IsNullOrEmpty(cleanTar)) return false;

            // 🔥 FIXED: every TryParse below used to run against CultureInfo.CurrentCulture (the implicit
            // default). Scraped device values and the extracted regex fragment always use "." as the
            // decimal point (English/technical convention), but on a machine whose OS culture uses "," as
            // the decimal separator (e.g. uk-UA), double.TryParse("230.4") silently returns false under
            // that culture - it expects "230,4". This made every single numeric rule with a fractional
            // value fail on exactly the locale this app is actually deployed on, regardless of the
            // Int-truncation fix above. NumberStyles.Float here explicitly allows a leading sign and a
            // decimal point (but not a culture-specific group separator), paired with InvariantCulture so
            // "." is always read as the decimal point no matter what the OS is configured for.
            const NumberStyles NumStyle = NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint;

            if (type == "Int")
            {
                // int.TryParse rejects any string with a decimal point, but scraped values almost always
                // have one ("230.4 V", "12.3 %") - this made every Int-type rule silently never match
                // against a real-world reading. Parse as double first and truncate, same as BtnSave_Click
                // already does for the saved comparison value, so both sides are handled consistently.
                if (double.TryParse(cleanIn, NumStyle, CultureInfo.InvariantCulture, out double di) &&
                    double.TryParse(cleanTar, NumStyle, CultureInfo.InvariantCulture, out double dt))
                {
                    int i = (int)Math.Truncate(di);
                    int t = (int)Math.Truncate(dt);

                    bool isMatch;
                    string verb;
                    if (op == ">") { isMatch = i > t; verb = "is above"; }
                    else if (op == "<") { isMatch = i < t; verb = "is below"; }
                    else if (op == "!=") { isMatch = i != t; verb = "is not"; }
                    else { isMatch = i == t; verb = "equals"; }

                    if (isMatch) matchDescription = $"{i} {verb} {t}";
                    return isMatch;
                }
            }
            else if (type == "Float")
            {
                if (float.TryParse(cleanIn, NumStyle, CultureInfo.InvariantCulture, out float i) &&
                    float.TryParse(cleanTar, NumStyle, CultureInfo.InvariantCulture, out float t))
                {
                    bool isMatch;
                    string verb;
                    if (op == ">") { isMatch = i > t; verb = "is above"; }
                    else if (op == "<") { isMatch = i < t; verb = "is below"; }
                    else if (op == "!=") { isMatch = i != t; verb = "is not"; }
                    else { isMatch = i == t; verb = "equals"; }

                    if (isMatch) matchDescription = $"{i} {verb} {t}";
                    return isMatch;
                }
            }
            else if (type == "Double")
            {
                if (double.TryParse(cleanIn, NumStyle, CultureInfo.InvariantCulture, out double i) &&
                    double.TryParse(cleanTar, NumStyle, CultureInfo.InvariantCulture, out double t))
                {
                    bool isMatch;
                    string verb;
                    if (op == ">") { isMatch = i > t; verb = "is above"; }
                    else if (op == "<") { isMatch = i < t; verb = "is below"; }
                    else if (op == "!=") { isMatch = i != t; verb = "is not"; }
                    else { isMatch = i == t; verb = "equals"; }

                    if (isMatch) matchDescription = $"{i} {verb} {t}";
                    return isMatch;
                }
            }
            return false;
        }
    }
}