aadsd

function solve() {
    'use strict';

    const ERROR_MESSAGES = {
        INVALID_NAME_TYPE: 'Name must be string!',
        INVALID_NAME_LENGTH: 'Name must be between between 2 and 20 symbols long!',
        INVALID_NAME_SYMBOLS: 'Name can contain only latin symbols and whitespaces!',
        INVALID_MANA: 'Mana must be a positive integer number!',
        INVALID_EFFECT: 'Effect must be a function with 1 parameter!',
        INVALID_DAMAGE: 'Damage must be a positive number that is at most 100!',
        INVALID_HEALTH: 'Health must be a positive number that is at most 200!',
        INVALID_SPEED: 'Speed must be a positive number that is at most 100!',
        INVALID_COUNT: 'Count must be a positive integer number!',
        INVALID_SPELL_OBJECT: 'Passed objects must be Spell-like objects!',
        NOT_ENOUGH_MANA: 'Not enough mana!',
        TARGET_NOT_FOUND: 'Target not found!',
        INVALID_BATTLE_PARTICIPANT: 'Battle participants must be ArmyUnit-like!'

    };

    const generateID = (function() {
        let counter = 0;
        return function() {
            return counter += 1;
        }
    })();

    const VALIDATOR = {
        Check_If_MANA_Is_Not_Undefined_Or_Type_Number_And_Positive_Number: function(x) {
            if (x == undefined || x == NaN || typeof x != 'number' || x < 0) {
                throw Error(ERROR_MESSAGES.INVALID_MANA);
            }
        },
        Check_If_NAME_Is_Not_Undefined_Or_Type_String: function(x) {
            if (x == undefined || typeof x != 'string') {
                throw Error('Name must be between between 2 and 20 symbols long!');
            }
        },
        Is_In_Range_Min_And_Max: function(x, min, max) {
            if (x < min || x > max) {
                throw Error(ERROR_MESSAGES.INVALID_NAME_LENGTH);
            }
        },
        String_Contains_Latin_Letters_And_Space: function(x) {
            let pattern = /([A-Za-z\s])+/g;

            if (!(pattern.test(x))) {
                throw Error(ERROR_MESSAGES.INVALID_NAME_SYMBOLS);
            }
        },
        Check_If_IT_Is_Less_Than_100_And_Is_Number_And_Not_Undefined_And_Positive: function(x, max, message) {
            if (x == undefined || typeof x != 'number' || x > max || x < 0) {
                throw Error(message);
            }
        }

    };


    class Unit {
        constructor(name, alignment) {
            this.name = name;
            this.alignment = alignment;
        }

        get name() {
            return this._name;
        }

        set name(x) {

            VALIDATOR.Check_If_NAME_Is_Not_Undefined_Or_Type_String(x);

            VALIDATOR.Is_In_Range_Min_And_Max(x.length, 2, 20);

            VALIDATOR.String_Contains_Latin_Letters_And_Space(x);

            this._name = x;
        }

        get alignment() {
            return this._alignment;
        }

        set alignment(x) {

            if (x !== 'good' && x !== 'neutral' && x !== 'evil') {
                throw Error('Alignment must be good, neutral or evil!');
            }

            this._alignment = x;
        }
    };


    class ArmyUnit extends Unit {
        constructor(name, alignment, damage, health, speed, count) {
            super(name, alignment);

            this.id = generateID();
            this.damage = damage;
            this.health = health;
            this.count = count;
            this.speed = speed;
        }

        get damage() {
            return this._damage;
        }

        set damage(x) {

            VALIDATOR.Check_If_IT_Is_Less_Than_100_And_Is_Number_And_Not_Undefined_And_Positive(x, 100, ERROR_MESSAGES.INVALID_DAMAGE);

            this._damage = x;
        }

        get health() {
            return this._health;
        }

        set health(x) {

            VALIDATOR.Check_If_IT_Is_Less_Than_100_And_Is_Number_And_Not_Undefined_And_Positive(x, 200,
                ERROR_MESSAGES.INVALID_HEALTH);
            this._health = x;
        }

        get count() {
            return this._count;
        }

        set count(x) {

            if (x == undefined || typeof x != 'number' || x < 0) {
                throw Error(ERROR_MESSAGES.INVALID_COUNT);
            }

            this._count = x;
        }

        get speed() {
            return this._speed;
        }

        set speed(x) {

            VALIDATOR.Check_If_IT_Is_Less_Than_100_And_Is_Number_And_Not_Undefined_And_Positive(x, 100,
                ERROR_MESSAGES.INVALID_SPEED);

            this._speed = x;
        }
    };


    class Commander extends Unit {
        constructor(name, alignment, mana) {
            super(name, alignment);

            this.mana = mana;
            this.spellbook = [];
            this.army = [];
        }

        get mana() {
            return this._mana;
        }

        set mana(x) {

            if (x == undefined || typeof x != 'number' || x < 0) {
                throw Error('Mana must be a positive integer number!');
            }

            this._mana = x;
        }
    }


    class Spell {
        constructor(name, manaCost, effect) {
            this.name = name;
            this.manaCost = manaCost;
            this.effect = effect;
        };

        get name() {
            return this._name;
        }

        set name(x) {

            VALIDATOR.Check_If_NAME_Is_Not_Undefined_Or_Type_String(x);

            VALIDATOR.Is_In_Range_Min_And_Max(x.length, 2, 20);

            VALIDATOR.String_Contains_Latin_Letters_And_Space(x);

            this._name = x;
        }

        get manaCost() {
            return this._manaCost;
        }

        set manaCost(x) {

            VALIDATOR.Check_If_MANA_Is_Not_Undefined_Or_Type_Number_And_Positive_Number(x);

            this._manaCost = x;
        }

        get effect() {
            return this._effect;
        }

        set effect(x) {

            if (x == undefined || typeof x != 'function' || x.length != 1) {
                throw Error(ERROR_MESSAGES.INVALID_EFFECT);
            }

            this._effect = x;
        }

    };


    class Battlemanager {

        constructor() {
            this._armyOfCommanders = [];
            this._armyOfUnits = [];
        }

        getCommander(name, alignment, mana) {
            return new Commander(name, alignment, mana);
        }

        getArmyUnit(options) {
            let unit = new ArmyUnit(options.name, options.alignment, options.damage, options.health,
                options.speed, options.count);

            this._armyOfUnits.push(unit);
            return unit;
        }

        getSpell(name, manaCost, effect) {
            return new Spell(name, manaCost, effect);
        }

        addCommanders(...commanders) {

            //commanders.forEach(x => this._armyOfCommanders.push(x));

            this._armyOfCommanders = this._armyOfCommanders.concat(commanders);

            return this;
        }

        addArmyUnitTo(commanderName, armyUnit) {

            let commander = this._armyOfCommanders.find(x => x.name == commanderName);

            if (commander == undefined) {
                throw Error('No such commander');
            }

            commander.army.push(armyUnit);


            return this;
        }

        addSpellsTo(commanderName, ...spells) {

            let commander = this._armyOfCommanders.find(x => x.name === commanderName);

            if (commander == undefined) {
                throw Error('No such commander');
            }

            for (let spell of spells) {
                if (spell == undefined || (!(spell instanceof Spell)) || typeof spell != 'object') {
                    throw Error(ERROR_MESSAGES.INVALID_SPELL_OBJECT);
                }
            }

            spells.forEach(x => commander.spellbook.push(x));

            return this;
        }


        findCommanders(query) {


            if (Object.keys(query).length == 0) {

                // this._armyOfCommanders.sort((a, b) => a.name > b.name);

                return this._armyOfCommanders;
            }

            let commanders = [];

            for (let c of this._armyOfCommanders) {
                if (Object.keys(query).every(x => c[x] == query[x])) {
                    commanders.push(c);
                }
            }

            //commanders.sort((a, b) => a.name > b.name);

            return commanders;
        }

        findArmyUnitById(id) {
            return this._armyOfUnits.find(x => x.id == id);
        }

        findArmyUnits(query) {

            if (Object.keys(query).length == 0) {

                // this._armyOfUnits.sort((a, b) => a.speed < b.speed);

                // for (let i = 0; i < this._armyOfUnits.length - 1; i += 1) {
                //     if (this._armyOfUnits[i].speed == this._armyOfUnits[i + 1].speed) {
                //         let temp = this._armyOfUnits[i];
                //         this._armyOfUnits[i] = this._armyOfUnits[i + 1];
                //         this._armyOfUnits[i + 1] = temp;
                //     }
                // }



                return this._armyOfUnits;
            }

            let result = [];

            for (let unit of this._armyOfUnits) {
                if (Object.keys(query).every(x => unit[x] == query[x])) {
                    result.push(unit);
                }
            }

            // result.sort((a, b) => a.speed < b.speed);

            // for (let i = 0; i < result.length - 1; i += 1) {
            //     if (result[i].speed == result[i + 1].speed) {
            //         let temp = result[i];
            //         result[i] = result[i + 1];
            //         result[i + 1] = temp;
            //     }
            // }

            return result;

        }
        spellcast(casterName, spellName, targetUnitId) {
            let caster = this._armyOfCommanders.find(x => x.name == casterName);
            if (caster == undefined) {
                throw Error('Can\'t cast with non-existant commander ' + casterName + '!');
            }

            let spell = caster.spellbook.find(x => x.name == spellName);
            if (spell == undefined) {
                throw Error(casterName + ' doesn\'t know ' + spellName);
            }

            let target = this._armyOfUnits.find(x => x.id == targetUnitId);
            if (target == undefined) {
                throw Error('Target not found!');
            }

            if (caster.mana < spell.manaCost) {
                throw Error('Not enough mana!');
            }

            spell.effect(target);

            if (caster.mana - spell.manaCost < 0) {
                caster.mana = 0;
            } else {
                caster.mana -= spell.manaCost;
            }


            return this;
        }

        battle(attacker, defender) {

            if (!(attacker instanceof ArmyUnit) || !(defender instanceof ArmyUnit)) {
                throw Error('Battle participants must be ArmyUnit-like!');
            }
            let attackerTotalDamage = attacker.damage * attacker.count;
            let defenderTotalHealth = defender.health * defender.count;


            defenderTotalHealth -= attackerTotalDamage;
            let newCount = Math.ceil(defenderTotalHealth / defender.health);


            defender.count = newCount < 0 ? 0 : newCount;

        }
    };


    return new Battlemanager;
}
module.exports = solve;

// let MANAGER = solve();

// const tinkyWinky = MANAGER.getCommander('Tinky Winky', 'good', 66),
//     billGates = MANAGER.getCommander('Bill Gates', 'evil', 66)

// MANAGER.addCommanders(tinkyWinky, billGates)

// const armyUnits = {
//     dwarfs: MANAGER.getArmyUnit({ name: 'Dwarfs', speed: 20, damage: 33, health: 44, alignment: 'good', count: 50 }),
//     codeMonkeys: MANAGER.getArmyUnit({ name: 'Code Monkeys', speed: 20, damage: 5, health: 5, alignment: 'good', count: 300 }),
//     students: MANAGER.getArmyUnit({ name: 'Students', speed: 20, damage: 25, health: 33, alignment: 'good', count: 100 }),
//     mages1: MANAGER.getArmyUnit({ name: 'Mages One', speed: 15, damage: 60, health: 25, alignment: 'good', count: 5 }),
//     mages2: MANAGER.getArmyUnit({ name: 'Mages Two', speed: 15, damage: 60, health: 25, alignment: 'good', count: 50 }),
//     mages3: MANAGER.getArmyUnit({ name: 'Mages Three', speed: 15, damage: 60, health: 25, alignment: 'good', count: 3 }),
// }

// MANAGER
//     .addArmyUnitTo('Tinky Winky', armyUnits.dwarfs)
//     .addArmyUnitTo('Bill Gates', armyUnits.codeMonkeys)
//     .addArmyUnitTo('Bill Gates', armyUnits.students)
//     .addArmyUnitTo('Bill Gates', armyUnits.mages1)
//     .addArmyUnitTo('Tinky Winky', armyUnits.mages2)
//     .addArmyUnitTo('Bill Gates', armyUnits.mages3)

// const allUnits = MANAGER.findArmyUnits({})

// const sortedArmyUnits = Object.keys(armyUnits).map(k => armyUnits[k]).sort(compareUnits)