// Author: Gockner, Simon
// Created: 2021-04-23
// Copyright(c) 2021 SimonG. All Rights Reserved.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using Lib.ProcessManaging.Factories;
using Lib.ProcessManaging.Interfaces;

namespace Lib.ProcessManaging
{
    public class ProcessManager : IProcessManager
    {
        private readonly IObservedProcessFactory _observedProcessFactory;
        private readonly CancellationTokenSource _cancellationTokenSource;

        private readonly object _processesLock = new();
        
        private Thread? _monitorThread;

        public ProcessManager(IObservedProcessFactory observedProcessFactory)
        {
            _observedProcessFactory = observedProcessFactory;
            _cancellationTokenSource = new CancellationTokenSource();
            
            Processes = new List<IObservedProcess>();
        }

        public List<IObservedProcess> Processes { get; }
        
        public void Initialize()
        {
            _monitorThread = new Thread(Monitor)
            {
                Name = "Process Monitor", 
                IsBackground = true
            };
            
            _monitorThread.Start();
        }

        public IObservedProcess? GetProcessById(int id)
        {
            lock (_processesLock)
                return Processes.FirstOrDefault(p => p.Id == id);
        }

        private void Monitor()
        {
            while (!_cancellationTokenSource.IsCancellationRequested)
            {
                lock (_processesLock)
                {
                    IEnumerable<Process> processes = Process.GetProcesses();
                    foreach (var process in processes)
                    {
                        if (Processes.Any(p => p.EqualsProcess(process)))
                            continue;

                        IObservedProcess observedProcess = _observedProcessFactory.Create(process);
                        if (string.IsNullOrEmpty(observedProcess.FileName))
                            continue;

                        Processes.Add(observedProcess);
                        ProcessStarted?.Invoke(this, observedProcess);
                    }

                    foreach (var observedProcess in Processes.ToList().Where(p => !processes.Any(p.EqualsProcess)))
                    {
                        Processes.Remove(observedProcess);
                        ProcessExited?.Invoke(this, observedProcess);
                    }
                }

                Thread.Sleep(1000);
            }
        }

        public event EventHandler<IObservedProcess>? ProcessStarted;
        public event EventHandler<IObservedProcess>? ProcessExited;
        
        public void Dispose()
        {
            _cancellationTokenSource.Cancel();
            _cancellationTokenSource.Dispose();
            _monitorThread = null;
            
            lock (_processesLock) 
                Processes.Clear();
        }
    }
}