using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using Serilog;

namespace ZB.MOM.WW.OtOpcUa.Host.Metrics
{
    /// <summary>
    ///     Disposable scope returned by <see cref="PerformanceMetrics.BeginOperation" />. (MXA-008)
    /// </summary>
    public interface ITimingScope : IDisposable
    {
        /// <summary>
        ///     Marks whether the timed bridge operation completed successfully.
        /// </summary>
        /// <param name="success">A value indicating whether the measured operation succeeded.</param>
        void SetSuccess(bool success);
    }

    /// <summary>
    ///     Statistics snapshot for a single operation type.
    /// </summary>
    public class MetricsStatistics
    {
        /// <summary>
        ///     Gets or sets the total number of recorded executions for the operation.
        /// </summary>
        public long TotalCount { get; set; }

        /// <summary>
        ///     Gets or sets the number of recorded executions that completed successfully.
        /// </summary>
        public long SuccessCount { get; set; }

        /// <summary>
        ///     Gets or sets the ratio of successful executions to total executions.
        /// </summary>
        public double SuccessRate { get; set; }

        /// <summary>
        ///     Gets or sets the mean execution time in milliseconds across the recorded sample.
        /// </summary>
        public double AverageMilliseconds { get; set; }

        /// <summary>
        ///     Gets or sets the fastest recorded execution time in milliseconds.
        /// </summary>
        public double MinMilliseconds { get; set; }

        /// <summary>
        ///     Gets or sets the slowest recorded execution time in milliseconds.
        /// </summary>
        public double MaxMilliseconds { get; set; }

        /// <summary>
        ///     Gets or sets the 95th percentile execution time in milliseconds.
        /// </summary>
        public double Percentile95Milliseconds { get; set; }
    }

    /// <summary>
    ///     Per-operation timing and success tracking with a 1000-entry rolling buffer. (MXA-008)
    /// </summary>
    public class OperationMetrics
    {
        private readonly List<double> _durations = new();
        private readonly object _lock = new();
        private double _maxMilliseconds;
        private double _minMilliseconds = double.MaxValue;
        private long _successCount;
        private long _totalCount;
        private double _totalMilliseconds;

        /// <summary>
        ///     Records the outcome and duration of a single bridge operation invocation.
        /// </summary>
        /// <param name="duration">The elapsed time for the operation.</param>
        /// <param name="success">A value indicating whether the operation completed successfully.</param>
        public void Record(TimeSpan duration, bool success)
        {
            lock (_lock)
            {
                _totalCount++;
                if (success) _successCount++;

                var ms = duration.TotalMilliseconds;
                _durations.Add(ms);
                _totalMilliseconds += ms;

                if (ms < _minMilliseconds) _minMilliseconds = ms;
                if (ms > _maxMilliseconds) _maxMilliseconds = ms;

                if (_durations.Count > 1000) _durations.RemoveAt(0);
            }
        }

        /// <summary>
        ///     Creates a snapshot of the current statistics for this operation type.
        /// </summary>
        /// <returns>A statistics snapshot suitable for logs, status reporting, and tests.</returns>
        public MetricsStatistics GetStatistics()
        {
            lock (_lock)
            {
                if (_totalCount == 0)
                    return new MetricsStatistics();

                var sorted = _durations.OrderBy(d => d).ToList();
                var p95Index = Math.Max(0, (int)Math.Ceiling(sorted.Count * 0.95) - 1);

                return new MetricsStatistics
                {
                    TotalCount = _totalCount,
                    SuccessCount = _successCount,
                    SuccessRate = (double)_successCount / _totalCount,
                    AverageMilliseconds = _totalMilliseconds / _totalCount,
                    MinMilliseconds = _minMilliseconds,
                    MaxMilliseconds = _maxMilliseconds,
                    Percentile95Milliseconds = sorted[p95Index]
                };
            }
        }
    }

    /// <summary>
    ///     Tracks per-operation performance metrics with periodic logging. (MXA-008)
    /// </summary>
    public class PerformanceMetrics : IDisposable
    {
        private static readonly ILogger Logger = Log.ForContext<PerformanceMetrics>();

        private readonly ConcurrentDictionary<string, OperationMetrics>
            _metrics = new(StringComparer.OrdinalIgnoreCase);

        private readonly Timer _reportingTimer;
        private bool _disposed;

        /// <summary>
        ///     Initializes a new metrics collector and starts periodic performance reporting.
        /// </summary>
        public PerformanceMetrics()
        {
            _reportingTimer = new Timer(ReportMetrics, null,
                TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(60));
        }

        /// <summary>
        ///     Stops periodic reporting and emits a final metrics snapshot.
        /// </summary>
        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;
            _reportingTimer.Dispose();
            ReportMetrics(null);
        }

        /// <summary>
        ///     Records a completed bridge operation under the specified metrics bucket.
        /// </summary>
        /// <param name="operationName">The logical operation name, such as read, write, or subscribe.</param>
        /// <param name="duration">The elapsed time for the operation.</param>
        /// <param name="success">A value indicating whether the operation completed successfully.</param>
        public void RecordOperation(string operationName, TimeSpan duration, bool success = true)
        {
            var metrics = _metrics.GetOrAdd(operationName, _ => new OperationMetrics());
            metrics.Record(duration, success);
        }

        /// <summary>
        ///     Starts timing a bridge operation and returns a disposable scope that records the result when disposed.
        /// </summary>
        /// <param name="operationName">The logical operation name to record.</param>
        /// <returns>A timing scope that reports elapsed time back into this collector.</returns>
        public ITimingScope BeginOperation(string operationName)
        {
            return new TimingScope(this, operationName);
        }

        /// <summary>
        ///     Retrieves the raw metrics bucket for a named operation.
        /// </summary>
        /// <param name="operationName">The logical operation name to look up.</param>
        /// <returns>The metrics bucket when present; otherwise, <see langword="null" />.</returns>
        public OperationMetrics? GetMetrics(string operationName)
        {
            return _metrics.TryGetValue(operationName, out var metrics) ? metrics : null;
        }

        /// <summary>
        ///     Produces a statistics snapshot for all recorded bridge operations.
        /// </summary>
        /// <returns>A dictionary keyed by operation name containing current metrics statistics.</returns>
        public Dictionary<string, MetricsStatistics> GetStatistics()
        {
            var result = new Dictionary<string, MetricsStatistics>(StringComparer.OrdinalIgnoreCase);
            foreach (var kvp in _metrics)
                result[kvp.Key] = kvp.Value.GetStatistics();
            return result;
        }

        private void ReportMetrics(object? state)
        {
            foreach (var kvp in _metrics)
            {
                var stats = kvp.Value.GetStatistics();
                if (stats.TotalCount == 0) continue;

                Logger.Information(
                    "Metrics: {Operation} — Count={Count}, SuccessRate={SuccessRate:P1}, " +
                    "AvgMs={AverageMs:F1}, MinMs={MinMs:F1}, MaxMs={MaxMs:F1}, P95Ms={P95Ms:F1}",
                    kvp.Key, stats.TotalCount, stats.SuccessRate,
                    stats.AverageMilliseconds, stats.MinMilliseconds,
                    stats.MaxMilliseconds, stats.Percentile95Milliseconds);
            }
        }

        /// <summary>
        ///     Timing scope that records one operation result into the owning metrics collector.
        /// </summary>
        private class TimingScope : ITimingScope
        {
            private readonly PerformanceMetrics _metrics;
            private readonly string _operationName;
            private readonly Stopwatch _stopwatch;
            private bool _disposed;
            private bool _success = true;

            /// <summary>
            ///     Initializes a timing scope for a named bridge operation.
            /// </summary>
            /// <param name="metrics">The metrics collector that should receive the result.</param>
            /// <param name="operationName">The logical operation name being timed.</param>
            public TimingScope(PerformanceMetrics metrics, string operationName)
            {
                _metrics = metrics;
                _operationName = operationName;
                _stopwatch = Stopwatch.StartNew();
            }

            /// <summary>
            ///     Marks whether the timed operation should be recorded as successful.
            /// </summary>
            /// <param name="success">A value indicating whether the operation succeeded.</param>
            public void SetSuccess(bool success)
            {
                _success = success;
            }

            /// <summary>
            ///     Stops timing and records the operation result once.
            /// </summary>
            public void Dispose()
            {
                if (_disposed) return;
                _disposed = true;
                _stopwatch.Stop();
                _metrics.RecordOperation(_operationName, _stopwatch.Elapsed, _success);
            }
        }
    }
}