#if false
using System.Diagnostics.Metrics;
using OrpaonVision.Core.Results;
using OrpaonVision.Core.RuleEngine;

namespace OrpaonVision.SiteApp.Runtime.Metrics;

/// <summary>
/// 规则引擎性能指标收集器。
/// </summary>
public interface IRuleEngineMetrics
{
    void RecordRuleEvaluation(string ruleType, TimeSpan elapsed, RuleResult result);
    void RecordRuleLoad(int ruleCount, TimeSpan elapsed);
    void RecordRuleValidation(bool isValid, string ruleType);
}

/// <summary>
/// 规则引擎性能指标收集器实现。
/// </summary>
public sealed class RuleEngineMetrics : IRuleEngineMetrics
{
    private readonly Counter<int> _ruleEvaluationCounter;
    private readonly Histogram<double> _ruleEvaluationDuration;
    private readonly Counter<int> _ruleLoadCounter;
    private readonly Histogram<double> _ruleLoadDuration;
    private readonly Counter<int> _ruleValidationCounter;
    private readonly ILogger<RuleEngineMetrics> _logger;

    public RuleEngineMetrics(IMeterFactory meterFactory, ILogger<RuleEngineMetrics> logger)
    {
        var meter = meterFactory.Create("OrpaonVision.RuleEngine");
        
        _ruleEvaluationCounter = meter.CreateCounter<int>(
            "orpaonvision_rule_engine_evaluations_total",
            description: "规则评估总次数");
            
        _ruleEvaluationDuration = meter.CreateHistogram<double>(
            "orpaonvision_rule_engine_evaluation_duration_seconds",
            description: "规则评估耗时（秒）");
            
        _ruleLoadCounter = meter.CreateCounter<int>(
            "orpaonvision_rule_engine_loads_total",
            description: "规则加载总次数");
            
        _ruleLoadDuration = meter.CreateHistogram<double>(
            "orpaonvision_rule_engine_load_duration_seconds",
            description: "规则加载耗时（秒）");
            
        _ruleValidationCounter = meter.CreateCounter<int>(
            "orpaonvision_rule_engine_validations_total",
            description: "规则验证总次数");
        
        _logger = logger;
    }

    public void RecordRuleEvaluation(string ruleType, TimeSpan elapsed, RuleResult result)
    {
        try
        {
            var elapsedSeconds = elapsed.TotalSeconds;
            
            // 记录评估次数
            _ruleEvaluationCounter.Add(1, new KeyValuePair<string, object>[]
            {
                new("rule_type", ruleType),
                new("result", result.ToString()),
                new("success", result == RuleResult.Pass ? "true" : "false")
            });
            
            // 记录评估耗时
            _ruleEvaluationDuration.Record(elapsedSeconds, new KeyValuePair<string, object>[]
            {
                new("rule_type", ruleType),
                new("result", result.ToString())
            });
            
            _logger.LogDebug("记录规则评估指标：类型={RuleType}，结果={Result}，耗时={ElapsedMs}ms", 
                ruleType, result, elapsed.TotalMilliseconds);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "记录规则评估指标失败：类型={RuleType}", ruleType);
        }
    }

    public void RecordRuleLoad(int ruleCount, TimeSpan elapsed)
    {
        try
        {
            var elapsedSeconds = elapsed.TotalSeconds;
            
            // 记录加载次数
            _ruleLoadCounter.Add(1, new KeyValuePair<string, object>[]
            {
                new("rule_count", ruleCount)
            });
            
            // 记录加载耗时
            _ruleLoadDuration.Record(elapsedSeconds, new KeyValuePair<string, object>[]
            {
                new("rule_count", ruleCount)
            });
            
            _logger.LogDebug("记录规则加载指标：数量={RuleCount}，耗时={ElapsedMs}ms", 
                ruleCount, elapsed.TotalMilliseconds);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "记录规则加载指标失败：数量={RuleCount}", ruleCount);
        }
    }

    public void RecordRuleValidation(bool isValid, string ruleType)
    {
        try
        {
            // 记录验证次数
            _ruleValidationCounter.Add(1, new KeyValuePair<string, object>[]
            {
                new("rule_type", ruleType),
                new("valid", isValid ? "true" : "false")
            });
            
            _logger.LogDebug("记录规则验证指标：类型={RuleType}，有效={IsValid}", ruleType, isValid);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "记录规则验证指标失败：类型={RuleType}", ruleType);
        }
    }
}

#endif