//----------------------------------------------------------------------------
//  Copyright (C) 2013  The IPython Development Team
//
//  Distributed under the terms of the BSD License.  The full license is in
//  the file COPYING, distributed as part of this software.
//----------------------------------------------------------------------------

//============================================================================
// WidgetModel, WidgetView, and WidgetManager
//============================================================================
/**
 * Base Widget classes
 * @module IPython
 * @namespace IPython
 * @submodule widget
 */

"use strict";

// Use require.js 'define' method so that require.js is intelligent enough to
// syncronously load everything within this file when it is being 'required' 
// elsewhere.
define(["components/underscore/underscore-min",
         "components/backbone/backbone-min",
        ], function(){

    // Only run once on a notebook.
    if (IPython.notebook.widget_manager == undefined) {

        //--------------------------------------------------------------------
        // WidgetModel class
        //--------------------------------------------------------------------
        var WidgetModel = Backbone.Model.extend({
            constructor: function(comm_manager, comm, widget_view_types) {
                this.comm_manager = comm_manager;
                this.widget_view_types = widget_view_types;
                this.pending_msgs = 0;
                this.msg_throttle = 3;
                this.msg_buffer = null;
                this.views = {};

                // Remember comm associated with the model.
                this.comm = comm;
                comm.model = this;

                // Hook comm messages up to model.
                comm.on_close($.proxy(this.handle_comm_closed, this));
                comm.on_msg($.proxy(this.handle_comm_msg, this));

                return Backbone.Model.apply(this);
            },


            update_other_views: function(caller) {
                this.last_modified_view = caller;
                this.save(this.changedAttributes(), {patch: true});

                for (var output_area in this.views) {
                    var views = this.views[output_area];
                    for (var view_index in views) {
                        var view = views[view_index];
                        if (view !== caller) {
                            view.update();    
                        }
                    }
                }
            },


            handle_status: function (output_area, msg) {
                //execution_state : ('busy', 'idle', 'starting')
                if (msg.content.execution_state=='idle') {
                    
                    // Send buffer if this message caused another message to be
                    // throttled.
                    if (this.msg_buffer != null) {
                        if (this.msg_throttle == this.pending_msgs && 
                            this.msg_buffer.length > 0) {
                            
                            var output_area = this._get_msg_output_area(msg);
                            var callbacks = this._make_callbacks(output_area);
                            var data = {sync_method: 'update', sync_data: this.msg_buffer};
                            comm.send(data, callbacks);   
                            this.msg_buffer = null;
                        } else {

                            // Only decrease the pending message count if the buffer
                            // doesn't get flushed (sent).
                            --this.pending_msgs;
                        }
                    }
                }
            },


            // Custom syncronization logic.
            handle_sync: function (method, options) {
                var model_json = this.toJSON();

                // Only send updated state if the state hasn't been changed 
                // during an update.
                if (!this.updating) {
                    if (this.pending_msgs >= this.msg_throttle) {
                        // The throttle has been exceeded, buffer the current msg so
                        // it can be sent once the kernel has finished processing 
                        // some of the existing messages.
                        if (method=='patch') {
                            if (this.msg_buffer == null) {
                                this.msg_buffer = $.extend({}, model_json); // Copy
                            }
                            for (var attr in options.attrs) {
                                this.msg_buffer[attr] = options.attrs[attr];
                            }
                        } else {
                            this.msg_buffer = $.extend({}, model_json); // Copy
                        }

                    } else {
                        // We haven't exceeded the throttle, send the message like 
                        // normal.  If this is a patch operation, just send the 
                        // changes.
                        var send_json = model_json;
                        if (method=='patch') {
                            send_json = {};
                            for (var attr in options.attrs) {
                                send_json[attr] = options.attrs[attr];
                            }
                        }

                        var data = {sync_method: method, sync_data: send_json};
                        var output_area = this.last_modified_view.output_area;
                        var callbacks = this._make_callbacks(output_area);
                        this.comm.send(data, callbacks);    
                        this.pending_msgs++;
                    }
                }
                
                // Since the comm is a one-way communication, assume the message 
                // arrived.
                return model_json;
            },


            // Handle incomming comm msg.
            handle_comm_msg: function (msg) {
                var method = msg.content.data.method;
                switch (method){
                    case 'display':

                        // Try to get the cell index.
                        var output_area = this._get_output_area(msg.parent_header.msg_id);
                        if (output_area == null) {
                            console.log("Could not determine where the display" + 
                                " message was from.  Widget will not be displayed")
                        } else {
                            this.display_view(msg.content.data.view_name, 
                            msg.content.data.parent,
                            output_area);
                        }
                        break;
                    case 'update':
                        this.handle_update(msg.content.data.state);
                        break;
                }
            },


            // Handle when a widget is updated via the python side.
            handle_update: function (state) {
                this.updating = true;
                try {
                    for (var key in state) {
                        if (state.hasOwnProperty(key)) {
                            if (key == "_css"){
                                this.css = state[key];
                            } else {
                                this.set(key, state[key]); 
                            }
                        }
                    }
                    this.id = this.comm.comm_id;
                    this.save();
                } finally {
                    this.updating = false;
                }
            },


            // Handle when a widget is closed.
            handle_comm_closed: function (msg) {
                for (var output_area in this.views) {
                    var views = this.views[output_area];
                    for (var view_index in views) {
                        var view = views[view_index];
                        view.remove();
                    }
                }
            },


            // Create view that represents the model.
            display_view: function (view_name, parent_comm_id, output_area) {
                var new_views = [];

                var displayed = false;
                if (parent_comm_id != undefined) {
                    var parent_comm = this.comm_manager.comms[parent_comm_id];
                    var parent_model = parent_comm.model;
                    var parent_views = parent_model.views[output_area];
                    for (var parent_view_index in parent_views) {
                        var parent_view = parent_views[parent_view_index];
                        if (parent_view.display_child != undefined) {
                            var view = this._create_view(view_name, output_area);
                            new_views.push(view);
                            parent_view.display_child(view);
                            displayed = true;
                        }
                    }
                }

                if (!displayed) {
                    // No parent view is defined or exists.  Add the view's 
                    // element to cell's widget div.
                    var view = this._create_view(view_name, output_area);
                    new_views.push(view);
                    this._get_widget_area_element(output_area, true)
                        .append(view.$el);
                
                }

                for (var view_index in new_views) {
                    var view = new_views[view_index];
                    view.update();
                }
            },


            // Create a view
            _create_view: function (view_name, output_area) {
                var view = new this.widget_view_types[view_name]({model: this});
                view.render();
                if (this.views[output_area]==undefined) {
                    this.views[output_area] = []
                }
                this.views[output_area].push(view);
                view.output_area = output_area;

                // Handle when the view element is remove from the page.
                var that = this;
                view.$el.on("remove", function(){ 
                    var index = that.views[output_area].indexOf(view);
                    if (index > -1) {
                        that.views[output_area].splice(index, 1);
                    }
                    view.remove(); // Clean-up view 
                    if (that.views[output_area].length()==0) {
                        delete that.views[output_area];
                    }

                    // Close the comm if there are no views left.
                    if (that.views.length()==0) {
                        that.comm.close();     
                    }
                });
                return view;
            },


            // Build a callback dict.
            _make_callbacks: function (output_area) {
                var callbacks = {};
                if (output_area != null) {
                    var that = this;
                    callbacks = {
                        iopub : {
                            output : $.proxy(output_area.handle_output, output_area),
                            clear_output : $.proxy(output_area.handle_clear_output, output_area),
                            status : function(msg){
                                that.handle_status(output_area, msg);
                            },
                            get_output_area : function() {
                                if (that.last_modified_view != undefined && 
                                    that.last_modified_view.output_area != undefined) {
                                    return that.last_modified_view.output_area;
                                } else {
                                    return null
                                }
                            },
                        },
                    };
                }
                return callbacks;
            },


            // Get the output area corresponding to the msg_id.
            // output_area is an instance of Ipython.OutputArea
            _get_output_area: function (msg_id) {
                
                // First, guess cell.execute triggered
                var cells = IPython.notebook.get_cells();
                for (var cell_index in cells) {
                    if (cells[cell_index].last_msg_id == msg_id) {
                        var cell = IPython.notebook.get_cell(cell_index)
                        return cell.output_area;
                    }
                }

                // Second, guess widget triggered
                var callbacks = this.comm_manager.kernel.get_callbacks_for_msg(msg_id)
                if (callbacks != undefined && callbacks.iopub != undefined && callbacks.iopub.get_output_area != undefined) {
                    var output_area = callbacks.iopub.get_output_area();
                    if (output_area != null) {
                        return output_area;
                    }
                }
                
                // Not triggered by a widget or a cell
                return null;
            },

            // Gets widget output area (as a JQuery element) from the 
            // output_area (Ipython.OutputArea instance)
            _get_widget_area_element: function (output_area, show) {
                var widget_area = output_area.element
                    .parent() // output_wrapper
                    .parent() // cell
                    .find('.widget-area');
                if (show) { widget_area.show(); }
                return widget_area.find('.widget-subarea');
            },

        });


        //--------------------------------------------------------------------
        // WidgetView class
        //--------------------------------------------------------------------
        var WidgetView = Backbone.View.extend({
            
            initialize: function() {
                this.visible = true;
                this.model.on('change',this.update,this);
                this._add_class_calls = this.model.get('_add_class')[0];
                this._remove_class_calls = this.model.get('_remove_class')[0];
            },
            
            update: function() {
                if (this.model.get('visible') != undefined) {
                    if (this.visible != this.model.get('visible')) {
                        this.visible = this.model.get('visible');
                        if (this.visible) {
                            this.$el.show();
                        } else {
                            this.$el.hide();
                        }
                    }
                }

                if (this.model.css != undefined) {
                    for (var selector in this.model.css) {
                        if (this.model.css.hasOwnProperty(selector)) {
                            
                            // Apply the css traits to all elements that match the selector.
                            var elements = this.get_selector_element(selector);
                            if (elements.length > 0) {
                                var css_traits = this.model.css[selector];    
                                for (var css_key in css_traits) {
                                    if (css_traits.hasOwnProperty(css_key)) {
                                        elements.css(css_key, css_traits[css_key]);
                                    }
                                }
                            }
                        }
                    }
                }

                var add_class = this.model.get('_add_class');
                if (add_class != undefined){
                    var add_class_calls = add_class[0];
                    if (add_class_calls > this._add_class_calls) {
                        this._add_class_calls = add_class_calls;
                        var elements = this.get_selector_element(add_class[1]);
                        if (elements.length > 0) {
                            elements.addClass(add_class[2]);
                        }
                    }    
                }

                var remove_class = this.model.get('_remove_class');
                if (remove_class != undefined){
                    var remove_class_calls = remove_class[0];
                    if (remove_class_calls > this._remove_class_calls) {
                        this._remove_class_calls = remove_class_calls;
                        var elements = this.get_selector_element(remove_class[1]);
                        if (elements.length > 0) {
                            elements.removeClass(remove_class[2]);
                        }
                    }    
                }
            },

            get_selector_element: function(selector) {
                // Get the elements via the css selector.  If the selector is
                // blank, apply the style to the $el_to_style element.  If
                // the $el_to_style element is not defined, use apply the 
                // style to the view's element.
                var elements = this.$el.find(selector);
                if (selector=='') {
                    if (this.$el_to_style == undefined) {
                        elements = this.$el;
                    } else {
                        elements = this.$el_to_style;
                    }
                }
                return elements;
            },
        });


        //--------------------------------------------------------------------
        // WidgetManager class
        //--------------------------------------------------------------------
        var WidgetManager = function(comm_manager){
            this.comm_manager = comm_manager;
            this.widget_model_types = {};
            this.widget_view_types = {};
            
            var that = this;
            Backbone.sync = function(method, model, options, error) {
                var result = model.handle_sync(method, options);
                if (options.success) {
                  options.success(result);
                }
            }; 
        }


        WidgetManager.prototype.register_widget_model = function (widget_model_name, widget_model_type) {
            // Register the widget with the comm manager.  Make sure to pass this object's context
            // in so `this` works in the call back.
            this.comm_manager.register_target(widget_model_name, $.proxy(this.handle_com_open, this));
            this.widget_model_types[widget_model_name] = widget_model_type;
        }


        WidgetManager.prototype.register_widget_view = function (widget_view_name, widget_view_type) {
            this.widget_view_types[widget_view_name] = widget_view_type;
        }


        WidgetManager.prototype.handle_com_open = function (comm, msg) {
            var widget_type_name = msg.content.target_name;
            var widget_model = new this.widget_model_types[widget_type_name](this.comm_manager, comm, this.widget_view_types);
        }


        //--------------------------------------------------------------------
        // Init code
        //--------------------------------------------------------------------
        IPython.WidgetManager = WidgetManager;
        IPython.WidgetModel = WidgetModel;
        IPython.WidgetView = WidgetView;

        IPython.notebook.widget_manager = new WidgetManager(IPython.notebook.kernel.comm_manager);    

    };
});