/// <reference path="../tsdefs/mongodb.d.ts" />
/// <reference path="../tsdefs/rx.d.ts" />

import * as ReactiveX from 'rx'; // don't delete!
import {User} from "../model/user";
import {Collection} from "mongodb";
import {MongoClient} from "mongodb";
import {Db} from "mongodb";
import {InsertOneWriteOpResult} from "mongodb";
import {CursorResult} from "mongodb";
import Observable = ReactiveX.Observable;
import Subject = ReactiveX.Subject;
import {TokenManager} from "../TokenManager";
import {Bassin} from "../model/bassin";
import {Storm} from "../model/storm";
import {Building} from "../model/building";
import {UpdateWriteOpResult} from "mongodb";
import {UserHistory} from "../model/history/userHistory";
import {DayInfo} from "../model/history/dayInfo";
import {BuildingHistory} from "../model/history/buildingHistory";
import {Settings} from "../model/settings";

import {Model} from "../model/model";
import {Hatchery} from "../model/hatchery";
import {Specie} from "../model/specie";
import {ObjectID} from "mongodb";
import {FeedingModel} from "../model/feedingModel";
import {SeaCage} from "../model/seaCage";
import {FishContainer} from "../model/fishContainer";

export class UserManager {

    private mongoClient:MongoClient;
    private url:string;
    private userCollection:Collection;
    private historyCollection:Collection;
    private settingsCollection:Collection;
    private outputModelsCollection:Collection;
    private constantInputModelCollection:Collection;
    private generatedInputModelCollection:Collection;
    private db:Db;

    constructor() {
        this.mongoClient = require('mongodb').MongoClient;
        this.url = 'mongodb://Uninova:uninova4@ds011422.mlab.com:11422/uninova';
    }

    public connect():Observable<Db> {
        var observable:Observable<Db> = Observable.fromPromise<Db>(this.mongoClient.connect(this.url));
        observable.subscribe(
            (db:Db) => {
                this.db = db;
                this.userCollection = db.collection("users");
                this.historyCollection = db.collection("history");
                this.settingsCollection = db.collection("data");
                this.outputModelsCollection = db.collection("outputmodels");
                this.constantInputModelCollection = db.collection("constantinputmodels");
                this.generatedInputModelCollection = db.collection("generatedinputmodels");
            }
        );
        return observable;
    }

    public getEnvironmentalModel(username: string, id: string): Observable<Model> {
        return Observable.create<Model>(
            observer => {
                this.readUser(username).subscribe(
                    (user: User) => {
                        Observable.fromPromise<CursorResult>(this.generatedInputModelCollection.find({_id: new ObjectID(id)}).limit(1).next()).map(
                            doc => doc == null ? null : new Model(doc.name, doc.data.slice(0, user.day))
                        ).subscribe((model: Model) => {observer.onNext(model)});
                    }
                )
            }
        );
    }

    public getMortalityModelById(id: string): Observable<Model> {
        return Observable.fromPromise<CursorResult>(this.generatedInputModelCollection.find({_id: new ObjectID(id)}).limit(1).next()).map(
            doc => {
                return doc == null ? null : new Model(doc.name, doc.data)
            }
        );
    }

    public deleteUser(token: string): Observable<any> {
        return Observable.create<any>(
            observer => {
                let username: string = TokenManager.getField(token, "username");
                this.deleteUserAccount(username).subscribe(() => this.deleteUserHistory(username).subscribe(() => observer.onNext(null)));
            }
        );
    }

    private deleteUserAccount(username: string): Observable<any> {
        return Observable.fromPromise(this.userCollection.deleteOne({username: username}));
    }

    private deleteUserHistory(username: string): Observable<any> {
        return Observable.fromPromise(this.historyCollection.deleteOne({username: username}));
    }

    /*  createUser
     We try to find a user with the corresponding username in the collection to see if the username is already taken.
     If not, we create a new user object and set it's registeredNumber value to the current amount of users in the collection.
     This user object gets inserted in the collection as a new document.
     Finally we pass the user object to the TokenManager to generate a token which will be passed to the client for future authentication.
     */
    public createUser(username:string, password:string):Observable<string> {
        return Observable.create<string>(
            observer => {
                this.readUser(username).subscribe(
                    readUser => {
                        if (readUser == null) {
                            Observable.fromPromise<number>(this.userCollection.count({})).subscribe(count => {
                                this.generateTemperatureModel().subscribe(temperatureModelData => {
                                    this.generateOxygenModel(temperatureModelData.model).subscribe(oxygenModelObjectId => {
                                        this.generatePhModel(temperatureModelData.model).subscribe(phModelObjectId => {
                                            this.getSettingsData().subscribe((settings:Settings) => {
                                                var storms:Storm[] = this.getRandomStorms(temperatureModelData.model);
                                                var user:User = new User(username, password, settings.startersMoney, "1", count, false, 1, [], storms, temperatureModelData.id.toString(), oxygenModelObjectId.toString(), phModelObjectId.toString(), "", "", "");
                                                Observable.fromPromise<InsertOneWriteOpResult>(this.userCollection.insertOne(user)).subscribe(() => observer.onNext(TokenManager.tokenify(user)));
                                            });
                                        });
                                    });
                                });
                            });
                        } else observer.onNext("");
                    }
                );
            }
        );
    }

    private generateTemperatureModel():Observable<any> {
        var temperatureModel:Model = new Model();
        var data = [];
        for (var i:number = 0; i < 365; i++) {
            if (Math.random() > 0.95)
                data[i] = 15.005;
            else
                data[i] = Math.round(((Math.random() + 1.75) * Math.sin(i * 6.0) + 23) * 100) / 100;
        }
        temperatureModel.name = "temperatureModel";
        temperatureModel.data = data;
        return Observable.fromPromise<InsertOneWriteOpResult>(this.generatedInputModelCollection.insertOne(temperatureModel)).map((iowor:InsertOneWriteOpResult) => {
            var modelData = {};
            modelData["model"] = temperatureModel;
            modelData["id"] = iowor.insertedId;
            return modelData;
        });
    }

    private getRandomStorms(model:Model):Storm[] {
        var storms:Storm[] = [];
        for (var i:number = 0; i < model.data.length; i++) {
            if (model.data[i] == 15.005) {
                var randomGravity:number = Math.floor(Math.random() * 9) + 1;
                storms.push(new Storm(randomGravity, i));
            }
        }

        return storms;


        /*   var storms: Storm[] = [];
         var amountOfStorms: number = Math.floor(Math.random() * 5) + 1; // 1 to 6 (inclusive) storms a year
         var randomAlreadyTaken: boolean;

         while (storms.length < amountOfStorms) {
         randomAlreadyTaken = false;
         var randomDay: number = Math.floor(Math.random() * 364) + 1;
         for (var i: number = 0; i < storms.length; i++) {
         if (storms[i].day == randomDay) {
         randomAlreadyTaken = true;
         break;
         }
         }
         if (randomAlreadyTaken) continue;
         var randomGravity: number = Math.floor(Math.random() * 9) + 1;
         storms.push(new Storm(randomGravity, randomDay));
         }
         return storms;*/
    }


    public generateOxygenModel(temparetureModel:Model):Observable<ObjectID> {
        var oxygenModel:Model = new Model();
        var data:number[] = [];
        for (var i:number = 0; i < 365; i++)
            data[i] = i;
        oxygenModel.name = "oxygenModel";
        oxygenModel.data = data;
        return Observable.fromPromise<InsertOneWriteOpResult>(this.generatedInputModelCollection.insertOne(oxygenModel)).map((iowor:InsertOneWriteOpResult) => iowor.insertedId);
    }

    public generatePhModel(temperatureModel:Model):Observable<ObjectID> {
        var phModel:Model = new Model();
        var data:number[] = [];
        for (var i:number = 0; i < 365; i++)
            data[i] = i;
        phModel.name = "phModel";
        phModel.data = data;
        return Observable.fromPromise<InsertOneWriteOpResult>(this.generatedInputModelCollection.insertOne(phModel)).map((iowor:InsertOneWriteOpResult) => iowor.insertedId);
    }

    public getHistory(token:string):Observable<UserHistory> {
        return Observable.fromPromise<CursorResult>(this.historyCollection.find({username: TokenManager.getField(token, "username")}).limit(1).next()).map(
            doc =>
                doc == null ? null : new UserHistory(doc.username, doc.buildingData)
        );
    }

    public getFoodNeededForDay(feedingModelId: string, day: number): Observable<number> {
        return Observable.create<number>(
            observer => {
                this.getFeedingModelByIdRoute(feedingModelId).subscribe((model: Model) => observer.onNext(model.data[day % 365]));
            }
        );
    }

    /*  login
     We read the user from the collection by their username.
     If the passwords match we return the user's token for future authentication, otherwise an empty string.
     */
    public login(username:string, password:string):Observable<any> {
        return Observable.create<any>(
            observer =>
                this.readUser(username).subscribe(
                    (user:User) =>
                        observer.onNext((user != null && user.password.localeCompare(password) == 0) ? {
                            "token": TokenManager.tokenify(user),
                            "aquasmart": user.hasAquaSmart,
                            "profileLevel": user.profileLevel
                        } : null)
                )
        );
    }

    public generateAverageWeight(token:string):Observable<string> {
        return Observable.create<string>(
            observer => {
                this.readUser(TokenManager.getField(token, "username")).subscribe((user:User) => {
                    var buildings:Building[] = this.getParsedBuildings(JSON.stringify(user.buildings));
                    for (var i:number = 0; i < buildings.length; i++) {
                        let building:Building = buildings[i];
                        if (building instanceof Hatchery) {
                            this.calcAverageWeight(user, building as Hatchery).subscribe((avgWeightModel:Model) => {
                                Observable.fromPromise<InsertOneWriteOpResult>(this.outputModelsCollection.insertOne(avgWeightModel)).map((iowor:InsertOneWriteOpResult) => iowor.insertedId.toString()).subscribe((id:string) => observer.onNext(id));
                            });
                        }
                    }
                })
            }
        );
    }

    private calcAverageWeight(user:User, hatchery:Hatchery):Observable<Model> {
        return Observable.create<Model>(
            observer => {
                let avgWeightModel:Model = new Model("Average Weight", []);

                let isStandardFeedingModel: boolean =
                    user.fishType1CustomFeedingModelId != hatchery.feedingModelId &&
                    user.fishType2CustomFeedingModelId != hatchery.feedingModelId &&
                    user.fishType3CustomFeedingModelId != hatchery.feedingModelId;

                this.getFeedingModelById(0, hatchery, hatchery.feedingModelId, isStandardFeedingModel).subscribe(feedingModelData => {
                    let feedingModel:FeedingModel = feedingModelData.model;
                    this.getFcrValuesForSpecie(hatchery.specie).subscribe((fcrValues:number[]) => {
                        this.getWaterTemperatureValues().subscribe((waterTemperatureValues:number[]) => {
                            for (var i:number = 0; i < +user.day; i++) {
                                let currentAvgWeight:number = feedingModel.data[i] / (((fcrValues[1] - fcrValues[0]) / 2) + fcrValues[0]) * (1 + (waterTemperatureValues[0] - ((waterTemperatureValues[1] - waterTemperatureValues[0]) / 2) / (waterTemperatureValues[1] - waterTemperatureValues[0])));
                                avgWeightModel.data.push(currentAvgWeight);

                                if (i == +user.day - 1)
                                    observer.onNext(avgWeightModel);
                            }
                        })
                    })
                })
            }
        );
    }

    private getSpecieName(specieType:string):Observable<string> {
        let fieldName:string = specieType.toLowerCase() + "Name";
        return Observable.fromPromise<CursorResult>(this.settingsCollection.find({}).limit(1).next()).map(
            doc => doc == null ? null : doc[fieldName]
        );
    }

    private getSpecieType(specie:string):Observable<string> {
        return Observable.create<string>(
            observer => {
                if (specie.toLowerCase() == "specie1" || specie.toLowerCase() == "specie2" || specie.toLowerCase() == "specie3")
                    observer.onNext(specie);
                else {
                    Observable.fromPromise<CursorResult>(this.settingsCollection.find({}).limit(1).next()).subscribe(doc => {
                        if (doc["specie1Name"].toLowerCase() == specie.toLowerCase())
                            observer.onNext("specie1");
                        if (doc["specie2Name"].toLowerCase() == specie.toLowerCase())
                            observer.onNext("specie2");
                        if (doc["specie3Name"].toLowerCase() == specie.toLowerCase())
                            observer.onNext("specie3");
                    });
                }
            }
        );
    }

    private getFcrValuesForSpecie(specie:string):Observable<number[]> {
        return Observable.create<number[]>(
            observer => {
                this.getSpecieType(specie).subscribe((specieType:string) => {
                    var object = {};
                    let field1Name:string = "fcrMin" + specieType[0].toUpperCase() + specieType.substr(1).toLowerCase();
                    let field2Name:string = "fcrMax" + specieType[0].toUpperCase() + specieType.substr(1).toLowerCase();
                    object[field1Name] = 1;
                    object[field2Name] = 1;
                    Observable.fromPromise<CursorResult>(this.settingsCollection.find({}).limit(1).next()).map(
                        doc => doc == null ? null : [doc[field1Name], doc[field2Name]]
                    ).subscribe(sup => observer.onNext(sup));
                });
            }
        );
    }

    private getWaterTemperatureValues():Observable<number[]> {
        return Observable.fromPromise<CursorResult>(this.settingsCollection.find({}).limit(1).next()).map(
            doc => doc == null ? null : [doc["minWaterTemperature"], doc["maxWaterTemperature"]]
        );
    }

    private getParsedBuildings(buildingsJson:string):Building[] {
        var parsedBuildings:Building[] = [];
        var buildings = JSON.parse(buildingsJson);
        for (var i:number = 0; i < buildings.length; i++) {
            if (buildings[i]["name"].toLowerCase().indexOf("hatchery") > -1)
                parsedBuildings[i] = new Hatchery(buildings[i]["position"], buildings[i]["rotation"], buildings[i]["name"], buildings[i]["mortalityModelId"], buildings[i]["bassins"], buildings[i]["feedingModelId"], buildings[i]["transformation"], buildings[i]["specie"], buildings[i]["daySinceFilled"], buildings[i]["visitedHatchery"]);
            else if (buildings[i]["name"].toLowerCase().indexOf("seacage") > -1)
                parsedBuildings[i] = new SeaCage(buildings[i]["position"], buildings[i]["rotation"], buildings[i]["name"], buildings[i]["mortalityModelId"], buildings[i]["amountOfFish"], buildings[i]["feedingModelId"], buildings[i]["transformation"], buildings[i]["specie"], buildings[i]["daySinceFilled"], buildings[i]["visitedSea"], buildings[i]["visitedBoat"]);
            else
                parsedBuildings[i] = new Building(buildings[i]["position"], buildings[i]["rotation"], buildings[i]["name"]);
        }
        return parsedBuildings;
    }

    //First: save received buildings to user's history
    //Second: change bassins and mortality and such
    //Third: incrDayForUser
    public nextDay(token:string, buildings:string, money: string, fishType1CustomFeedingModelId: string, fishType2CustomFeedingModelId: string, fishType3CustomFeedingModelId: string):Observable<Building[]> {
        return Observable.create<Building[]>(
            observer => {
                var username:string = TokenManager.getField(token, "username");
                console.log("wtf: " + username);
                Observable.fromPromise<CursorResult>(this.userCollection.find({username: username}).limit(1).next())
                    .map(doc => new User(doc.username, "nope", doc.money, doc.day, doc.registeredNumber, doc.hasAquaSmart, doc.profileLevel, doc.buildings, doc.storms, doc.temperatureModelId, doc.oxygenModelId, doc.phModelId, doc.fishType1CustomFeedingModelId, doc.fishType2CustomFeedingModelId, doc.fishType3CustomFeedingModelId, doc._id))
                    .subscribe(
                        (user:User) => {
                            this.getData(token).subscribe((previousDayUserObject:User) => {
                                this.saveAsHistoryFor(username, +money, +user.day, this.getParsedBuildings(buildings)).subscribe( // save history
                                    () => {
                                        let newBuildings:Building[] = this.getParsedBuildings(buildings);
                                        this.getSettingsData().subscribe(
                                            (settings:Settings) => {
                                                this.getEnvironmentalModel(username, user.temperatureModelId).subscribe(
                                                    (temperatureModel:Model) => {
                                                        if (newBuildings != null && newBuildings.length > 0) {
                                                            for (let building of newBuildings) {
                                                                if (building instanceof Hatchery) {
                                                                    for (var bassin of building.bassins)
                                                                        bassin.amountOfFishes -= this.calculateFatalitiesBassin(user, temperatureModel, building as Hatchery, bassin as Bassin, settings);
                                                                } else if (building instanceof SeaCage)
                                                                    (building as SeaCage).amountOfFish -= this.calculateFatalitiesSeaCage(user, temperatureModel, building as SeaCage, settings);
                                                            }

                                                            let totalBuildingCount:number = newBuildings.length;
                                                            var buildingCount:number = 0;
                                                            let newestBuildings:Building[] = this.checkMortalityModels(previousDayUserObject, newBuildings);
                                                            for (let building of newestBuildings) {
                                                                this.pushToMortalityModel(user, building).subscribe((pushedBuilding: Building) => {
                                                                    if (++buildingCount == totalBuildingCount) {
                                                                        this.updateUserBuildings(token, newestBuildings).subscribe(
                                                                            (someBuildings:Building[]) => {
                                                                                var sDay: string = user.day;
                                                                                var nDay: number = +sDay;
                                                                                nDay++;
                                                                                user.day = "" + nDay;
                                                                                this.updateUser(username, nDay, fishType1CustomFeedingModelId, fishType2CustomFeedingModelId, fishType3CustomFeedingModelId, +money).subscribe(() => observer.onNext(newestBuildings));
                                                                            })
                                                                    }
                                                                })
                                                            }
                                                        }
                                                    })
                                            })
                                    })
                            })
                        })
            })
    }

    private checkMortalityModels(previousDayUser: User, currentDayBuildings: Building[]): Building[] {
        let previousDayBuildings: Building[] = this.getParsedBuildings(JSON.stringify(previousDayUser.buildings));
        for (var i: number = 0; i < previousDayBuildings.length; i++) {
            let previousDayBuilding: Building = previousDayBuildings[i];
            for (var j: number = 0; j < currentDayBuildings.length; j++) {
                let currentDayBuilding: Building = currentDayBuildings[j];
                if (previousDayBuilding.name == currentDayBuilding.name) {
                    if (previousDayBuilding instanceof Hatchery) {
                        let previousDayHatchery: Hatchery = previousDayBuilding as Hatchery;
                        let currentDayHatchery: Hatchery = currentDayBuilding as Hatchery;

                        var previousDayHatcheryAmountOfFishes: number = 0;
                        for (var k: number = 0; k < previousDayHatchery.bassins.length; k++)
                            previousDayHatcheryAmountOfFishes += previousDayHatchery.bassins[k].amountOfFishes;

                        var currentDayHatcheryAmountOfFishes: number = 0;
                        for (var k: number = 0; k < currentDayHatchery.bassins.length; k++)
                            currentDayHatcheryAmountOfFishes += currentDayHatchery.bassins[k].amountOfFishes;

                        //todo: && not empty
                        if ((previousDayHatcheryAmountOfFishes != 0 && currentDayHatcheryAmountOfFishes == 0) ||
                            (currentDayHatcheryAmountOfFishes > previousDayHatcheryAmountOfFishes)) {
                                currentDayHatchery.mortalityModelId = null;
                        }
                    } else if (previousDayBuilding instanceof SeaCage) {
                        let previousDaySeaCage: SeaCage = previousDayBuilding as SeaCage;
                        let currentDaySeaCage: SeaCage = currentDayBuilding as SeaCage;

                        if ((previousDaySeaCage.amountOfFish != 0 && currentDaySeaCage.amountOfFish == 0) ||
                            (currentDaySeaCage.amountOfFish > previousDaySeaCage.amountOfFish)) {
                                currentDaySeaCage.mortalityModelId = null;
                        }
                    }
                }
            }
        }

        return currentDayBuildings;
    }

    private pushToMortalityModel(user: User, building: Building): Observable<Building> {
        return Observable.create<Building>(
            observer => {
                if (building instanceof Hatchery || building instanceof SeaCage) {
                    Observable.create<string>(
                        innerObserver => {
                            if ((building as FishContainer).mortalityModelId == null || (building as FishContainer).mortalityModelId == "") {
                                let mortalityModel: Model = new Model("mortalityModel", []);
                                Observable.fromPromise<InsertOneWriteOpResult>(this.generatedInputModelCollection.insertOne(mortalityModel))
                                    .map((iowor:InsertOneWriteOpResult) => iowor.insertedId.toString())
                                    .subscribe(
                                        (insertedId:string) => {
                                            innerObserver.onNext(insertedId);
                                        }
                                    );
                            } else
                                innerObserver.onNext((building as FishContainer).mortalityModelId);
                        }
                    ).subscribe((mortalityModelId:string) => {
                        console.log("MORTALITYMODELID: " + mortalityModelId);
                        (building as FishContainer).mortalityModelId = mortalityModelId;
                        if (building instanceof Hatchery) {
                            var amountOfFishes:number = 0;
                            for (var i:number = 0; i < (building as Hatchery).bassins.length; i++)
                                amountOfFishes += building.bassins[i].amountOfFishes;
                            Observable.fromPromise<any>(this.generatedInputModelCollection.findOneAndUpdate(
                                {_id: new ObjectID((building as FishContainer).mortalityModelId)},
                                {$push: {data: amountOfFishes}})
                            ).subscribe(() => observer.onNext(building));
                        } else if (building instanceof SeaCage)
                            Observable.fromPromise<any>(this.generatedInputModelCollection.findOneAndUpdate(
                                {_id: new ObjectID((building as FishContainer).mortalityModelId)},
                                {$push: {data: (building as SeaCage).amountOfFish}})
                            ).subscribe(() => observer.onNext(building));
                    })
                } else
                    observer.onNext(null);
            })
    };



    //gets called when user adds buildings in overview then hits escape
    public saveData(token:string, buildings:Building[], money: number, fishType1CustomFeedingModelId: string, fishType2CustomFeedingModelId: string, fishType3CustomFeedingModelId: string):Observable<any> {
        return Observable.create<any>(
            observer => {
                if (TokenManager.validate(token)) {
                    var requestingUsername:string = TokenManager.getField(token, "username");
                    Observable.fromPromise<UpdateWriteOpResult>(
                        this.userCollection.updateOne(
                            {username: requestingUsername},
                            {$set: {buildings: buildings, fishType1CustomFeedingModelId: fishType1CustomFeedingModelId, fishType2CustomFeedingModelId: fishType2CustomFeedingModelId, fishType3CustomFeedingModelId: fishType3CustomFeedingModelId}},
                            {}
                        )).subscribe(
                        (result:UpdateWriteOpResult) =>
                            observer.onNext(result.modifiedCount)
                    );
                }
            }
        );
    }

    private updateUser(username: string, day: number, fishType1CustomFeedingModelId: string, fishType2CustomFeedingModelId: string, fishType3CustomFeedingModelId: string, money: number): Observable<any> {
        return Observable.create<any>(
            observer => {
                Observable.create<any>(
                    innerObserver => {
                        if (day != 365)
                            innerObserver.onNext(null);
                        else
                            this.getNewEnvironmentalModels().subscribe((environmentalModels: string[]) => innerObserver.onNext(environmentalModels));
                    }
                ).subscribe(
                    (environmentalModels: string[]) => {

                        let objectToSave = {
                            day: day,
                            fishType1CustomFeedingModelId: fishType1CustomFeedingModelId,
                            fishType2CustomFeedingModelId: fishType2CustomFeedingModelId,
                            fishType3CustomFeedingModelId: fishType3CustomFeedingModelId,
                            money: money
                        };

                        if (environmentalModels != null) {
                            objectToSave["temperatureModelId"] = environmentalModels[0];
                            objectToSave["oxygenModelId"] = environmentalModels[1];
                            objectToSave["phModelId"] = environmentalModels[2];
                            console.log(objectToSave["temperatureModelId"]);
                            console.log(objectToSave["oxygenModelId"]);
                            console.log(objectToSave["phModelId"]);
                        }

                        Observable.fromPromise<UpdateWriteOpResult>(
                            this.userCollection.updateOne(
                                {username: username},
                                {$set: objectToSave},
                                {}
                            )).subscribe(
                            (result:UpdateWriteOpResult) =>
                                observer.onNext(result) //result is omitted
                        )
                });
            }
        );
    }

    private getNewEnvironmentalModels(): Observable<string[]> {
        console.log("NEW SHIT");
        return Observable.create<string[]>(
            observer => {
                this.generateTemperatureModel().subscribe(temperatureModelData => {
                    this.generateOxygenModel(temperatureModelData.model).subscribe(oxygenModelObjectId => {
                        this.generatePhModel(temperatureModelData.module).subscribe(phModelObjectId => {
                            observer.onNext([temperatureModelData.id.toString(), oxygenModelObjectId.toString(), phModelObjectId.toString()])
                        })
                    })
                })
            }
        )
    }

    private incrDayForUser(username:string, currentDay:number):Observable<any> {
        return Observable.create<any>(
            observer => {
                Observable.fromPromise<UpdateWriteOpResult>(this.userCollection.updateOne({username: username}, {$set: {day: currentDay + 1}}, {})).subscribe(
                    (result:UpdateWriteOpResult) =>
                        observer.onNext(result) //result is omitted
                );
            }
        );
    }

    public saveCustomFeedingModel(model: Model): Observable<string> {
        return Observable.fromPromise<InsertOneWriteOpResult>(this.generatedInputModelCollection.insertOne(new Model(model.name, model.data)))
            .map((iowor: InsertOneWriteOpResult) => iowor.insertedId.toString());
    }

    //Does history already exist for this user?
    //  no -> create one and insert data we received
    //  yes -> insert data we received in 'days' collection of user's history
    private saveAsHistoryFor(username: string, money: number, currentDay:number, buildings: Building[]): Observable<any> {
        let dayHistory = {};
        dayHistory["day"] = currentDay;
        dayHistory["money"] = money;

        let buildingData = [];
        for (var i: number = 0; i < buildings.length; i++) {
            let building:Building = buildings[i];
            if (building instanceof Hatchery || building instanceof SeaCage) {
                let currentBuildingDataBlock = {};
                currentBuildingDataBlock["name"] = building.name;
                var amountOfFish:number = 0;
                if (building instanceof Hatchery) {
                    let bassins:Bassin[] = (building as Hatchery).bassins;
                    for (var j:number = 0; j < bassins.length; j++)
                        amountOfFish += bassins[j].amountOfFishes;
                } else if (building instanceof SeaCage)
                    amountOfFish = (building as SeaCage).amountOfFish;
                currentBuildingDataBlock["amountOfFish"] = amountOfFish;
                buildingData.push(currentBuildingDataBlock);
            }
        }

        dayHistory["buildingData"] = buildingData;

        return Observable.create<any>(
            observer => {
                Observable.fromPromise<number>(this.historyCollection.count({username: username})).subscribe(count => {
                    if (count == 0) { // no history for user yet -> create history object for user
                        let userObject = {};
                        userObject["username"] = username;
                        userObject["history"] = [dayHistory];
                        Observable.fromPromise<InsertOneWriteOpResult>(this.historyCollection.insertOne(userObject)).subscribe(() => observer.onNext(null));
                    } else // history for user -> push to user's array
                        Observable.fromPromise<any>(this.historyCollection.findOneAndUpdate({username: username}, {$push: {history: dayHistory}})).subscribe(() => observer.onNext(null));
                });
            }
        );
    }

    private getDataUsername(username: string): Observable<User> {
        return Observable.create<User>(
            observer => {
                this.readUser(username).subscribe(
                    (user: User) =>
                        observer.onNext(user)
                );
            }
        );
    }

    /*  getData
     This method gets invoked when the user is logged in.
     Returns the user's document from the database which also contains buildings, bassins and storms.
     */
    public getData(token: string): Observable<User> {
        return Observable.create<User>(
            observer => {
                var username: string = TokenManager.getField(token, "username");
                this.readUser(username).subscribe(
                    (user:User) =>
                        observer.onNext(user)
                );
            }
        );
    }

    public getNeighbourData(token:string):Observable<User[]> {
        return Observable.create<User[]>(
            observer => {
                var registeredNumber = TokenManager.getField(token, "registeredNumber");
                var neighbours:User[] = [];
                Observable.create<User>(
                    observerLeftNeighbour => {
                        if (+registeredNumber > 0)
                            this.getDataFromRegisteredNumber(registeredNumber - 1).subscribe((leftNeighbour:User) => observerLeftNeighbour.onNext(leftNeighbour));
                        else
                            observerLeftNeighbour.onNext(null);
                    }
                ).subscribe((leftNeighbour:User) => {
                    neighbours[0] = leftNeighbour;
                    Observable.create<User>(
                        observerRightNeighbour => {
                            Observable.fromPromise<number>(this.userCollection.count({})).subscribe(count => {
                                if (+registeredNumber < count - 1)
                                    this.getDataFromRegisteredNumber(registeredNumber + 1).subscribe((rightNeighbour:User) => observerRightNeighbour.onNext(rightNeighbour));
                                else
                                    observerRightNeighbour.onNext(null);
                            });
                        }
                    ).subscribe((rightNeighbour:User) => {
                        neighbours[1] = rightNeighbour;
                        observer.onNext(neighbours);
                    });
                });
            }
        )
    }

    public getSettingsData():Observable<Settings> {
        var settings: Settings;
        return Observable.fromPromise<CursorResult>(this.settingsCollection.find({}).limit(1).next()).map(
            doc => doc == null ? null : (settings = doc)
        );
    }

    /*
     *
     * string name
     * string specie
     * int amountOfFish
     * list<Model> models: feedingmodel, ph model, oxygen model
     * */

    public getHatcheryModels(username: string): Observable<any[]> {
        return Observable.create<any[]>(
            observer => {
                var fishContainerModels = [];
                this.getDataUsername(username).subscribe((user: User) => {
                    var lastFishContainerI: number = -1;
                    var count: number = 0;
                    var total: number = 0;
                    var bs: Building[] = this.getParsedBuildings(JSON.stringify(user.buildings));
                    for (var i:number = 0; i < bs.length; i++) {
                        var building:Building = bs[i];
                        if (building instanceof Hatchery || building instanceof SeaCage) {
                            lastFishContainerI = i;
                            total++;
                        }
                    }

                    if (lastFishContainerI == -1)
                        observer.onNext(null);

                    var currentFishContainerCount:number = 0;
                    for (var i:number = 0; i < bs.length; i++) {
                        var building:Building = bs[i];
                        if (building instanceof Hatchery || building instanceof SeaCage) {
                            //var hatchery: Hatchery = building as Hatchery;
                            var fishContainer:FishContainer = building as FishContainer;
                            currentFishContainerCount++;
                            const fishContainerModel: any = {};
                            fishContainerModel.name = fishContainer.name;
                            fishContainerModel.specie = fishContainer.specie;
                            var amountOfFish:number = 0;

                            if (building instanceof Hatchery) {
                                for (var j:number = 0; j < (building as Hatchery).bassins.length; j++)
                                    amountOfFish += (building as Hatchery).bassins[j].amountOfFishes;
                            } else if (building instanceof SeaCage) {
                                amountOfFish = (building as SeaCage).amountOfFish;
                            }
                            fishContainerModel.amountOfFish = amountOfFish;
                            const models:Model[] = [];

                            console.log("FISHCONTAINER:");
                            console.log(JSON.stringify(fishContainer));

                            let isStandardFeedingModel: boolean =
                                user.fishType1CustomFeedingModelId != fishContainer.feedingModelId &&
                                    user.fishType2CustomFeedingModelId != fishContainer.feedingModelId &&
                                    user.fishType3CustomFeedingModelId != fishContainer.feedingModelId;

                            this.getFeedingModelById(i, fishContainer, fishContainer.feedingModelId, isStandardFeedingModel).subscribe(feedingModelData => {
                                models.push(feedingModelData.model == null ? null : feedingModelData.model);
                                this.getPhModelById(feedingModelData.hatcheryI, feedingModelData.building, feedingModelData.building.phModelId).subscribe(phModelData => {
                                    models.push(phModelData.model == null ? null : phModelData.model);
                                    this.getOxygenModelById(phModelData.hatcheryI, phModelData.building, phModelData.building.oxygenModelId).subscribe(oxygenModelData => {
                                        models.push(oxygenModelData.model == null ? null : oxygenModelData.model);
                                        this.getMortalityModelById(oxygenModelData.building.mortalityModelId).subscribe((mortalityModel: Model) => {
                                            count++;
                                            models.push(mortalityModel == null ? null : mortalityModel);
                                            fishContainerModel["models"] = models;
                                            fishContainerModels.push(fishContainerModel);
                                            //if (oxygenModelData.hatcheryI == lastFishContainerI)
                                            if (count == total)
                                                observer.onNext(fishContainerModels);
                                        });
                                    });
                                });
                            });
                        }
                    }
                });
            }
        )
    }

    public getFeedingModelByIdRoute(id: string): Observable<FeedingModel> {
        return Observable.fromPromise(this.constantInputModelCollection.find({_id: new ObjectID(id)}).limit(1).next());
    }

    public getFeedingModelsForSpecie(specie:string):Observable<FeedingModel[]> {
        return Observable.create<FeedingModel[]>(
            observer => {
                let models = [];
                this.constantInputModelCollection.find({specie: specie}).forEach(doc => models.push(doc == null ? null : new FeedingModel(doc._id, doc.name, doc.specie, doc.data)), (error) => {
                    observer.onNext(models)
                });
            }
        )
    }

     public getHatcheryFishCountHistory(token: string): Observable<Model> {
     var user:string = TokenManager.getField(token, "username");

     return Observable.create<Model>(o => {
         Observable.fromPromise<CursorResult>(this.historyCollection.find({username: user}).sort({_id: -1}).next())
         .subscribe(d => {
                var model:Model = null;



                return o.onNext(model);
             });
         });
     }

    private updateUserBuildings(token:string, buildings:Building[]):Observable<Building[]> {
        return Observable.create<Building[]>(
            observer => {
                if (TokenManager.validate(token)) {
                    //this.checkForOxygenAndPhModels(buildings).subscribe((newBuildings: Building[]) => {
                    // In newBuildings, ALL hatcheries have an oxygen and phModel generated, also the new ones
                    var username:string = TokenManager.getField(token, "username");
                    Observable.fromPromise<UpdateWriteOpResult>(this.userCollection.updateOne({username: username}, {$set: {buildings: buildings/*newBuildings*/}}, {})).subscribe((result:UpdateWriteOpResult) => observer.onNext(buildings/*newBuildings*/));
                    //});
                } else observer.onNext(null);
            }
        );
    }

    private readUser(username:string):Observable<User> {
        return Observable.fromPromise<CursorResult>(this.userCollection.find({username: username}).limit(1).next()).map(
            doc =>
                doc == null ? null : new User(doc.username, doc.password, doc.money, doc.day, doc.registeredNumber, doc.hasAquaSmart, doc.profileLevel, doc.buildings, doc.storms, doc.temperatureModelId, doc.oxygenModelId, doc.phModelId, doc.fishType1CustomFeedingModelId, doc.fishType2CustomFeedingModelId, doc.fishType3CustomFeedingModelId, doc._id)
        );
    }

    private getDataFromRegisteredNumber(registeredNumber:number): Observable<User> {
        return Observable.create<User>(
            observer => {
                Observable.fromPromise<CursorResult>(this.userCollection.find({registeredNumber: registeredNumber}).limit(1).next()).map(
                    doc => {
                        return doc == null ? null : new User(doc.username, "nice try ;)", doc.money, doc.day, doc.registeredNumber, doc.hasAquaSmart, doc.profileLevel, doc.buildings, doc.storms, doc.temperatureModel, doc.oxygenModelId, doc.phModelId,  doc.fishType1CustomFeedingModelId, doc.fishType2CustomFeedingModelId, doc.fishType3CustomFeedingModelId, doc._id);
                    }
                ).subscribe((user:User) => observer.onNext(user));
            }
        );
    }

    public updateProfile(username: string, aquasmart: boolean, profileLevel: number): Observable<any> {
        return Observable.create<any>(
            observer =>
                Observable.fromPromise<CursorResult>(this.userCollection.updateOne({username: username}, {$set: {hasAquaSmart: aquasmart, profileLevel: profileLevel}}, {})).subscribe(() => observer.onNext(null))
        );
    }

    private calculateFatalitiesSeaCage(user: User, temperatureModel: Model, seaCage: SeaCage, settings: Settings): number {
        var fatalityPercentage: number = settings.percentageOfMortalitySeacage;
        if (seaCage.visitedSea)
            fatalityPercentage -= 0.04;
        if (seaCage.visitedBoat)
            fatalityPercentage -= 0.01;

        if (temperatureModel.data[user.day] <= settings.minWaterTemperature || temperatureModel.data[user.day] >= settings.maxWaterTemperature)
            fatalityPercentage += 0.02;

        console.log("Seacage fish: " + seaCage.amountOfFish + " - " + (seaCage.amountOfFish * fatalityPercentage));

        return seaCage.amountOfFish * fatalityPercentage;
        //todo insert value into mortality model
    }

    private calculateFatalitiesBassin(user: User, temperatureModel: Model, hatchery: Hatchery, bassin: Bassin, settings: Settings): number {
        var fatalityPercentage: number = settings.percentageOfMortalityHatchery;
        if (hatchery.visitedHatchery)
            fatalityPercentage -= 0.02;

        if (temperatureModel.data[user.day] <= settings.minWaterTemperature || temperatureModel.data[user.day] >= settings.maxWaterTemperature)
            fatalityPercentage += 0.02;

        return bassin.amountOfFishes * fatalityPercentage;
        //todo insert value into mortality model
    }

    public changeFeedingModel(token:string, hatcheryNumber:number, transformation:number) {
        //todo: haal uit hatchery welke vissoort er is -> haal standaard model voor vissoort
        let username:string = TokenManager.getField(token, "username");
        this.readUser(username).subscribe(
            user => {
                for (var i:number = 0; i < user.buildings.length; i++) {
                    let buildingName:string = user.buildings[i].name.toLowerCase();
                    let splitted:string[] = buildingName.split("_");
                    /*if (buildingName.indexOf("hatchery") > -1 && +splitted[splitted.length - 1] == hatcheryNumber) {
                        console.log("FOUND HATCHERY NUMBER : " + hatcheryNumber);
                    } else {
                        console.log("NOT YET FOUND HATCHERY NUMBER : " + hatcheryNumber + ", currently at: " + i);
                    }*/
                }
            }
        );
    }

    public getFeedingModelById(hatcheryI:number, building:Building, id: string, isStandardFeedingModel: boolean):Observable<any> {
        console.log("Trying to get feeding model by id: " + id);
        return Observable.create<any>(
            observer => {
                if (id == null || id == "")
                    observer.onNext({model: null, building: building, hatcheryI: hatcheryI});
                else {
                    if (isStandardFeedingModel) {
                        Observable.fromPromise<CursorResult>(this.constantInputModelCollection.find({_id: new ObjectID(id)}).limit(1).next()).map(
                            doc => {
                                var returnObject = {};
                                console.log("ReturnObject.model: " + doc);
                                returnObject["model"] = (doc == null ? null : new Model(doc.name, doc.data));
                                returnObject["building"] = building;
                                returnObject["hatcheryI"] = hatcheryI;
                                return returnObject;
                            }
                        ).subscribe(returnObject => observer.onNext(returnObject));
                    } else {
                        Observable.fromPromise<CursorResult>(this.generatedInputModelCollection.find({_id: new ObjectID(id)}).limit(1).next()).map(
                            doc => {
                                var returnObject = {};
                                console.log("ReturnObject.model: " + doc);
                                returnObject["model"] = (doc == null ? null : new Model(doc.name, doc.data));
                                returnObject["building"] = building;
                                returnObject["hatcheryI"] = hatcheryI;
                                return returnObject;
                            }
                        ).subscribe(returnObject => observer.onNext(returnObject));
                    }
                }
            }
        );
    }

    private getPhModelById(hatcheryI:number, building:Building, id?:string):Observable<any> {
        return Observable.create<any>(
            observer => {
                if (id == null || id == "")
                    observer.onNext({model: null, building: building, hatcheryI: hatcheryI});
                else {
                    Observable.fromPromise<CursorResult>(this.generatedInputModelCollection.find({_id: new ObjectID(id)}).limit(1).next()).map(
                        doc => {
                            var returnObject = {};
                            returnObject["model"] = (doc == null ? null : new Model(doc.name, doc.data));
                            returnObject["building"] = building;
                            returnObject["hatcheryI"] = hatcheryI;
                            return returnObject;
                        }
                    ).subscribe(returnObject => observer.onNext(returnObject));
                }
            }
        );
    }

    private getOxygenModelById(hatcheryI:number, building:Building, id:string):Observable<any> {
        return Observable.create<any>(
            observer => {
                if (id == null || id == "")
                    observer.onNext({model: null, building: building, hatcheryI: hatcheryI});
                else {
                    Observable.fromPromise<CursorResult>(this.generatedInputModelCollection.find({_id: new ObjectID(id)}).limit(1).next()).map(
                        doc => {
                            var returnObject = {};
                            returnObject["model"] = (doc == null ? null : new Model(doc.name, doc.data));
                            returnObject["building"] = building;
                            returnObject["hatcheryI"] = hatcheryI;
                            return returnObject;
                        }
                    ).subscribe(returnObject => observer.onNext(returnObject));
                }
            }
        );
    }

    /* private generateOxygenAndPhModelForHatcheryIfNecessary(i: number, hatchery: Hatchery): Observable<any> {
     return Observable.create<any>(
     observer => {
     if ((hatchery.phModelId == null) && // building has no phModel
     (hatchery.oxygenModelId == null)) { // && building has no oxygenModel
     this.generateOxygenModel().subscribe((oxygenModelId:ObjectID) => {
     this.generatePhModel().subscribe((phModelId:ObjectID) => {
     var returnObject = {};
     hatchery.oxygenModelId = oxygenModelId.toString();
     hatchery.phModelId = phModelId.toString();
     returnObject["building"] = hatchery;
     returnObject["i"] = i;
     observer.onNext(returnObject);
     });
     });
     } else observer.onNext({building: hatchery, i: i});
     }
     );
     }*/

    /*private checkForOxygenAndPhModels(buildings: Building[]): Observable<Building[]> {
     return Observable.create<Building[]>(
     observer => {
     var lastHatcheryI: number = -1;
     for (var i: number = 0; i < buildings.length; i++) {
     if (buildings[i].name.indexOf("hatchery") > -1)
     lastHatcheryI = i;
     }

     for (var i: number = 0; i < buildings.length; i++) {
     //if (buildings[i].name.indexOf("hatchery") > -1) {
     if (buildings[i] instanceof Hatchery) {
     this.generateOxygenAndPhModelForHatcheryIfNecessary(i, buildings[i] as Hatchery).subscribe(returnObject => {
     buildings[returnObject.i] = returnObject.building;
     if (+returnObject.i === +lastHatcheryI)
     observer.onNext(buildings);
     });
     }
     }
     }
     );
     }*/

    public getOpenDataUsers():Observable<string[]> {
        return Observable.create<string[]>(
            observer => {
                let users: string[] = [];
                this.userCollection.find({hasAquaSmart: "True"}).forEach(
                    doc =>
                        users.push(doc == null ? null : doc.username), (error) => {
                        observer.onNext(users);
                    });
            }
        );
    }
}