import { ChildProcess, fork } from 'child_process';
import config from '../config';

const { requestLimit } = config;

interface forkResponse {
    kill: boolean;
    string?: string;
}

interface Params {
    req: {
        url: string;
        cookies: object;
    };
    res: object;
}

class ForkBalancer {
    path: string;
    forks: number;
    maxRAM?: number;
    args?: Array<string>;

    private activeFork: number;
    private resolvers = new Map();
    private renderers: Array<ChildProcess>;

    constructor({ path = '', forks = 2, maxRAM = 250, args = [] }) {
        this.activeFork = 0;
        this.forks = forks;
        this.maxRAM = maxRAM;
        this.path = path;
        this.args = args;
        this.renderers = Array.from({ length: forks }, () => this.createFork());
    }

    public getFromRenderer(params: Params): Promise<forkResponse> {
        const { resolvers, maxRAM, activeFork, restartFork, renderers } = this;
        const renderer = renderers[activeFork];

        return new Promise(function(resolve, reject) {
            try {
                renderer.once('message', res => {
                    resolvers.delete(params.req.url);
                    resolve(res);

                    if (res.kill) restartFork();
                });

                if (!resolvers.has(params.req.url)) {
                    renderer.setMaxListeners(requestLimit);
                    resolvers.set(params.req.url, resolve);
                    renderer.send({ ...params, maxRAM });
                }
            } catch (error) {
                resolvers.delete(params.req.url);
                reject(error);
            }
        });
    }

    private createFork = () => {
        const { path, args } = this;
        return fork(path, args);
    };

    private restartFork = () => {
        const { activeFork, renderers, next, createFork } = this;
        const renderer = renderers[activeFork];
        next();
        renderer.kill();
        this.renderers[activeFork] = createFork();
    };

    private next = () => {
        const { activeFork, forks } = this;
        if (activeFork === forks - 1) {
            this.activeFork = 0;
        } else {
            this.activeFork++;
        }
    };
}

export default ForkBalancer;