/**
 * Project      : AMDA-NG
 * Name         : PlotParamObject.js
 * @class   amdaPlotObj.PlotParamObject
 * @extends amdaModel.RequestParamObject
 * @brief   Plot Param Business Object Definition 
 * @author  Benjamin Renard
 * @version $Id: PlotParamObject.js benjamin $
 ******************************************************************************
 *    FT Id     :   Date   : Name - Description
 ******************************************************************************
 *	:           :17/08/2015: BRE  - file creation
 */
 
 		
Ext.define('amdaPlotObj.PlotParamObject', {
	extend: 'amdaModel.RequestParamObject',
	
	requires: [
	           'amdaPlotObj.PlotObjectConfig',
	           'amdaPlotObj.PlotSerieObject',
		   'amdaPlotObj.PlotOrbitSerieObject',
	           'amdaPlotObj.PlotSpectroObject',
	           'amdaPlotObj.PlotStatusBarObject',
	           'amdaPlotObj.PlotTickBarObject',
	           'amdaPlotObj.PlotInstantSerieObject',
	           'amdaPlotObj.PlotInstantSpectroObject',
		   'amdaPlotObj.PlotIntervalsObject'
	],
	
	fields : [
                  {name: 'param-type', type: 'string', defaultValue: 'param'}, //Available types: param, ttcat
                  {name: 'param-ttcat-name', type: 'string'},
	          {name: 'param-drawing-type', type: 'string'},
	          {name: 'param-drawing-object', type: 'auto'}
    ],
    
    associations : [
              {
            	  type  : 'belongsTo',
                  model : 'amdaPlotObj.PlotPanelObject',
                  getterName : 'Panel'
              }
    ],
    
    constructor: function(){
        var me = this;
        me.callParent(arguments);
        if ((arguments.length > 0) && arguments[0])
        {
        	if (arguments[0]['param-drawing-object'])
        		me.loadDrawingObject(arguments[0]['param-drawing-object']);
        }
        this.dirty = false;
    },
    
    loadDrawingObject: function(drawing)
    {
    	var drawingObject = this.get('param-drawing-object');
    	if (drawingObject == null)
    		return;
    	this.set('param-drawing-object', this.createDrawingObjectByType(this.get('param-drawing-type'), drawing));
    	drawingObject.dirty = false;
	 
    },
    
    createDrawingObjectByType : function(drawingType, data)
    {
    	//Create drawing object in relation with the drawing type
    	switch (drawingType)
    	{
    	case 'serie' :
    		return new amdaPlotObj.PlotSerieObject(data);
		case 'orbit-serie' :
			return new amdaPlotObj.PlotOrbitSerieObject(data);
    	case 'spectro' :
    		return new amdaPlotObj.PlotSpectroObject(data);
    	case 'status-bar' :
    		return new amdaPlotObj.PlotStatusBarObject(data);
    	case 'tick-bar' :
    		return new amdaPlotObj.PlotTickBarObject(data);
    	case 'iserie' :
    		return new amdaPlotObj.PlotInstantSerieObject(data);
    	case 'ispectro' :
    		return new amdaPlotObj.PlotInstantSpectroObject(data);
	case 'intervals' :
		return new amdaPlotObj.PlotIntervalsObject(data);
    	default :
    		return null;
    	}
    },
    
    changeDrawingType: function(drawingType, drawData)
    {
    	if (drawingType == this.get('param-drawing-type'))
    		return;
    	
    	this.set('param-drawing-type', drawingType);
    	
    	this.set('param-drawing-object', this.createDrawingObjectByType(drawingType));
    	
    	//Set drawing object to default status
    	if (this.get('param-drawing-object') != null)
    	{
    		this.get('param-drawing-object').setDefaultValues();
    		if (this.get('param-drawing-object').loadFromData && drawData && (drawingType == drawData.type))
    			this.get('param-drawing-object').loadFromData(drawData);
    	}
    },
    
    getAvailableDrawingObjectByPlotType: function(plotType) {
        switch (this.get('param-type'))
        {
        case 'param' :
    	    switch (plotType)
    	    {
    	    case 'timePlot'  :
    	    case 'epochPlot' :
    		return [
    		        {'key' : 'serie', 'value' : 'Serie'},
    		        {'key' : 'spectro', 'value' : 'Spectro'},
    		        {'key' : 'tick-bar', 'value' : 'Tick Bar'},
    		        {'key' : 'status-bar', 'value' : 'Status Bar'}
    		];
    	    case 'xyPlot' :
    		return [
    		        {'key' : 'serie', 'value' : 'Serie'},
    		        {'key' : 'orbit-serie', 'value' : 'Orbit Serie'} 
    		];
    	    case 'instantPlot' :
    		return [
    		        {'key' : 'iserie', 'value' : 'Serie'},
    		        {'key' : 'ispectro', 'value' : 'Spectro'}
    		];
    	    case 'statusPlot' :
    		return [
    		        {'key' : 'status-bar', 'value' : 'Status Bar'}
    		];
    	    case 'tickPlot' :
    		return [
    		        {'key' : 'tick-bar', 'value' : 'Tick Bar'}
    		];
    	    }
            break;
        case 'ttcat':
            switch (plotType)
            {
            case 'timePlot':
                return [
			{'key' : 'intervals', 'value' : 'Intervals'},
                        {'key' : 'serie', 'value' : 'Serie'},
                        {'key' : 'status-bar', 'value' : 'Status Bar'}
                ];
            case 'statusPlot':
                return [
                        {'key' : 'status-bar', 'value' : 'Status Bar'}
                ];
            }
            break;
        }
    	return [];
    },
    
    setDefaultValues: function(drawingType)
    {
    	this.changeDrawingType(drawingType);
    },

    getShortInfo : function(plotType)
    {
    	var availableDrawingObjects = this.getAvailableDrawingObjectByPlotType(plotType);
		var typeName = amdaPlotObj.PlotObjectConfig.getValueByKey(availableDrawingObjects, this.get('param-drawing-type'));
		
		var fullName = '';
		if (this.get('param-type') == 'ttcat') {
			fullName = this.get('param-ttcat-name');
		}
		else {
			fullName = this.getParamFullName();
		}
		
		var info = '';
		
		switch (plotType)
		{
		case 'xyPlot' :
			if (this.get('param-drawing-type') == 'orbit-serie')
			{
				var projection = amdaPlotObj.PlotObjectConfig.getValueByKey(amdaPlotObj.PlotObjectConfig.availableOrbitSerieProjections, this.get('param-drawing-object').get('serie-projection'));
				info = fullName+', '+projection;
			}
			else
				info = fullName+' = f('+this.get('param-drawing-object').get('serie-xaxis-param')+', t)';
			break;
		case 'instantPlot' :
			info = fullName;
			break;
		default :
			info = fullName+' = f(t)';
		}
		
		info += ', '+typeName;
		
		switch (this.get('param-drawing-type'))
		{
		case 'serie' :
			var yAxis = amdaPlotObj.PlotObjectConfig.getValueByKey(amdaPlotObj.PlotObjectConfig.availableYAxes, this.get('param-drawing-object').get('serie-yaxis'));
			info += ', Y '+yAxis;
			break;
		case 'spectro' :
			var yAxis = amdaPlotObj.PlotObjectConfig.getValueByKey(amdaPlotObj.PlotObjectConfig.availableYAxes, this.get('param-drawing-object').get('spectro-yaxis'));
			info += ', Y '+yAxis;
			break;
		}
		
		return info;
    },
    
    isDirty : function()
    {
    	if (this.dirty)
    		return true;
    	if (this.get('param-drawing-object') != null)
    		return this.get('param-drawing-object').dirty;
    	
    	return false;
    },
    
    getJsonValues : function() 
    {
    	var paramValues  = this.callParent(arguments);

    	paramValues['param-type'] = this.get('param-type');
	paramValues['param-ttcat-name'] = this.get('param-ttcat-name');
    	paramValues['param-drawing-type'] = this.get('param-drawing-type');
    	if (this.get('param-drawing-object') != null)
    		paramValues['param-drawing-object'] = this.get('param-drawing-object').getJsonValues();
    	
    	return paramValues;
    }
});