/// <summary>
/// Component responsible for monitoring and managing IOB (Industrial Operation Block) services.
/// 
/// This Blazor component displays real-time status of running processes, provides UI controls
/// for starting/stopping services, and manages auto-restart logic based on configuration and thresholds.
/// 
/// Key Features:
/// - Displays live status of IOB services (running, stopped, ratio, color-coded indicators).
/// - Enables user to open process folders (config, logs, target paths).
/// - Supports dynamic filtering by IOB type.
/// - Implements auto-restart logic triggered when service health degrades.
/// - Integrates with external services (AppControlService, FluxLogManService) via DI.
/// - Handles UI state updates via parameterized events and background scanning.
/// </summary>
using IOB_MAN.Core;
using IOB_MAN.Core.Services;
using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using NLog;
using System.Diagnostics;
using System.Runtime.InteropServices;
using static IOB_MAN.Core.CoreEnum;

namespace IOB_MAN.Components.Compo
{
    public partial class ApplicationCheck : IDisposable
    {
        #region Public Methods

        /// <summary>
        /// Cleans up event subscriptions and resources when the component is disposed.
        /// 
        /// Specifically:
        /// - Unsubscribes from ACService.StatusUpdated event.
        /// </summary>
        public void Dispose()
        {
            ACService.EA_StatusUpdated -= ACService_EA_StatusUpdated;
        }

        #endregion Public Methods

        #region Protected Fields

        /// <summary>
        /// Selected IOB type filter (e.g., "PLC", "SCADA", "HMI").
        /// Used to filter displayed records in the UI.
        /// </summary>
        protected string iobTypeSel = "";

        /// <summary>
        /// List of page sizes available for record pagination (e.g., 5, 10, 20 records per page).
        /// Used in UI for user-controlled pagination.
        /// </summary>
        protected List<int> PageSizeDispl = new List<int>() { 5, 10, 15, 20, 25, 50 };

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// Injected service for managing external applications and service states.
        /// Responsible for opening, closing, and monitoring IOB processes.
        /// </summary>
        [Inject]
        protected AppControlService ACService { get; set; } = null!;

        /// <summary>
        /// Gets or sets whether auto-restart is enabled.
        /// 
        /// Behavior:
        /// - When enabled, triggers automatic restart of closed services.
        /// - When disabled, delays restart until a configurable threshold (VetoAutoCheck) is reached.
        /// - On change, updates service state and forces UI reload.
        /// </summary>
        protected bool AutoRestart
        {
            get => ACService.AutoRestartEnabled;
            set
            {
                if (ACService.AutoRestartEnabled != value)
                {
                    ACService.AutoRestartEnabled = value;
                    if (value)
                    {
                        ACService.DoReopenClosed();
                    }
                    else
                    {
                        countAutoRestart = "0000";
                        ACService.DelayRestart(!value);
                    }
                    currPage = 1;
                    ForceReload();
                }
            }
        }

        /// <summary>
        /// CSS style for context menu (positioned absolutely at mouse coordinates).
        /// Dynamically set based on user right-click position.
        /// </summary>
        protected string contextMenuStyle
        {
            get => $"position: absolute; top: {menuYpx}; left: {menuXpx}; z-index:999;";
        }

        /// <summary>
        /// CSS class for process startup status indicator.
        /// 
        /// Color logic:
        /// - If fewer than configured processes are started → "text-info"
        /// - If <50% of processes are running → "text-danger"
        /// - If 50% to 100% running → "text-warning"
        /// </summary>
        protected string cssCheckProc
        {
            get
            {
                string answ = "text-light";
                if (NumProcStarted < NumProcConfig)
                {
                    answ = "text-info";
                }
                else
                {
                    double ratio = (double)NumProcRunning / NumProcStarted;
                    if (ratio < 0.5)
                    {
                        answ = "text-danger";
                    }
                    else if (ratio < 1)
                    {
                        answ = "text-warning";
                    }
                }
                return answ;
            }
        }

        /// <summary>
        /// CSS class for "active processes" status.
        /// 
        /// Color logic:
        /// - If <50% of started processes are running → "bg-danger"
        /// - If 50% to 100% running → "bg-warning"
        /// - Otherwise → "bg-success"
        /// </summary>
        protected string cssProcAttivi
        {
            get
            {
                string answ = "bg-success bg-opacity-50 px-2";
                double ratio = (double)NumProcRunning / NumProcStarted;
                if (ratio < 0.5 || NumProcStarted == 0)
                {
                    answ = "bg-danger bg-opacity-50 px-2";
                }
                else if (ratio < 1)
                {
                    answ = "bg-warning bg-opacity-50 px-2";
                }
                return answ;
            }
        }

        /// <summary>
        /// CSS class for "started processes" status.
        /// 
        /// Color logic:
        /// - If <50% of configured processes are started → "bg-danger"
        /// - If 50% to 100% started → "bg-warning"
        /// - Otherwise → "bg-success"
        /// </summary>
        protected string cssProcAvviati
        {
            get
            {
                string answ = "bg-success bg-opacity-50 px-2";
                double ratio = (double)NumProcStarted / NumProcConfig;
                if (ratio < 0.5)
                {
                    answ = "bg-danger bg-opacity-50 px-2";
                }
                else if (ratio < 1)
                {
                    answ = "bg-warning bg-opacity-50 px-2";
                }
                return answ;
            }
        }

        /// <summary>
        /// Current list of IOB types (e.g., PLC, SCADA) available in the system.
        /// Retrieved from ACService.
        /// </summary>
        protected List<string> CurrIobType
        {
            get => ACService.CurrIobType;
        }

        /// <summary>
        /// Injected service for managing flux log data and opening log views.
        /// Used to open specific log files or view logs for a selected IOB.
        /// </summary>
        [Inject]
        protected FluxLogManService FLMService { get; set; } = null!;

        /// <summary>
        /// Selected IOB type (user-filtered value).
        /// Updates UI when changed and triggers a reload.
        /// </summary>
        protected string IobTypeSel
        {
            get => iobTypeSel;
            set
            {
                if (iobTypeSel != value)
                {
                    iobTypeSel = value;
                    ForceReload();
                }
            }
        }

        /// <summary>
        /// Injected JS runtime for interacting with browser APIs (e.g., confirm dialogs).
        /// Used for user confirmation before reboot or restart actions.
        /// </summary>
        [Inject]
        protected IJSRuntime JSRuntime { get; set; } = null!;

        /// <summary>
        /// Current logging level (e.g., Debug, Info, Warning).
        /// Controls verbosity of logs in the application.
        /// </summary>
        protected LogLevelIob LogLevel
        {
            get => ACService.LogLevel;
            set => ACService.LogLevel = value;
        }

        /// <summary>
        /// Navigation manager for routing to pages (e.g., About, Settings).
        /// </summary>
        [Inject]
        protected NavigationManager NavMan { get; set; } = null!;

        /// <summary>
        /// Total number of configured IOB processes.
        /// Used to calculate startup and running ratios.
        /// </summary>
        protected int NumProcConfig
        {
            get => ACService.NumProcConfig;
        }

        /// <summary>
        /// Number of IOB processes currently running.
        /// Used in status indicators and health checks.
        /// </summary>
        protected int NumProcRunning
        {
            get => ACService.NumProcRunning;
        }

        /// <summary>
        /// Number of IOB processes that have been started (not necessarily running).
        /// Used in status indicators and auto-restart logic.
        /// </summary>
        protected int NumProcStarted
        {
            get => ACService.NumProcStarted;
        }

        /// <summary>
        /// Total number of configured IOB types.
        /// Used for type-based filtering and UI display.
        /// </summary>
        protected int NumTypeConfig
        {
            get => ACService.NumTypeConfig;
        }

        /// <summary>
        /// Round-trip time (in ms) for communication between components and services.
        /// Used to measure responsiveness and performance.
        /// </summary>
        protected double RoundTrip
        {
            get => ACService.RoundTrip;
        }

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Returns CSS class based on whether a specific IOB is running.
        /// 
        /// Style:
        /// - If not running → "bg-danger bg-opacity-25"
        /// - Otherwise → empty (default background)
        /// </summary>
        /// <param name="currRec">The IOB record to evaluate.</param>
        /// <returns>Appropriate CSS class string.</returns>
        protected string CssClassIob(IobAdapt currRec)
        {
            string css = !currRec.isRunning ? "bg-danger bg-opacity-25" : "";
            return css;
        }

        /// <summary>
        /// Delays a restart request by setting a countdown timer in the UI.
        /// 
        /// Used when auto-restart is disabled to prevent immediate restarts.
        /// </summary>
        protected void DelayRestart()
        {
            ACService.DelayRestart(false);
        }

        /// <summary>
        /// Closes all child IOB processes and refreshes the UI.
        /// 
        /// Actions:
        /// - Stops all running services.
        /// - Triggers a full scan to update state.
        /// - Optionally resets the list of services.
        /// </summary>
        protected async Task DoCloseAll()
        {
            CloseAllChild(false);
            await ACService.DoScan();
            // ForceReload(); // Optional: can be removed if UI refresh is handled elsewhere
        }

        /// <summary>
        /// Closes a specific child IOB process.
        /// 
        /// Action:
        /// - Sends a close command to the service.
        /// - Hides the right-click menu.
        /// </summary>
        /// <param name="currRec">The IOB record to close.</param>
        protected void DoCloseChild(IobAdapt currRec)
        {
            ACService.DoCloseChild(currRec);
            dxMenuVisible = false;
        }

        /// <summary>
        /// Minimizes all IOB process windows to the system tray.
        /// 
        /// Behavior:
        /// - Iterates over all CurrRecords.
        /// - For each process, retrieves its MainWindowHandle and minimizes it.
        /// - Logs any errors (e.g., process already closed).
        /// </summary>
        protected void DoHideAll()
        {
            foreach (var item in CurrRecords)
            {
                try
                {
                    Process p = Process.GetProcessById(item.pID);
                    var windowsHandle = p.MainWindowHandle;
                    ShowWindowAsync(windowsHandle, CoreEnum.SW_SHOWMINIMIZED);
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in HIDE windows:{Environment.NewLine}{exc}");
                }
            }
        }

        /// <summary>
        /// Reboots all IOB processes and optionally reloads configuration.
        /// 
        /// Actions:
        /// - Closes all services.
        /// - If 'reloadConf' is true, re-scans configuration and reloads it.
        /// - Reopens all services.
        /// - Triggers a final scan to update UI.
        /// </summary>
        /// <param name="reloadConf">If true, re-reads configuration after restart.</param>
        protected async Task DoRestartAll(bool reloadConf)
        {
            CloseAllChild(true);
            if (reloadConf)
            {
                await ACService.DoScan();
                ACService.DoReloadConfig();
            }
            ACService.DoOpenAllChild();
            await ACService.DoScan();
        }

        /// <summary>
        /// Restores all IOB process windows to full screen.
        /// 
        /// Behavior:
        /// - Iterates over all CurrRecords.
        /// - For each process, retrieves its MainWindowHandle and restores it.
        /// - Logs any errors (e.g., process already closed).
        /// </summary>
        protected void DoShowAll()
        {
            foreach (var item in CurrRecords)
            {
                try
                {
                    Process p = Process.GetProcessById(item.pID);
                    var windowsHandle = p.MainWindowHandle;
                    ShowWindowAsync(windowsHandle, CoreEnum.SW_SHOWNORMAL);
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in SHOW windows:{Environment.NewLine}{exc}");
                }
            }
        }

        /// <summary>
        /// Restores a specific IOB process window.
        /// 
        /// Action:
        /// - Finds the process by ID and restores it to normal view.
        /// </summary>
        /// <param name="item">The IOB record to restore.</param>
        protected void DoShowChild(IobAdapt item)
        {
            try
            {
                Process p = Process.GetProcessById(item.pID);
                var windowsHandle = p.MainWindowHandle;
                ShowWindowAsync(windowsHandle, CoreEnum.SW_SHOWNORMAL);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in SHOW windows:{Environment.NewLine}{exc}");
            }
        }

        /// <summary>
        /// Starts a specific IOB process.
        /// 
        /// Action:
        /// - Sends a command to ACService to open and start the selected IOB.
        /// - Hides the right-click menu.
        /// </summary>
        /// <param name="currRec">The IOB record to start.</param>
        protected void DoStartChild(IobAdapt currRec)
        {
            ACService.DoOpenChildSel(currRec);
            dxMenuVisible = false;
        }

        /// <summary>
        /// Forces a full scan of all IOB services and updates UI state.
        /// 
        /// Actions:
        /// - Sets isLoading to true.
        /// - Clears current records.
        /// - Calls DoScan() to refresh service list.
        /// - Updates filtered list based on current filters (e.g., IOB type).
        /// - Applies pagination.
        /// - Sets isLoading to false and triggers UI update.
        /// </summary>
        protected async Task ForceCheck()
        {
            isLoading = true;
            ListRecords = new List<IobAdapt>();
            await ACService.DoScan();
            isLoading = false;
        }

        /// <summary>
        /// Initializes the component.
        /// 
        /// Action:
        /// - Subscribes to ACService.StatusUpdated event to update UI on status changes.
        /// </summary>
        protected override void OnInitialized()
        {
            ACService.EA_StatusUpdated += ACService_EA_StatusUpdated;
        }

        /// <summary>
        /// Called when parameters change (e.g., user selects a new IOB type).
        /// 
        /// Actions:
        /// - Triggers a full scan of services.
        /// - Updates the UI with filtered records.
        /// </summary>
        protected override async Task OnParametersSetAsync()
        {
            await ACService.DoScan();
            ForceReload();
        }

        /// <summary>
        /// Updates the number of records per page (e.g., from 10 to 20).
        /// 
        /// Behavior:
        /// - Updates the page count and triggers a reload to refresh the UI.
        /// </summary>
        /// <param name="newNum">New number of records per page.</param>
        protected void SetNumRec(int newNum)
        {
            numRecord = newNum;
            currPage = 1;
            ForceReload();
        }

        /// <summary>
        /// Updates the current page (e.g., page 2, 3, etc.).
        /// 
        /// Behavior:
        /// - Updates the page number and triggers a reload to refresh the UI.
        /// </summary>
        /// <param name="newNum">New page number.</param>
        protected void SetPage(int newNum)
        {
            currPage = newNum;
            ForceReload();
        }

        #endregion Protected Methods

        #region Private Fields

        /// <summary>
        /// Logger instance for structured logging within this component.
        /// </summary>
        private static Logger Log = LogManager.GetCurrentClassLogger();

        /// <summary>
        /// Timestamp of last UI render to prevent rapid re-renders.
        /// Prevents excessive updates when data changes quickly.
        /// </summary>
        private DateTime _lastRender = DateTime.MinValue;

        /// <summary>
        /// Auto-restart countdown (in seconds) displayed in UI.
        /// Shows time remaining before auto-restart is triggered.
        /// </summary>
        private string countAutoRestart = "";

        /// <summary>
        /// Flag indicating whether the right-click menu is visible.
        /// Used for UI state management.
        /// </summary>
        private bool dxMenuVisible = false;

        /// <summary>
        /// Flag controlling whether task killing is allowed (e.g., for safety).
        /// </summary>
        private bool enableKillTask = true;

        /// <summary>
        /// X-coordinate for context menu positioning (in pixels).
        /// Set dynamically on right-click.
        /// </summary>
        private string menuXpx = "0px";

        /// <summary>
        /// Y-coordinate for context menu positioning (in pixels).
        /// Set dynamically on right-click.
        /// </summary>
        private string menuYpx = "0px";

        /// <summary>
        /// Currently selected IOB record (used for actions like opening folders).
        /// </summary>
        private IobAdapt? selIOB = null;

        #endregion Private Fields

        #region Private Properties

        /// <summary>
        /// Current computer name (e.g., "DESKTOP-ABC123").
        /// </summary>
        private string ComputerName
        {
            get => Environment.MachineName;
        }

        /// <summary>
        /// CSS class for "Close All" button.
        /// 
        /// Behavior:
        /// - Enabled only if at least one service is currently running.
        /// - Disabled otherwise (grayed out).
        /// </summary>
        private string cssBtnCloseAll
        {
            get => NumProcStarted > 0 ? "" : "disabled opacity-50";
        }

        /// <summary>
        /// Current page number (1-indexed).
        /// </summary>
        private int currPage { get; set; } = 1;

        /// <summary>
        /// Current list of IOB service records (e.g., PLC, HMI).
        /// Retrieved from ACService and used for UI display.
        /// </summary>
        private List<IobAdapt> CurrRecords
        {
            get => ACService.ListIobAdapters;
        }

        /// <summary>
        /// User domain (e.g., "DOMAIN\\username").
        /// </summary>
        private string DomainName
        {
            get => Environment.UserDomainName;
        }

        /// <summary>
        /// Indicates whether the UI is loading (used for spinner or placeholder state).
        /// </summary>
        private bool isLoading { get; set; } = false;

        /// <summary>
        /// Paginated list of records currently displayed in the UI.
        /// Filtered and paginated based on IOB type and page size.
        /// </summary>
        private List<IobAdapt>? ListRecords { get; set; } = null;

        /// <summary>
        /// Number of records per page (e.g., 10, 20).
        /// </summary>
        private int numRecord { get; set; } = 10;

        /// <summary>
        /// Target path for a selected IOB (e.g., C:\IOB\PLC\001).
        /// Built dynamically from CodIOB and ACService.
        /// </summary>
        private string selIobTgtPath
        {
            get
            {
                string answ = selIOB != null ? ACService.IobTgtPath(selIOB.CodIOB) : "";
                return answ;
            }
        }

        /// <summary>
        /// Total number of records (used for pagination and UI display).
        /// </summary>
        private int totalCount { get; set; } = 0;

        /// <summary>
        /// Current user name (e.g., "JohnDoe").
        /// </summary>
        private string UserName
        {
            get => Environment.UserName;
        }

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Windows API: Shows a window with a specified style (e.g., minimized, normal).
        /// Used to minimize or restore IOB process windows.
        /// </summary>
        /// <param name="hWnd">Handle to the window.</param>
        /// <param name="nCmdShow">Style (e.g., SW_SHOWMINIMIZED, SW_SHOWNORMAL).</param>
        [DllImport("user32.dll")]
        private static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);

        /// <summary>
        /// Handles status updates from ACService.
        /// 
        /// Logic:
        /// - If auto-restart is disabled, shows countdown until auto-restart is triggered.
        /// - When countdown reaches zero, enables auto-restart.
        /// - Forces UI reload to reflect new state.
        /// </summary>
        private void ACService_EA_StatusUpdated()
        {
            if (!AutoRestart)
            {
                var remSec = (int)ACService.VetoAutoCheck.Subtract(DateTime.Now).TotalSeconds;
                countAutoRestart = remSec > 0 ? $"{remSec:N0}" : "!!!";
                if (remSec <= 0)
                {
                    AutoRestart = true;
                }
            }
            ForceReload();
        }

        /// <summary>
        /// Closes all child IOB processes.
        /// 
        /// Parameters:
        /// - doReset: if true, resets the internal list of services.
        /// </summary>
        /// <param name="doReset">Whether to reset the service list after closing.</param>
        private void CloseAllChild(bool doReset)
        {
            enableKillTask = false;
            ACService.DoCloseAll(doReset);
            enableKillTask = true;
        }

        /// <summary>
        /// Triggers a reboot request with user confirmation.
        /// 
        /// Behavior:
        /// - Uses JSRuntime to show a confirmation dialog.
        /// - If confirmed, raises a reboot request to ACService.
        /// </summary>
        /// <param name="args">Mouse event arguments (used for context menu).</param>
        private async Task ForceReboot(Microsoft.AspNetCore.Components.Web.MouseEventArgs args)
        {
            if (!await JSRuntime.InvokeAsync<bool>("confirm", "Sicuro di voler riavviare il programma?"))
                return;

            ACService.RaiseRebootReq();
        }

        /// <summary>
        /// Forces a UI reload with current filters and pagination.
        /// 
        /// Behavior:
        /// - Skips if too soon (less than 1 second since last render).
        /// - Updates filtered list based on IOB type.
        /// - Applies pagination.
        /// - Updates UI state and triggers re-render.
        /// </summary>
        private void ForceReload()
        {
            if ((DateTime.Now - _lastRender).TotalSeconds < 1)
                return;

            _lastRender = DateTime.Now;
            isLoading = true;
            var filtered = CurrRecords;
            if (!string.IsNullOrEmpty(IobTypeSel))
                filtered = filtered.Where(x => x.TgtName == IobTypeSel).ToList();

            totalCount = filtered.Count();
            ListRecords = filtered
                .OrderBy(x => x.CodIOB)
                .Skip(numRecord * (currPage - 1))
                .Take(numRecord)
                .ToList();
            isLoading = false;
            _ = InvokeAsync(StateHasChanged);
        }

        /// <summary>
        /// Opens the target folder of the selected IOB (e.g., for configuration).
        /// </summary>
        private void IobFolderOpenApp()
        {
            if (selIOB != null)
                Process.Start("explorer.exe", selIobTgtPath);

            selIOB = null;
            dxMenuVisible = false;
        }

        /// <summary>
        /// Opens the configuration folder of the selected IOB.
        /// </summary>
        private void IobFolderOpenConf()
        {
            if (selIOB != null)
                Process.Start("explorer.exe", Path.Combine(selIobTgtPath, "DATA", "CONF"));

            selIOB = null;
            dxMenuVisible = false;
        }

        /// <summary>
        /// Opens the logs folder of the selected IOB.
        /// </summary>
        private void IobFolderOpenLog()
        {
            if (selIOB != null)
                Process.Start("explorer.exe", Path.Combine(selIobTgtPath, "logs", selIOB.CodIOB));

            selIOB = null;
            dxMenuVisible = false;
        }

        /// <summary>
        /// Navigates to the "About" page.
        /// </summary>
        private void NavAbout()
        {
            NavMan.NavigateTo("About");
        }

        /// <summary>
        /// Opens a FluxLog view for the selected IOB.
        /// </summary>
        private void OpenFLForm()
        {
            if (selIOB != null)
                FLMService.RequestLoadFLogData(selIOB.CodIOB);

            selIOB = null;
            dxMenuVisible = false;
        }

        /// <summary>
        /// Handles right-click event on an IOB record.
        /// 
        /// Behavior:
        /// - Sets selected IOB.
        /// - Shows context menu at mouse position.
        /// </summary>
        /// <param name="e">Mouse event arguments.</param>
        /// <param name="currRec">The IOB record being right-clicked.</param>
        private void RightClick(Microsoft.AspNetCore.Components.Web.MouseEventArgs e, IobAdapt currRec)
        {
            selIOB = currRec;
            if (e.Button == 2)
            {
                dxMenuVisible = true;
                menuXpx = $"{e.ClientX}px";
                menuYpx = $"{e.ClientY - 90}px";
            }
        }

        #endregion Private Methods
    }
}