(function() {
"use strict";

var FlockSystem = function() {
    this.initialize();
}
var p = FlockSystem.prototype = new creatine.System();

    p.initialize = function() {

    }


    p.process = function(boids, dog, wolfs, fdelta) {
        // console.log(fdelta)
        for (var i=0; i<boids.length; i++) {
            var b = boids[i];
            var flock = b.getComponent('Flock');

            // if (flock.state == FLOCK_STATE_GOAL) continue;

            if (flock.timeToForgetEnemy > 0) flock.timeToForgetEnemy -= fdelta;
            if (flock.timeToForgetDog > 0) flock.timeToForgetDog -= fdelta;
            this._changeStateIfNeeded(b, flock);


            var nearBoids = this._getNearestNeighbors(b, boids);

            var rules = [
                this._centering(b, nearBoids),
                this._avoid(b, nearBoids),
                this._velocity(b, nearBoids),
                this._runfromdog(b, dog),
                this._runfromwolf(b, wolfs),
                this._avoidSoftBlocks(b),
                this._runeffect(b),
            ]

            var vX = 0;
            var vY = 0;
            for (var j=0; j<rules.length; j++) {
                var mult = FLOCK_STATE_MODIFIERS[flock.state];
                // if (i==0) console.log(mult)

                vX += rules[j][0]*mult[j];
                vY += rules[j][1]*mult[j];
            }


            flock.velocityX = (flock.velocityX+vX)*(1-SHEEP_VELOCITY_DECAY*fdelta);
            flock.velocityY = (flock.velocityY+vY)*(1-SHEEP_VELOCITY_DECAY*fdelta);
            
            var norm = norm2d(flock.velocityX, flock.velocityY);
            if (norm > SHEEP_MAX_VELOCITY) {
                flock.velocityX = (flock.velocityX/norm) * SHEEP_MAX_VELOCITY
                flock.velocityY = (flock.velocityY/norm) * SHEEP_MAX_VELOCITY
            }
        }
    }

    p._changeStateIfNeeded = function(b, flock) {
        var tx = toCoordX(b.display.x);
        var ty = toCoordY(b.display.y);
        var goal = registry.map.getLayerByName('area_goal');

        if (getTile(goal, tx, ty)) {
            flock.state = FLOCK_STATE_GOAL;
        }
        else if (flock.timeToForgetEnemy > 0) {
            if (flock.state != FLOCK_STATE_SCARE) {
                if (Math.random() < SHEEP_SOUND_CHANCE_ON_SCARE) {
                    jukebox.playSheep();
                }
            }
            flock.state = FLOCK_STATE_SCARE;
        }
        else if (flock.timeToForgetDog > 0) {
            flock.state = FLOCK_STATE_WALK;
        } else {
            flock.state = FLOCK_STATE_IDLE;
        }

        // console.log(flock.state, tx, ty, getTile(goal, tx, ty));
    }

    p._getNearestNeighbors = function(b, boids) {
        var nearest = [];

        for (var i=0; i<boids.length; i++) {
            if (b == boids[i]) continue;

            var d = dist(b.display.x, b.display.y, boids[i].display.x, boids[i].display.y);

            if (d < SHEEP_MAX_NEIGHBORHOOD) {
                nearest.push(boids[i]);
            }
        }

        return nearest;
    }
    
    p._centering = function(b, boids) {
        var pX = 0;
        var pY = 0;

        if (boids.length) {
            for (var i=0; i<boids.length; i++) {
                pX += boids[i].display.x;
                pY += boids[i].display.y;
            }

            pX = (pX/boids.length - b.display.x)*SHEEP_CENTREOFMASS_COEFFICIENT;
            pY = (pY/boids.length - b.display.y)*SHEEP_CENTREOFMASS_COEFFICIENT;
        }

        // return [0, 0];
        return [pX, pY];
    }

    p._avoid = function(b, obstacles) {
        var cX = 0;
        var cY = 0;

        if (obstacles.length) {
            for (var i=0; i<obstacles.length; i++) {
                var d = dist(b.display.x, b.display.y, obstacles[i].display.x, obstacles[i].display.y);

                if (d < SHEEP_MIN_SAFE_DISTANCE) {
                    cX += b.display.x - obstacles[i].display.x;
                    cY += b.display.y - obstacles[i].display.y;
                }

            }
        }

        // return [0, 0];
        return [cX, cY];
    }

    p._velocity = function(b, boids) {
        var vX = 0;
        var vY = 0;

        if (boids.length) {
            for (var i=0; i<boids.length; i++) {
                var flock = boids[i].getComponent('Flock');
                vX += flock.velocityX;
                vY += flock.velocityY;
            }

            var flock = b.getComponent('Flock');
            vX = (vX/boids.length - flock.velocityX)*SHEEP_DIRECTION_COEFFICIENT;
            vY = (vY/boids.length - flock.velocityY)*SHEEP_DIRECTION_COEFFICIENT;
        }

        // return [0, 0];
        return [vX, vY];
    }

    p._towards = function(b, place) {
        var pX = 0;
        var pY = 0;

        if (place && dist(b.display.x, b.display.y, place[0], place[1]) < SHEEP_PLACE_DISTANCE) {
            pX = (place[0] - b.display.x)*SHEEP_PLACE_COEFFICIENT;
            pY = (place[1] - b.display.y)*SHEEP_PLACE_COEFFICIENT;
        }

        return [pX, pY];
    }

    p._runfromdog = function(b, place) {
        var pX = 0;
        var pY = 0;

        if (place && dist(b.display.x, b.display.y, place[0], place[1]) < SHEEP_DOG_DISTANCE) {
            var flock = b.getComponent('Flock');
            flock.timeToForgetDog = SHEEP_MEMORY_TIME;
            pX = (place[0] - b.display.x);
            pY = (place[1] - b.display.y);
        }

        return [-pX, -pY];
    }

    p._runfromwolf = function(b, wolfs) {
        var pX = 0;
        var pY = 0;
        var flock = b.getComponent('Flock');

        for (var i=0; i<wolfs.length; i++) {

            var wolf = wolfs[i];

            if (dist(b.display.x, b.display.y, wolf.display.x, wolf.display.y) < SHEEP_WOLF_DISTANCE) {
                var flock = b.getComponent('Flock');
                flock.timeToForgetEnemy = SHEEP_MEMORY_TIME;

                pX = (wolf.display.x - b.display.x);
                pY = (wolf.display.y - b.display.y);

                return [-pX, -pY];
            }
        }
        return [pX, pY];
    }

    p._avoidSoftBlocks = function(b) {
        var vx = 0;
        var vy = 0;
        var tx = Math.floor(b.display.x/registry.map.tileWidth);
        var ty = Math.floor(b.display.y/registry.map.tileHeight);

        var hardBlocks = registry.map.getLayerByName('area_softblock');

        for (var i=0; i<TILE_MASK.length; i++) {
            var mask = TILE_MASK[i];
            var dir = TILE_BLOCK_MASK_DIRECTIONS[i];

            if (getTile(hardBlocks, tx+mask[0], ty+mask[1])) {
                var cx = (tx+mask[0])*registry.map.tileWidth+registry.map.tileWidth/2;
                var cy = (ty+mask[1])*registry.map.tileHeight+registry.map.tileHeight/2;
                var d = dist(b.display.x, b.display.y, cx, cy);

                if (d < SHEEP_SOFTBLOCK_REPULSION_DISTANCE) {
                    vx += dir[0]*SHEEP_SOFTBLOCK_REPULSION_COEFFICIENT;
                    vy += dir[1]*SHEEP_SOFTBLOCK_REPULSION_COEFFICIENT;
                }
            }
        }
        
        return [vx, vy];
    }

    p._runeffect = function(b) {
        var tx = toCoordX(b.display.x);
        var ty = toCoordY(b.display.y);

        var effects = registry.map.getLayerByName('area_effects');
        var ef = TILE_EFFECTS[getTile(effects, tx, ty)];

        if (ef) {
            return [ef[0]*SHEEP_EFFECT_COEFFICIENT, ef[1]*SHEEP_EFFECT_COEFFICIENT];
        }

        return [0, 0];
    }

window.FlockSystem = FlockSystem;

})();