import { EmployeePositions } from "./EmployeePositions";
import { CorporationConstants } from "./data/Constants";
import { getRandomInt } from "../../utils/helpers/getRandomInt";
import { generateRandomString } from "../../utils/StringHelperFunctions";
import { Generic_fromJSON, Generic_toJSON, Reviver } from "../../utils/JSONReviver";
import { Employee } from "./Employee";
import { IIndustry } from "./IIndustry";
import { ICorporation } from './ICorporation';

interface IParams {
    loc?: string;
    cost?: number;
    size?: number;
    comfort?: number;
    beauty?: number;
}

export class OfficeSpace {
    loc: string;
    cost: number;
    size: number;
    comf: number;
    beau: number;
    tier = "Basic";
    minEne = 0;
    maxEne = 100;
    minHap = 0;
    maxHap = 100;
    maxMor = 100;
    employees: Employee[] = [];
    employeeProd: {[key: string]: number} = {
        [EmployeePositions.Operations]:   0,
        [EmployeePositions.Engineer]:     0,
        [EmployeePositions.Business]:     0,
        [EmployeePositions.Management]:   0,
        [EmployeePositions.RandD]:        0,
        total:                            0,
    };

    constructor(params: IParams = {}) {
        this.loc    = params.loc        ? params.loc        : "";
        this.cost   = params.cost       ? params.cost       : 1;
        this.size   = params.size       ? params.size       : 1;
        this.comf   = params.comfort    ? params.comfort    : 1;
        this.beau   = params.beauty      ? params.beauty     : 1;
    }


    atCapacity(): boolean {
        return (this.employees.length) >= this.size;
    }

    process(marketCycles = 1, corporation: ICorporation, industry: IIndustry): number {
        // HRBuddy AutoRecruitment and training
        if (industry.hasResearch("HRBuddy-Recruitment") && !this.atCapacity()) {
            const emp = this.hireRandomEmployee();
            if (industry.hasResearch("HRBuddy-Training") && emp !== undefined) {
                emp.pos = EmployeePositions.Training;
            }
        }

        // Process Office properties
        this.maxEne = 100;
        this.maxHap = 100;
        this.maxMor = 100;
        if (industry.hasResearch("Go-Juice")) {
            this.maxEne += 10;
        }
        if (industry.hasResearch("JoyWire")) {
            this.maxHap += 10;
        }
        if (industry.hasResearch("Sti.mu")) {
            this.maxMor += 10;
        }

        // Calculate changes in Morale/Happiness/Energy for Employees
        let perfMult=1; //Multiplier for employee morale/happiness/energy based on company performance
        if (corporation.funds < 0 && industry.lastCycleRevenue < 0) {
            perfMult = Math.pow(0.99, marketCycles);
        } else if (corporation.funds > 0 && industry.lastCycleRevenue > 0) {
            perfMult = Math.pow(1.01, marketCycles);
        }

        const hasAutobrew = industry.hasResearch("AutoBrew");
        const hasAutoparty = industry.hasResearch("AutoPartyManager");

        let salaryPaid = 0;
        for (let i = 0; i < this.employees.length; ++i) {
            const emp = this.employees[i];
            if (hasAutoparty) {
                emp.mor = this.maxMor;
                emp.hap = this.maxHap;
            } else {
                emp.mor *= perfMult;
                emp.hap *= perfMult;
                emp.mor = Math.min(emp.mor, this.maxMor);
                emp.hap = Math.min(emp.hap, this.maxHap);
            }

            if (hasAutobrew) {
                emp.ene = this.maxEne;
            } else {
                emp.ene *= perfMult;
                emp.ene = Math.min(emp.ene, this.maxEne);
            }

            const salary = emp.process(marketCycles, this);
            salaryPaid += salary;
        }

        this.calculateEmployeeProductivity(corporation, industry);
        return salaryPaid;
    }

    calculateEmployeeProductivity(corporation: ICorporation, industry: IIndustry): void {
        //Reset
        for (const name in this.employeeProd) {
            this.employeeProd[name] = 0;
        }

        let total = 0;
        for (let i = 0; i < this.employees.length; ++i) {
            const employee = this.employees[i];
            const prod = employee.calculateProductivity(corporation, industry);
            this.employeeProd[employee.pos] += prod;
            total += prod;
        }
        this.employeeProd.total = total;
    }

    hireRandomEmployee(): Employee | undefined {
        if (this.atCapacity()) return;
        if (document.getElementById("cmpy-mgmt-hire-employee-popup") != null) return;

        //Generate three random employees (meh, decent, amazing)
        const mult = getRandomInt(76, 100)/100;
        const int = getRandomInt(50, 100),
            cha = getRandomInt(50, 100),
            exp = getRandomInt(50, 100),
            cre = getRandomInt(50, 100),
            eff = getRandomInt(50, 100),
            sal = CorporationConstants.EmployeeSalaryMultiplier * (int + cha + exp + cre + eff);

        const emp = new Employee({
            intelligence: int * mult,
            charisma: cha * mult,
            experience: exp * mult,
            creativity: cre * mult,
            efficiency: eff * mult,
            salary: sal * mult,
        });

        const name = generateRandomString(7);

        for (let i = 0; i < this.employees.length; ++i) {
            if (this.employees[i].name === name) {
                return this.hireRandomEmployee();
            }
        }
        emp.name = name;
        this.employees.push(emp);

        return emp;
    }

    //Finds the first unassigned employee and assigns its to the specified job
    assignEmployeeToJob(job: string): boolean {
        for (let i = 0; i < this.employees.length; ++i) {
            if (this.employees[i].pos === EmployeePositions.Unassigned) {
                this.employees[i].pos = job;
                return true;
            }
        }
        return false;
    }

    //Finds the first employee with the given job and unassigns it
    unassignEmployeeFromJob(job: string): boolean {
        for (let i = 0; i < this.employees.length; ++i) {
            if (this.employees[i].pos === job) {
                this.employees[i].pos = EmployeePositions.Unassigned;
                return true;
            }
        }
        return false;
    }

    toJSON(): any {
        return Generic_toJSON("OfficeSpace", this);
    }

    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
    static fromJSON(value: any): OfficeSpace {
        return Generic_fromJSON(OfficeSpace, value.data);
    }
}

Reviver.constructors.OfficeSpace = OfficeSpace;