/**
 * Raw Editor API object - should always correspond with the Editor Schema
 * @param id
 * @param name
 * @param baseUrl
 * @param path
 * @param imageFactory
 * @param games [R3.API.D3.Game]
 * @param scenes
 * @param cameras
 * @param composers
 * @param viewports
 * @param renderers
 * @param renderTargets
 * @param systems
 * @param entityManager
 * @param allSelected
 * @param selectedObjects
 * @param parentEntity
 * @constructor
 */
R3.D3.API.Editor = function(
    id,
    name,
    baseUrl,
    path,
    imageFactory,
    games,
    scenes,
    cameras,
    composers,
    viewports,
    renderers,
    renderTargets,
    systems,
    entityManager,
    allSelected,
    selectedObjects,
    parentEntity
) {
    R3.Component.call(
        this,
        R3.Component.COMPONENT_EDITOR,
        {
            'imageFactory'  : R3.D3.ImageFactory,
            'games'         : [R3.D3.Game],
            'scenes'        : [R3.D3.Scene],
            'cameras'       : [R3.D3.Camera],
            'composers'     : [R3.D3.Composer],
            'viewports'     : [R3.D3.Viewport],
            'renderers'     : [R3.D3.Renderer],
            'renderTargets' : [R3.D3.RenderTarget],
            'systems'       : [R3.System],
            'entityManager' : R3.EntityManager
        },
        null,
        parentEntity
    );

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

    if (R3.Utils.UndefinedOrNull(name)) {
        name = 'Editor (' + this.id + ')';
    }
    this.name = name;

    if (R3.Utils.UndefinedOrNull(baseUrl)) {
        baseUrl = '';
    }
    this.baseUrl = baseUrl;

    if (R3.Utils.UndefinedOrNull(path)) {
        path = '';
    }
    this.path = path;

    if (R3.Utils.UndefinedOrNull(imageFactory)) {
        imageFactory = null;
    }
    this.imageFactory = imageFactory;

    if (R3.Utils.UndefinedOrNull(games)) {
        games = [];
    }
    this.games = games;

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

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

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

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

    if (R3.Utils.UndefinedOrNull(renderTargets)) {
        renderTargets = [];
    }
    this.renderTargets = renderTargets;

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

    if (R3.Utils.UndefinedOrNull(entityManager)) {
        entityManager = new R3.API.EntityManager();
    }
    this.entityManager = entityManager;
    
    if (R3.Utils.UndefinedOrNull(allSelected)) {
        allSelected = false;
    }
    this.allSelected = allSelected;

    if (R3.Utils.UndefinedOrNull(selectedObjects)) {
        selectedObjects = [];
    }
    this.selectedObjects = selectedObjects;

};

R3.D3.API.Editor.prototype = Object.create(R3.Component.prototype);
R3.D3.API.Editor.prototype.constructor = R3.D3.API.Editor;

/**
 * Creates an API Editor from an Object Editor
 * @param objectEditor
 * @constructor
 */
R3.D3.API.Editor.FromObjectEditor = function(objectEditor) {

    var apiImageFactory     = null;
    var apiGames            = [];
    var apiScenes           = [];
    var apiCameras          = [];
    var apiComposers        = [];
    var apiViewports	    = [];
    var apiRenderers        = [];
    var apiRenderTargets    = [];
    var apiSystems          = [];
    var apiEntityManager    = null;

    if (objectEditor.imageFactory) {
        apiImageFactory = R3.D3.API.ImageFactory.FromObjectImageFactory(objectEditor.imageFactory);
    }

    if (objectEditor.games) {
        apiGames = objectEditor.games.map(
            function(objectGame){
                return R3.D3.API.Game.FromObjectGame(objectGame);
            }
        );
    }

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

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

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

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

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

    if (objectEditor.renderTargets) {
        apiRenderTargets = objectEditor.renderTargets.map(
            function(objectRenderTarget){
                return R3.D3.API.RenderTarget.FromObjectComponent(objectRenderTarget);
            }
        );
    }

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

    if (objectEditor.entityManager) {
        apiEntityManager = R3.API.EntityManager.FromObjectEntityManager(objectEditor.entityManager);
    }
    
    return new R3.D3.API.Editor(
        objectEditor.id,
        objectEditor.name,
        objectEditor.baseUrl,
        objectEditor.path,
        apiImageFactory,
        apiGames,
        apiScenes,
        apiCameras,
        apiComposers,
        apiViewports,
        apiRenderers,
        apiRenderTargets,
        apiSystems,
        apiEntityManager,
        objectEditor.allSelected,
        objectEditor.selectedObjects,
		objectEditor.parentEntity
    );
};