describe("filmStudio", function () {
    let testClass;
    let fakeClass;
    describe("Class Initialization With Right Params", function () {
        it("should initialize properly", function () {
            testClass = new FilmStudio("FOX");
            fakeClass = new exploit("FOX");
            assert.deepEqual(testClass, fakeClass);
        })
    });
    describe("Make Movie", function () {
        beforeEach(function () {
            testClass = new FilmStudio("FOX");
            fakeClass = new exploit("FOX");
        });
        it("should make one movie", function () {
            let output = testClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            let output2 = fakeClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            assert.deepEqual(output, output2);
        });
        it("should work with sequels", function () {
            testClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            fakeClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            let output = testClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Thanos']);
            let output2 = fakeClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Thanos']);
            assert.deepEqual(output, output2);
        });
        it("should work with different movies", function () {
            testClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            fakeClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            testClass.makeMovie('New Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Thanos']);
            fakeClass.makeMovie('New Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Thanos']);
            assert.deepEqual(testClass, fakeClass);
        });
        it("should throw with invalid args count", function () {
            let testCase = () => { testClass.makeMovie("It", "should", "throw"); };
            expect(testCase).to.throw("Invalid arguments count");
        });
        it("should throw invalid args", function () {
            let testCase = () => { testClass.makeMovie('The Avengers', "Not Array"); }
            expect(testCase).to.throw("Invalid arguments");
        });
    });
    describe("Casting", function () {
        beforeEach(function () {
            testClass = new FilmStudio("FOX");
            fakeClass = new exploit("FOX");
        });
        it("should work", function () {
            testClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            fakeClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            let output = testClass.casting("RDJ", "Iron-Man");
            let output2 = fakeClass.casting("RDJ", "Iron-Man");
            expect(output).to.equal(output2);
        });
        it("should work with a non-existing role", function () {
            testClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            fakeClass.makeMovie('The Avengers', ['Iron-Man', 'Thor', 'Hulk', 'Arrow guy']);
            let output = testClass.casting("RDJ", "Iron Man");
            let output2 = fakeClass.casting("RDJ", "Iron Man");
            expect(output).to.equal(output2);
        });
        it("should work with no movies", function () {
            let output = testClass.casting("RDJ", "Iron Man");
            let output2 = fakeClass.casting("RDJ", "Iron Man");
            expect(output).to.equal(output2);
        });
    });
    describe("Look for producer", function () {
        beforeEach(function () {
            testClass = new FilmStudio("FOX");
            fakeClass = new exploit("FOX");
            testClass.makeMovie('The Avengers', ['Iron-Man', 'Thor']);
            fakeClass.makeMovie('The Avengers', ['Iron-Man', 'Thor']);
        });
        it("should return the correct output", function () {
            testClass.casting("RDJ", "Iron-Man");
            fakeClass.casting("RDJ", "Iron-Man");
            testClass.casting("CH", "Thor");
            fakeClass.casting("CH", "Thor");
            let output = testClass.lookForProducer("The Avengers");
            let output2 = fakeClass.lookForProducer("The Avengers");
            expect(output).to.equal(output2);
        });
        it("should return without cast", function () {
            let output = testClass.lookForProducer("The Avengers");
            let output2 = fakeClass.lookForProducer("The Avengers");
            expect(output).to.equal(output2);
        });
        it("should throw", function () {
            testClass.casting("RDJ", "Iron-Man");
            testClass.casting("CH", "Thor");
            let testCase = () => { testClass.lookForProducer("Avengers") };
            expect(testCase).to.throw(`Avengers do not exist yet, but we need the money...`);
        });
    })
    class exploit {

        constructor(studioName) {
            this.name = studioName;
            this.films = [];
        }

        casting(actor, role) {
            let isTheActorIsUnemployed = true;
            let output;

            if (this.films.length) {

                for (let f of this.films) {

                    let roles = f.filmRoles.filter((r) => r.role === role);

                    if (roles.length) {
                        let filmIndex = this.films.indexOf(f);
                        let wantedRole = this.films[filmIndex].filmRoles.filter((fR) => fR.role === role)[0];
                        let roleIndex = this.films[filmIndex].filmRoles.indexOf(wantedRole);

                        this.films[filmIndex].filmRoles[roleIndex].actor = actor;
                        isTheActorIsUnemployed = false;
                        output = `You got the job! Mr. ${actor} you are next ${role} in the ${f.filmName}. Congratz!`;
                        break;
                    }
                }

                if (isTheActorIsUnemployed) {
                    output = `${actor}, we cannot find a ${role} role...`;
                }

            } else {
                output = `There are no films yet in ${this.name}.`;
            }

            return output;
        }

        makeMovie(filmName, roles) {

            if (arguments.length === 2) {

                let firstArgIsString = typeof arguments[0] === 'string';
                let secondArgIsArray = arguments[1] instanceof Array;

                if (firstArgIsString && secondArgIsArray) {
                    let findedFilms = this.films.filter((f) => f.filmName.includes(filmName));

                    let filmRoles = roles.reduce((acc, cur) => {
                        let curFilmRole = {
                            role: cur,
                            actor: false
                        };
                        acc.push(curFilmRole);
                        return acc;
                    }, []);

                    let film = {
                        filmName,
                        filmRoles
                    };

                    if (findedFilms.length > 0) {
                        film.filmName += ` ${++findedFilms.length}`;
                    }

                    this.films.push(film);
                    return film;
                } else {
                    throw ('Invalid arguments')
                }

            } else {
                throw ('Invalid arguments count')
            }
        }

        lookForProducer(film) {

            let f = this.films.filter((f) => f.filmName === film)[0];
            let output;

            if (f) {
                output = `Film name: ${f.filmName}\n`;
                output += 'Cast:\n';
                Object.keys(f.filmRoles).forEach((role) => {
                    output += `${f.filmRoles[role].actor} as ${f.filmRoles[role].role}\n`;
                });
            } else {
                throw new Error(`${film} do not exist yet, but we need the money...`)
            }

            return output;
        }
    }
})