/** 
 * Project   : AMDA-NG
 * Name      : PlotModule.js
 * @class    amdaDesktop.PlotModule
 * @extends  amdaDesktop.InteractiveModule

 * @brief    New Plot Module controller definition 
 * @author   Benjamin Renard
 * $Id: PlotModule.js benjamin $

 */

Ext.define('amdaDesktop.PlotModule', {

    extend: 'amdaDesktop.InteractiveModule',

    requires: [
        'amdaUI.PlotUI',
        'amdaPlotObj.MultiplotRequestObject',
        'amdaModel.MultiplotNode',
        'amdaUI.PlotTabResultUI',
        'amdaPlotComp.PlotPreviewUI',
        'amdaUI.MultiPlotUI'
    ],

    contentId: 'plotUI',
    linkedNode: null,

    panelResultInstance: null,

    /**

     * @cfg {String} data models
     * @required
     */

    nodeDataModel: 'amdaModel.MultiplotNode',

    /**
     * @cfg {String} window definitions
     * @required
     */

    width: 650,

    height: 670,

    uiType: 'newPanelPlot',
    helpTitle: 'Help on Plot Module',
    helpFile: 'plotHelp',

    plotResultWindowsManager: new Ext.AbstractManager(),

    multiPlotWin: null,

    computeResultWindowSize: function (panelResult) {

        var size = panelResult.getImageSize();

        size.width += 30;

        size.height += 95;
        return size;
    },

    computePreviewWindowSize: function (previewContent) {

        var size = previewContent.getImageSize();

        size.width += 30;

        size.height += 100;

        return size;
    },

    updateInteractiveSession: function (session, newplot, panelId_, time_) {

        var me = this;

        Ext.each(session.result, function (tabResult, index) {

            if (logExecTime && tabResult.exectime) {

                console.log("CMD EXEC TIME FOR " + tabResult.plot + " = " + tabResult.exectime + "ms");

            }

            if (tabResult.preview) {
                var plotPreviewConfig = {

                    folder: session.folder,
                    plotFile: tabResult.plot,
                    context: tabResult.context,

                    time: time_,
                    panelId: panelId_,

                    interactiveId: tabResult.id

                };
                me.updatePreview(plotPreviewConfig);
                return;
            }

            var winResultId = tabResult.id + "-win";

            var winResult = me.getWindowResult(winResultId);

            var plotTabConfig = {

                folder: session.folder,
                plotFile: tabResult.plot,
                context: tabResult.context,
                interactiveId: tabResult.id,

                isInterval: tabResult.isInterval,

                ttName: tabResult.ttName,
                ttIndex: tabResult.ttIndex,
                ttNbIntervals: tabResult.ttNbIntervals,
                ttFileIndex: tabResult.ttFileIndex,

                multiplot: tabResult.multiplot

            };

            if (winResult == null) {
                var x = 50 + tabResult.index * 50;
                var y = 100 + tabResult.index * 20;
                //create new result win
                var panelResult = new amdaUI.PlotTabResultUI(plotTabConfig);

                me.panelResultInstance = panelResult;

                var size = me.computeResultWindowSize(panelResult);

                var win = myDesktopApp.getDesktop().createWindow({

                    id: tabResult.id + "-win",
                    title: tabResult.title,
                    width: size.width,

                    height: size.height,

                    x: x,
                    y: y,

                    layout: 'fit',

                    items: [
                        panelResult

                    ],
                    listeners: {

                        scope: me,
                        beforeclose: function (win, opt) {

                            me.plotResultWindowsManager.unregister(win);

                        },

                        afterrender: function (win, opt) {

                            win.getPanelResult().updateConfig(tabResult.title, tabResult.multiplot);

                        }
                    },

                    getPanelResult: function () {

                        return panelResult;

                    },

                    updateTitle: function (multiplot) {

                        win.setTitle(tabResult.title + (multiplot ? ' - Synchronized to multiplot' : ''));

                    }
                });
                win.show();
                me.plotResultWindowsManager.register(win);
            }
            else {
                //update result

                winResult.getPanelResult().updateConfig(tabResult.title, tabResult.multiplot);

                winResult.getPanelResult().updatePlotImage(plotTabConfig, newplot);

                //update window size => not done see https://projects.irap.omp.eu/issues/9010
                //var size = me.computeResultWindowSize(winResult.getPanelResult());
                //winResult.setSize(size.width, size.height);

                winResult.toFront();
            }
        });

    },

    closeInteractiveSession: function () {

        var me = this;
        this.plotResultWindowsManager.each(function (key, value, length) {
            value.close();
        });

        if (this.multiPlotWin) {
            this.multiPlotWin.close();
        }

    },

    updatePlotResultTitle: function (tabIndex, title) {
        var winResultId = 'plot_' + tabIndex + '-win';

        var winResult = this.getWindowResult(winResultId);
        if (winResult) {
            winResult.setTitle(title);
            myDesktopApp.getDesktop().taskbar.windowBar.items.each(function (item) {
                if (winResult == item.win) {
                    item.setText(title);
                }

            });

        }
    },

    updatePreview: function (plotPreviewConfig) {

        var winPreviewId = "plot-preview-win";

        var winPreview = this.getWindowResult(winPreviewId);

        if (winPreview == null) {
            //create new preview win
            var previewContent = new amdaPlotComp.PlotPreviewUI(plotPreviewConfig);

            previewContent.setPanelResultInstance(this.panelResultInstance);
            //previewContent.setPanelId

            var size = this.computePreviewWindowSize(previewContent);

            var win = myDesktopApp.getDesktop().createWindow({

                id: winPreviewId,
                title: 'Plot Preview',
                width: size.width,

                height: size.height,
                layout: 'fit',

                items: [
                    previewContent

                ],
                listeners: {

                    scope: this,
                    beforeclose: function (win, opt) {

                        this.plotResultWindowsManager.unregister(win);
                    }
                },

                getPreviewContent: function () {

                    return previewContent;
                }
            });
            win.show();
            this.plotResultWindowsManager.register(win);
        }
        else {
            //update result
            winPreview.getPreviewContent().updatePlotImage(plotPreviewConfig);
            //update window size
            var size = this.computePreviewWindowSize(winPreview.getPreviewContent());
            winPreview.setSize(size.width, size.height);
            winPreview.toFront();
        }

    },

    getWindowResult: function (winResultId) {
        if (!this.plotResultWindowsManager.get(winResultId)) return null;
        return this.plotResultWindowsManager.get(winResultId);

    },

    setTimeInterval: function (timeObj) {
        var me = this;

        var desktop = this.app.getDesktop();
        var win = desktop.getWindow(this.id);
        if (win) {
            me.getUiContent().setTimeFromData(timeObj);
            win.show();
        }
        else {
            this.createWindow(function () {
                me.getUiContent().setTimeFromData(timeObj);
            });
        }
    },

    addParameter: function (paramNode) {

        var me = this;
        var desktop = this.app.getDesktop();
        var win = desktop.getWindow(this.id);
        if (win) {
            me.getUiContent().addParameter(paramNode, false);
            win.show();
        }
        else {
            this.createWindow(function () {
                me.getUiContent().addParameter(paramNode, true);
            });
        }

    },

    editPlot: function (plotNode) {

        var me = this;
        var desktop = this.app.getDesktop();
        var win = desktop.getWindow(this.id);
        if (win) {
            // Plot UI is opened => add plot in a new tab

            me.linkedNode.get('object').plots().add(plotNode);

            me.getUiContent().editPlot(plotNode);
            win.show();
        }
        else {
            // Plot UI is closed

            this.createWindow(null, function () {

                //This is the onAfterCreateObject callback
                //Add plot node to the multiplot object
                me.linkedNode.get('object').plots().removeAll();
                me.linkedNode.get('object').plots().add(plotNode);
            });
        }

    },

    syncAfterRename: function (renamedNode) {

        var me = this;
        var desktop = this.app.getDesktop();
        var win = desktop.getWindow(this.id);
        if (win) {
            me.getUiContent().updateTabs();

            me.getUiContent().updateRequestName(renamedNode);

        }

    },

    showMultiplotWin: function () {
        var me = this;

        var desktop = this.app.getDesktop();
        var win = desktop.getWindow(this.id);

        if (!win) {
            return;
        }

        if (!this.multiPlotWin) {
            var multiPlotPanel = Ext.create('amdaUI.MultiPlotUI',
                {
                    plotWin: me.getUiContent()
                }
            );
            this.multiPlotWin = myDesktopApp.getDesktop().createWindow({
                id: "multiplot-win",
                title: "Multi Plot Manager",
                width: 320,
                height: 320,
                minHeight: 300,
                minWidth: 320,
                layout: 'fit',
                items: [
                    multiPlotPanel
                ],
                listeners: {
                    beforeclose: function (win, opt) {
                        me.multiPlotWin = null;
                        me.getUiContent().enableSinglePlot(true);
                        me.plotResultWindowsManager.each(function (key, value, length) {
                            value.getPanelResult().updateConfig(value.getPanelResult().plotName, false);
                        });
                    }
                }
            });
        }

        this.getUiContent().enableSinglePlot(false);

        this.multiPlotWin.show();

    },

    refreshMultiPlot: function () {

        if (this.multiPlotWin) {
            this.multiPlotWin.items.items[0].refreshMultiPlot();
        }

        this.getUiContent().enableSinglePlot(!this.isMultiPlot());

    },

    isMultiPlot: function () {

        return this.multiPlotWin && !this.multiPlotWin.isHidden();

    },

    editInDownloadModule: function (plotNode) {

        var plotValues = plotNode.get('object').getJsonValues();
        var downloadValues = new Object();
        downloadValues.timesrc = plotValues.timesrc;
        downloadValues.startDate = plotValues.startDate;
        downloadValues.stopDate = plotValues.stopDate;
        downloadValues.durationDay = plotValues.durationDay;
        downloadValues.durationHour = plotValues.durationHour;
        downloadValues.durationMin = plotValues.durationMin;
        downloadValues.durationSec = plotValues.durationSec;

        downloadValues.durationMs = plotValues.durationMs;

        if (plotValues.timeTables)
            downloadValues.timeTables = plotValues.timeTables;
        downloadValues.list = [];
        plotNode.get('object').panels().each(function (panel) {
            panel.params().each(function (param) {

                paramObj = param.getJsonValues();
                paramObj.id = "";
                downloadValues.list.push(paramObj);

            });
        });
        myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id, true, function (module) {
            module.editFromJsonData(downloadValues);
        });

    }

});