FACULTATE-LICENTA/User/src/helpers/worker_manager.ts

import { Worker } from 'worker_threads';
import path from 'path';
import {WindowManager} from "./window_manager";

export class WorkerManager {
    private readonly pathToWorkerDir: string;
    private windowManager: WindowManager
    private workers: Worker[]; // Array to store running workers

    constructor(pathToWorkerDir: string, windowManager: WindowManager) {
        this.pathToWorkerDir = pathToWorkerDir;
        this.windowManager = windowManager;
        this.workers = []; // Initialize the array to store workers
    }

    async startNetworkScannerWorker(udpPort: number, tcpPort: number, okPage: string, errorPage: string, databaseResetPage: string, userConfigPath: string, applicationInfoPath: string): Promise<void> {
        return new Promise((resolve, reject) => {
            const worker = new Worker(path.join(this.pathToWorkerDir, 'network_scanner_worker.js'), {
                workerData: { udpPort, tcpPort, okPage, errorPage, databaseResetPage, userConfigPath, applicationInfoPath }, // Pass necessary data to the worker
            });

            this.workers.push(worker); // Store the worker reference

            worker.on('message', (data) => {
                console.log(data);
                if (data.type === 'changeContent') {
                    this.windowManager.changeContent(data.page);
                }
            });

            worker.on('error', (err) => {
                console.error('Network Scanner Worker error:', err);
                worker.terminate();
                this.removeWorker(worker);
                reject(err); // Reject the promise if there's an error
            });

            worker.on('exit', (code) => {
                console.log(`Network Scanner Worker exited with code ${code}`);
                this.removeWorker(worker); // Remove worker reference when it exits
                resolve(); // Resolve when the worker exits cleanly
            });
        });
    }

    // Start the Connection Pool Worker
    async startDirectoriesWatchersWorker(memoryManagerPath: string, applicationInfoPath: string): Promise<void> {
        return new Promise((resolve, reject) => {
            const worker = new Worker(path.join(this.pathToWorkerDir, 'directories_watcher_worker.js'), {
                workerData: { memoryManagerPath, applicationInfoPath },  // Pass the port to the worker
            });

            this.workers.push(worker); // Store the worker reference

            worker.on('message', (data) => {
                console.log('Connection Pool Worker message:', data);
            });

            worker.on('error', (err) => {
                console.error('Connection Pool Worker error:', err);
                worker.terminate();
                this.removeWorker(worker);
                reject(err); // Reject the promise if there's an error
            });

            worker.on('exit', (code) => {
                console.log(`Connection Pool Worker exited with code ${code}`);
                this.removeWorker(worker); // Remove worker reference when it exits
                resolve(); // Resolve when the worker exits cleanly
            });
        });
    }

    // Start the Servers Worker (UDP and TCP servers)
    async startServersWorker(host: string, udpPort: number, tcpPort: number): Promise<void> {
        return new Promise((resolve, reject) => {
            const worker = new Worker(path.join(this.pathToWorkerDir, 'servers_worker.js'), {
                workerData: { HOST: host, USER_UDP_PORT: udpPort, USER_TCP_PORT: tcpPort },  // Pass host and ports to the worker
            });

            this.workers.push(worker); // Store the worker reference

            worker.on('message', (data) => {
                console.log('Servers Worker message:', data);
            });

            worker.on('error', (err) => {
                console.error('Servers Worker error:', err);
                worker.terminate();
                this.removeWorker(worker);
                reject(err); // Reject the promise if there's an error
            });

            worker.on('exit', (code) => {
                console.log(`Servers Worker exited with code ${code}`);
                this.removeWorker(worker); // Remove worker reference when it exits
                resolve(); // Resolve when the worker exits cleanly
            });
        });
    }

    // Start the Users Info Worker
    async startResourceCoordinatorWorker(usersConfigPath: string, applicationInfoPath: string, memoryManagerPath: string, queueManagerPath: string, tcpPort: number): Promise<void> {
        return new Promise((resolve, reject) => {
            const worker = new Worker(path.join(this.pathToWorkerDir, 'resource_coordinator_worker.js'), {
                workerData: {
                    usersConfigPath,
                    applicationInfoPath,
                    memoryManagerPath,
                    queueManagerPath,
                    tcpPort
                }, // Pass necessary parameters to the worker
            });

            this.workers.push(worker); // Store the worker reference

            worker.on('message', (data) => {
                console.log('Users Info Worker message:', data);
            });

            worker.on('error', (err) => {
                console.error('Users Info Worker error:', err);
                worker.terminate();
                this.removeWorker(worker);
                reject(err); // Reject the promise if there's an error
            });

            worker.on('exit', (code) => {
                console.log(`Users Info Worker exited with code ${code}`);
                this.removeWorker(worker); // Remove worker reference when it exits
                resolve(); // Resolve when the worker exits cleanly
            });
        });
    }

    // Start the Backup Retrieval Worker
    async startBackupRetrievalWorker(
        userConfigPath: string,
        applicationInfoPath: string,
        clientPort: number,
        destinationPath: string
    ): Promise<void> {
        return new Promise(async (resolve, reject) => {
            const worker = new Worker(path.join(this.pathToWorkerDir, 'backup_retrieval_worker.js'), {
                workerData: { userConfigPath, applicationInfoPath, clientPort, destinationPath },  // Pass parameters to the worker
            });

            this.workers.push(worker); // Store the worker reference

            worker.on('message', async (data) => {
                console.log('Backup Retrieval Worker message:', data);
                await new Promise((resolve) => setTimeout(resolve, 3000)); // Wait for 1 second
                await this.windowManager.changeContent('main_menu');
                await this.windowManager.showAlert(data.message);
            });

            worker.on('error', (err) => {
                console.error('Backup Retrieval Worker error:', err);
                worker.terminate();
                this.removeWorker(worker);
                reject(err); // Reject the promise if there's an error
            });

            worker.on('exit', (code) => {
                console.log(`Backup Retrieval Worker exited with code ${code}`);
                this.removeWorker(worker); // Remove worker reference when it exits
                resolve(); // Resolve when the worker exits cleanly
            });
        });
    }

    // Close all running workers
    closeAllWorkers(): void {
        console.log('Terminating all running workers...');
        this.workers.forEach(worker => worker.terminate()); // Terminate each worker
        this.workers = []; // Clear the array after terminating all workers
    }

    // Helper method to remove a worker from the workers array when it exits
    private removeWorker(worker: Worker): void {
        const index = this.workers.indexOf(worker);
        if (index > -1) {
            this.workers.splice(index, 1); // Remove the worker from the array
        }
    }
}