/**
 * Raw Game API object - should always correspond with the Game Schema
 * @param id
 * @param name
 * @param gameType
 * @param width
 * @param height
 * @param baseUrl
 * @param path
 * @param scenes
 * @param cameras
 * @param renderers
 * @param composers
 * @param systems
 * @param viewports
 * @param entityManager
 * @param mouse
 * @param parentEntity
 * @constructor
 */
GameLib.D3.API.Game = function(
    id,
    name,
    baseUrl,
    path,
    gameType,
    width,
    height,
    scenes,
    cameras,
    renderers,
    composers,
    systems,
	viewports,
    entityManager,
    mouse,
    parentEntity
) {
    GameLib.Component.call(
        this,
        GameLib.Component.COMPONENT_GAME,
        {
            'scenes'        : [GameLib.D3.Scene],
            'cameras'       : [GameLib.D3.Camera],
            'renderers'     : [GameLib.D3.Renderer],
            'composers'     : [GameLib.D3.Composer],
            'systems'       : [GameLib.System],
			'viewports'     : [GameLib.D3.Viewport],
            'entityManager' : GameLib.EntityManager,
            'mouse'         : GameLib.Mouse
        },
        null,
        parentEntity
    );

    if (GameLib.Utils.UndefinedOrNull(id)) {
        id = GameLib.Utils.RandomId();
    }
    this.id = id;

    if (GameLib.Utils.UndefinedOrNull(name)) {
        name = 'Game (' + this.id + ')';
    }
    this.name = name;

    if (GameLib.Utils.UndefinedOrNull(baseUrl)) {
        baseUrl = '';
        console.warn('The base URL required for downloading images is not set - textured meshes will not render properly');
    }
    this.baseUrl = baseUrl;

    if (GameLib.Utils.UndefinedOrNull(path)) {
        path = null;
    }
    this.path = path;

    if (GameLib.Utils.UndefinedOrNull(gameType)) {
        gameType = GameLib.D3.Game.GAME_TYPE_VR_PONG;
    }
    this.gameType = gameType;

    if (GameLib.Utils.UndefinedOrNull(width)) {
        width = 800;
    }
    this.width = width;

    if (GameLib.Utils.UndefinedOrNull(height)) {
        height = 600;
    }
    this.height = height;

    if (GameLib.Utils.UndefinedOrNull(scenes)) {
        scenes = [];
    }
    this.scenes = scenes;

    if (GameLib.Utils.UndefinedOrNull(cameras)) {
        cameras = [];
    }
    this.cameras = cameras;

    if (GameLib.Utils.UndefinedOrNull(renderers)) {
        renderers = [];
    }
    this.renderers = renderers;

    if (GameLib.Utils.UndefinedOrNull(composers)) {
        composers = [];
    }
    this.composers = composers;

    if (GameLib.Utils.UndefinedOrNull(systems)) {
        systems = [];
    }
    this.systems = systems;

	if (GameLib.Utils.UndefinedOrNull(viewports)) {
		viewports = [];
	}
	this.viewports = viewports;

    if (GameLib.Utils.UndefinedOrNull(entityManager)) {
        entityManager = new GameLib.API.EntityManager();
    }
    this.entityManager = entityManager;
    
    if (GameLib.Utils.UndefinedOrNull(mouse)) {
        mouse = new GameLib.API.Mouse();
    }
    this.mouse = mouse;
};

GameLib.D3.API.Game.prototype = Object.create(GameLib.Component.prototype);
GameLib.D3.API.Game.prototype.constructor = GameLib.D3.API.Game;

/**
 * Creates an API camera from an Object camera
 * @param objectGame
 * @constructor
 */
GameLib.D3.API.Game.FromObjectGame = function(objectGame) {

    var apiScenes       = [];
    var apiCameras      = [];
    var apiRenderers    = [];
    var apiComposers    = [];
    var apiSystems      = [];
	var apiViewports	= [];

    var apiEntityManager    = null;
    var apiMouse            = null;

    if (objectGame.scenes) {
        apiScenes = objectGame.scenes.map(
            function(objectScene){
                return GameLib.D3.API.Scene.FromObjectScene(objectScene);
            }
        );
    }

    if (objectGame.cameras) {
        apiCameras = objectGame.cameras.map(
            function(objectCamera){
                return GameLib.D3.API.Camera.FromObjectCamera(objectCamera);
            }
        );
    }

    if (objectGame.renderers) {
        apiRenderers = objectGame.renderers.map(
            function(objectRenderer){
                return GameLib.D3.API.Renderer.FromObjectComponent(objectRenderer);
            }
        );
    }

    if (objectGame.composers) {
        apiComposers = objectGame.composers.map(
            function(objectComposer){
                return GameLib.D3.API.Composer.FromObjectComponent(objectComposer);
            }
        );
    }

    if (objectGame.systems) {
        apiSystems = objectGame.systems.map(
            function(objectSystem){
                return GameLib.API.System.FromObjectComponent(objectSystem);
            }
        );
    }

	if (objectGame.viewports) {
		apiViewports = objectGame.viewports.map(
			function(objectViewport){
				return GameLib.D3.API.Viewport.FromObjectViewport(objectViewport);
			}
		);
	}

    if (objectGame.entityManager) {
        apiEntityManager = GameLib.API.EntityManager.FromObjectEntityManager(objectGame.entityManager);
    }

    if (objectGame.mouse) {
        apiMouse = GameLib.API.Mouse.FromObjectMouse(objectGame.mouse);
    }

    return new GameLib.D3.API.Game(
        objectGame.id,
		objectGame.name,
        objectGame.baseUrl,
        objectGame.path,
		objectGame.gameType,
		objectGame.width,
		objectGame.height,
        apiScenes,
        apiCameras,
        apiRenderers,
        apiComposers,
        apiSystems,
		apiViewports,
        apiEntityManager,
        apiMouse,
		objectGame.parentEntity
    );

};