export class LazyGuy {
    constructor(components) {
        this.components = components;
        this.leftOverComponents = [];

        this.environment = {
            maxPageSize: 1016,
            marginOfComfort: 10
        };

    }


    /**
     *  Creates a generation of possible page options
     *
     *  @param {number} individuals - Number of individuals in generation
     */

    createGeneration(individuals) {
        let generation = [];

        for (let i = 0; i < individuals; i++){
            generation.push( this.getPage(this.components.slice(0)) );
        }

        return generation;
    }


    /**
     *  Get the fitness of an entire generation
     *
     *  @param {Object[]} generation - Generation to get the fitness for
     */

    generationFitness(generation) {
        let summed = generation.reduce((prev, current) => {
            return this.pageFitness(prev) + this.pageFitness(current);
        }, 0);

        return summed / generation.length;
    }


    /**
     *  Creates a page full of components
     *
     *  @param {number[]} components - Components to create a page from
     */

    getPage(components) {
        let page = { size: 0, parts: [] },
            comfortablePageSize = this.environment.maxPageSize - this.environment.marginOfComfort;

        while (page.size < comfortablePageSize && components.length > 0){
            let randomComponent = this.getRandomComponent(components);
            page.parts.push(randomComponent.part);
            page.size += randomComponent.part;

            components.splice(randomComponent.index, 1);
        }

        return page;
    }


    /**
     *  Get the fitness of a page
     *
     *  @param {number} size - Page size to get fitness for
     */

    pageFitness(size) {
        return Math.abs(this.environment.maxPageSize - size);
    }


    /**
     *  Get a random component from list
     *
     *  @param {number[]} components - Components to choose from
     */

    getRandomComponent(components) {
        let max = components.length,
            randomIndex = Math.floor(Math.random() * (max - 1));

        return { index: randomIndex, part: components[randomIndex] };
    }


    /**
     *  Generates a population from the genetically inferior members
     *  of the generation based on a small chance
     *
     *  @param {Object[]} inferiorIndividuals - The "losing" end of the current generation
     *  @param {number} inferiorityRetention - Number of probability to decide inclusion
     */

    inferiorPopulation(inferiorIndividuals, inferiorityRetention) {
        let inferiors = [];

        for (let individual of inferiorIndividuals){
            if (inferiorityRetention > Math.random()){
                inferiors.push(individual);
            }
        }

        return inferiors;
    }
}