/**
 * Project      : AMDA-NG
 * Name         : Download.js
 * Description  : Download Request Business Object Definition
 * @class amdaModel.Download

 * @extends amdaModel.AmdaTimeObject 

 * @author myriam
 * @version $Id: Download.js 2068 2014-02-06 11:27:38Z elena $

 */

Ext.define('amdaModel.DownloadConfig', {

    singleton: true,

    defaultValues: {
        timeformat: 'YYYY-MM-DDThh:mm:ss',
        timeformatTT: 'YYYY-MM-DDThh:mm:ss',
        fileformat: 'ASCII',
        fileformatTT: 'text',
        filecompress: 'tar+gzip',
        filecompressTT: 'tar+gzip',

        filestructure: '0'

    },

    timeformatData: [
        ['YYYY-MM-DDThh:mm:ss', 'YYYY-MM-DDThh:mm:ss.ms', 'ISO format with msecs'],

        ['DOY TIME', 'YYYYDOYhhmmssms', 'Day-Of-Year, 1 Jan => DOY = 1'],

        ['Timestamp', 'Seconds from 1970', 'Total of seconds from the Unix Epoch on January 1st, 1970 at UTC.'],
        ['YYYY MM DD hh mm ss', 'YYYY MM DD hh mm ss ms', 'date with spaces'],
        ['Timestamp-with-milliseconds', 'Seconds from 1970 with ms', 'Total of seconds from the Unix Epoch with milliseconds.']
    ],
    fileformatData: [
        ['ASCII', 'ASCII'],
        ['vot', 'VOTable'],
        ['cdf', 'CDF'],
        ['json', 'JSON']
    ],
    fileformatTTData: [
        ['text', 'plain text'],
        ['vot', 'VOTable'],
        ['space', 'HPEvent']
    ],
    filecompressData: [
        ['zip', 'zip'],
        ['tar+gzip', 'tar+gzip']
    ],
    filecompressTTData: [
        ['zip', 'zip'],
        ['tar+gzip', 'tar+gzip'],
        ['none', 'none']
    ],
    filestructureData: [
        ['0', 'All In One File'],
        ['1', 'One File Per Time Interval'],
        ['2', 'One File Per Param/Interval']
    ]

});

Ext.define('amdaModel.Download', {

    extend: 'amdaModel.AmdaTimeObject',

    requires: [
        "amdaModel.DownloadParam"
    ],

    fields: [
        { name: 'type', type: 'string', defaultValue: 'Download' },
        { name: 'downloadSrc', type: 'string' },
        { name: 'timeformat', type: 'string', defaultValue: amdaModel.DownloadConfig.defaultValues.timeformat },
        { name: 'timeformatTT', type: 'string', defaultValue: amdaModel.DownloadConfig.defaultValues.timeformatTT },
        { name: 'filestructure', type: 'string', defaultValue: amdaModel.DownloadConfig.defaultValues.filestructure },

        { name: 'refparamSampling', type: 'boolean', defaultValue: true },

        { name: 'separateInfoFile', type: 'boolean', defaultValue: false },
        { name: 'sampling', type: 'float', defaultValue: '600' },
        { name: 'scientificformat', type: 'boolean', defaultValue: true },
        { name: 'fileprefix', type: 'string' },
        { name: 'fileformat', type: 'string', defaultValue: amdaModel.DownloadConfig.defaultValues.fileformat },
        { name: 'fileformatTT', type: 'string', defaultValue: amdaModel.DownloadConfig.defaultValues.fileformatTT },
        { name: 'compression', type: 'string', defaultValue: amdaModel.DownloadConfig.defaultValues.filecompress },
        { name: 'compressionTT', type: 'string', defaultValue: amdaModel.DownloadConfig.defaultValues.filecompressTT },
        { name: 'last_update', type: 'int', defaultValue: 0 }
    ],

    associations: [{
        type: 'hasMany',
        model: 'amdaModel.DownloadParam',
        name: 'params'
    }],

    propertiesToCopy: 'id,name,downloadSrc,refparamSampling,separateInfoFile,sampling,scientificformat,list,timeformat,timeformatTT,filestructure,fileprefix,fileformat,fileformatTT,compression,compressionTT',

    constructor: function () {

        var me = this;
        me.callParent(arguments);
        if ((arguments.length > 0) && arguments[0]) {
            if (arguments[0].list)
                me.loadParams(arguments[0].list);
        }
        this.dirty = false;
    },

    loadParams: function (params) {

        /* Compatability mode */

        Ext.each(params, function (param, index) {

            if (param.hasOwnProperty('is-init')) {
                return;
            }
            params[index]['dim1-sum-type'] = param['dim1-is-range'] ? 1 : 0;
            params[index]['dim1-min-value'] = param['dim1-min-range'];
            params[index]['dim1-max-value'] = param['dim1-max-range'];
            params[index]['dim2-sum-type'] = param['dim2-is-range'] ? 1 : 0;
            params[index]['dim2-min-value'] = param['dim2-min-range'];
            params[index]['dim2-max-value'] = param['dim2-max-range'];
            params[index]['is-init'] = true;
        });
        this.params().loadData(params);
    },

    isDirty: function () {

        if (this.dirty)
            return true;

        var d = false;

        this.params().each(function (param, index) {

            if (param.dirty)
                d = true;
        });
        return d;
    },

    getJsonValues: function () {

        var myValues = new Object();
        myValues.nodeType = 'download'; //amdaModel.DownloadNode.nodeType;
        myValues.type = this.get('type');
        myValues.downloadSrc = this.get('downloadSrc');
        myValues.name = this.get('name');
        //Data download	 
        if (myValues.downloadSrc === '0') { // Data download 
            myValues.filestructure = this.get('filestructure');
            myValues.refparamSampling = this.get('refparamSampling');
            myValues.separateInfoFile = this.get('separateInfoFile');
            myValues.scientificformat = this.get('scientificformat');
            myValues.sampling = this.get('sampling');
            myValues.fileprefix = this.get('fileprefix');

            myValues.timesrc = this.get('timesrc');
            // if there's at least one timeTable in case of Download data
            if (this.get('timesrc') == amdaModel.AmdaTimeObject.inputTimeSrc[0] && this.get('timeTables') && this.get('timeTables').length) {
                // get complete timeTables collection
                var timeTables = this.get('timeTables'); // init an empty array for timeTables
                myValues.timeTables = [];
                // for each interval record

                Ext.Array.each(timeTables, function (item, index, all) {

                    // get Json simplified value
                    if (!item.$className) {
                        myValues.timeTables[index] = { timeTableName: item.timeTableName, id: item.id };
                    }
                    // get Json simplified value 
                    else {
                        myValues.timeTables[index] = item.getJsonValues();
                    }
                });
            } else {

                myValues.startDate = Ext.Date.format(this.get('startDate'), 'Y-m-d\\TH:i:s.u');	
                myValues.stopDate =  Ext.Date.format(this.get('stopDate'), 'Y-m-d\\TH:i:s.u');	

                myValues.durationDay = this.get('durationDay');
                myValues.durationHour = this.get('durationHour');
                myValues.durationMin = this.get('durationMin');
                myValues.durationSec = this.get('durationSec');

                myValues.durationMs = this.get('durationMs');

            }

            // if there's at least one parameter
            myValues.list = []

            this.params().each(function (param, index) {

                myValues.list[index] = param.getJsonValues();

            });

            myValues.fileformat = this.get('fileformat');
            myValues.timeformat = this.get('timeformat');
            myValues.compression = this.get('compression');
        }
        // TT download
        else if (myValues.downloadSrc === '1') {
            // if there's at least one timeTable
            if (this.get('timeTables') && this.get('timeTables').length) {
                var list = this.get('timeTables');
                myValues.list = [];

                Ext.each(list, function (item, index) {

                    var tt = new Object();
                    tt.name = item.get('name');
                    tt.id = item.get('id');
                    myValues.list[index] = tt;
                });
            }
            myValues.fileformat = this.get('fileformatTT');
            myValues.timeformat = this.get('timeformatTT');
            myValues.compression = this.get('compressionTT');
        }
        // fits images download
        else {
            myValues.list = [];
            if (this.get('list') && this.get('list').length)

                Ext.each(this.get('list'), function (item, index) {

                    var image = new Object();
                    image.name = item['name'];
                    image.url = item['url'];
                    myValues.list[index] = image;
                });
            myValues.compression = this.get('compression');
        }
        myValues.leaf = true;
        //   myValues.nodeType = amdaModel.PlotNode.nodeType;
        return myValues;
    }
});