using Newtonsoft.Json;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IOB_MAN.Core
{
    /// <summary>
    /// Classe TaskRunStats gestisce le statistiche di esecuzione dei task.
    /// Memorizza e calcola i tempi medi, il numero di esecuzioni e le dimensioni dei dati.
    /// Supporta il salvataggio delle statistiche su disco e il caricamento da file esistenti.
    /// </summary>
    public class TaskRunStats
    {
        #region Public Constructors

        /// <summary>
        /// Inizializza una nuova istanza della classe con dati vuoti.
        /// Utilizzato quando non è necessario caricare dati da file.
        /// </summary>
        public TaskRunStats()
        {
            // Inizializzazione generica senza rilettura dei dati dal disco
        }

        /// <summary>

        /// Inizializza una nuova istanza della classe con rilettura dei dati dal disco.
        /// Carica eventuali statistiche memorizzate in un file di configurazione.
        /// </summary>
        /// <param name="appDir">Directory dell'applicazione dove si trova il file di configurazione.</param>
        /// <param name="confName">Nome del file di configurazione da cui caricare i dati.</param>
        public TaskRunStats(string appDir, string confName)
        {
            AppDir = appDir;
            ConfName = confName;

            // Inizia il caricamento dei dati dal disco (se presenti)
            tryReload();
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// Tempo medio complessivo registrato per tutti i task.
        /// Calcolato sommando i tempi medi di ogni singolo task.
        /// </summary>
        public TimeSpan AvgTotalTime
        {
            get
            {
                TimeSpan answ = new TimeSpan();
                if (TaskData != null && TaskData.Count > 0)
                {
                    foreach (var record in TaskData)
                    {
                        answ += record.Value.AvgTime;
                    }
                }
                return answ;
            }
        }

        /// <summary>

        /// Numero totale di statistiche memorizzate per i task.
        /// Rappresenta il conteggio dei record presenti nel dizionario.
        /// </summary>
        public int NumItems
        {
            get
            {
                return TaskData.Count;
            }
        }

        /// <summary>

        /// Dimensione massima delle statistiche memorizzate per un task.
        /// Indica il numero massimo di esecuzioni registrate per un singolo task.
        /// </summary>
        public long SampleSizeMax
        {
            get
            {
                return TaskData.Max(x => x.Value.NumRun);
            }
        }

        /// <summary>

        /// Dizionario che contiene le statistiche per ogni task registrato.
        /// Ogni chiave rappresenta il nome del task, ogni valore contiene le informazioni di esecuzione.
        /// </summary>
        public Dictionary<string, TaskStat> TaskData { get; set; } = new Dictionary<string, TaskStat>();

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Calcola il tempo medio per un task specifico.
        /// </summary>
        /// <param name="taskName">Nome del task per cui si desidera calcolare il tempo medio.</param>
        /// <returns>Tempo medio per il task specificato.</returns>
        public TimeSpan AvgTaskTime(string taskName)
        {
            TimeSpan answ = new TimeSpan();
            if (TaskData != null && TaskData.Count > 0)
            {
                if (TaskData.ContainsKey(taskName))
                {
                    answ = TaskData[taskName].AvgTime;
                }
            }
            return answ;
        }

        /// <summary>

        /// Resetta tutte le statistiche e le azzera.
        /// </summary>
        public void ForceReset()
        {
            TaskData = new Dictionary<string, TaskStat>();
        }

        /// <summary>

        /// Registra i dati di un'operazione di esecuzione per un task specifico.
        /// Aggiorna i dati esistenti o crea un nuovo record se il task non è già presente.
        /// </summary>

        /// <param name="taskName">Nome del task che viene eseguito.</param>
        /// <param name="duration">Durata dell'esecuzione in unità di tempo.</param>
        public void RecordExeData(string taskName, TimeSpan duration)
        {
            // Cerca nel dizionario se il task è già presente
            if (TaskData.ContainsKey(taskName))
            {
                TaskData[taskName].NumRun++;
                TaskData[taskName].TotalTime += duration;
            }
            else
            {
                TaskData.Add(taskName, new TaskStat() { NumRun = 1, TotalTime = duration });
            }
        }

        /// <summary>

        /// Salva le statistiche memorizzate sul disco in un file JSON.
        /// </summary>
        public void SaveToDisk()
        {
            var rawData = JsonConvert.SerializeObject(TaskData, Formatting.Indented);
            if (rawData != null && rawData.Length > 2)
            {
                File.WriteAllText(StatsPath, rawData);
            }
        }

        #endregion Public Methods

        #region Private Fields

        /// <summary>
        /// Oggetto logger per il rilevamento degli eventi e degli errori.
        /// </summary>
        private static Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

        #region Private Properties

        /// <summary>
        /// Directory dell'applicazione dove si trova il file di configurazione.
        /// </summary>
        private string AppDir { get; set; } = "";

        /// <summary>
        /// Nome del file di configurazione da cui caricare i dati.
        /// </summary>
        private string ConfName { get; set; } = "";

        /// <summary>

        /// Percorso del file di statistiche su disco.
        /// Generato dinamicamente con Path.Combine(AppDir, ConfName).
        /// </summary>
        private string StatsPath
        {
            get => Path.Combine(AppDir, ConfName);
        }

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Tenta il caricamento dei dati dal file di configurazione.
        /// Se il file esiste, lo legge e lo deserializza in un dizionario.
        /// Gestisce eventuali eccezioni di deserializzazione.
        /// </summary>
        private void tryReload()
        {
            if (File.Exists(StatsPath))
            {
                string rawData = File.ReadAllText(StatsPath);
                if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
                {
                    try
                    {
                        TaskData = JsonConvert.DeserializeObject<Dictionary<string, TaskStat>>(rawData) ?? new Dictionary<string, TaskStat>();
                    }
                    catch (Exception exc)
                    {
                        Log.Error($"Eccezione in tryReload:{Environment.NewLine}{exc}");
                    }
                }
            }
        }

        #endregion Private Methods
    }
}