/*jshint maxlen: 500 */
    /**
    * Creates a component to work with an elemment.
    * @class ContentEditable
    * @for ContentEditable
    * @extends Y.Plugin.Base
    * @constructor
    * @module editor
    * @submodule content-editable
    */
 
    var Lang = Y.Lang,
        YNode = Y.Node,
 
        EVENT_CONTENT_READY = 'contentready',
        EVENT_READY = 'ready',
 
        TAG_PARAGRAPH = 'p',
 
        BLUR = 'blur',
        CONTAINER = 'container',
        CONTENT_EDITABLE = 'contentEditable',
        EMPTY = '',
        FOCUS = 'focus',
        HOST = 'host',
        INNER_HTML = 'innerHTML',
        KEY = 'key',
        PARENT_NODE = 'parentNode',
        PASTE = 'paste',
        TEXT = 'Text',
        USE = 'use',
 
    ContentEditable = function() {
        ContentEditable.superclass.constructor.apply(this, arguments);
    };
 
    Y.extend(ContentEditable, Y.Plugin.Base, {
 
        /**
        * Internal reference set when render is called.
        * @private
        * @property _rendered
        * @type Boolean
        */
        _rendered: null,
 
        /**
        * Internal reference to the YUI instance bound to the element
        * @private
        * @property _instance
        * @type YUI
        */
        _instance: null,
 
        /**
        * Initializes the ContentEditable instance
        * @protected
        * @method initializer
        */
        initializer: function() {
            var host = this.get(HOST);
 
            if (host) {
                host.frame = this;
            }
 
            this._eventHandles = [];
 
            this.publish(EVENT_READY, {
                emitFacade: true,
                defaultFn: this._defReadyFn
            });
        },
 
        /**
        * Destroys the instance.
        * @protected
        * @method destructor
        */
        destructor: function() {
            new Y.EventHandle(this._eventHandles).detach();
 
            this._container.removeAttribute(CONTENT_EDITABLE);
        },
 
        /**
        * Generic handler for all DOM events fired by the Editor container. This handler
        * takes the current EventFacade and augments it to fire on the ContentEditable host. It adds two new properties
        * to the EventFacade called frameX and frameY which adds the scroll and xy position of the ContentEditable element
        * to the original pageX and pageY of the event so external nodes can be positioned over the element.
        * In case of ContentEditable element these will be equal to pageX and pageY of the container.
        * @private
        * @method _onDomEvent
        * @param {EventFacade} e
        */
        _onDomEvent: function(e) {
            var xy;
 
            e.frameX = e.frameY = 0;
 
            if (e.pageX > 0 || e.pageY > 0) {
                if (e.type.substring(0, 3) !== KEY) {
                    xy = this._container.getXY();
 
                    e.frameX = xy[0];
                    e.frameY = xy[1];
                }
            }
 
            e.frameTarget = e.target;
            e.frameCurrentTarget = e.currentTarget;
            e.frameEvent = e;
 
            this.fire('dom:' + e.type, e);
        },
 
        /**
        * Simple pass thru handler for the paste event so we can do content cleanup
        * @private
        * @method _DOMPaste
        * @param {EventFacade} e
        */
        _DOMPaste: function(e) {
            var inst = this.getInstance(),
                data = EMPTY, win = inst.config.win;
 
            if (e._event.originalTarget) {
                data = e._event.originalTarget;
            }
 
            if (e._event.clipboardData) {
                data = e._event.clipboardData.getData(TEXT);
            }
 
            if (win.clipboardData) {
                data = win.clipboardData.getData(TEXT);
 
                if (data === EMPTY) { // Could be empty, or failed
                    // Verify failure
                    if (!win.clipboardData.setData(TEXT, data)) {
                        data = null;
                    }
                }
            }
 
            e.frameTarget = e.target;
            e.frameCurrentTarget = e.currentTarget;
            e.frameEvent = e;
 
            if (data) {
                e.clipboardData = {
                    data: data,
                    getData: function() {
                        return data;
                    }
                };
            } else {
                Y.log('Failed to collect clipboard data', 'warn', 'contenteditable');
 
                e.clipboardData = null;
            }
 
            this.fire('dom:paste', e);
        },
 
        /**
        * Binds DOM events and fires the ready event
        * @private
        * @method _defReadyFn
        */
        _defReadyFn: function() {
            var inst = this.getInstance(),
                container = this.get(CONTAINER);
 
            Y.each(
                ContentEditable.DOM_EVENTS,
                function(value, key) {
                    var fn = Y.bind(this._onDomEvent, this),
                        kfn = ((Y.UA.ie && ContentEditable.THROTTLE_TIME > 0) ? Y.throttle(fn, ContentEditable.THROTTLE_TIME) : fn);
 
                    if (!inst.Node.DOM_EVENTS[key]) {
                        inst.Node.DOM_EVENTS[key] = 1;
                    }
 
                    if (value === 1) {
                        if (key !== FOCUS && key !== BLUR && key !== PASTE) {
                            if (key.substring(0, 3) === KEY) {
                                //Throttle key events in IE
                                this._eventHandles.push(container.on(key, kfn, container));
                            } else {
                                this._eventHandles.push(container.on(key, fn, container));
                            }
                        }
                    }
                },
                this
            );
 
            inst.Node.DOM_EVENTS.paste = 1;
 
            this._eventHandles.push(
                container.on(PASTE, Y.bind(this._DOMPaste, this), container),
                container.on(FOCUS, Y.bind(this._onDomEvent, this), container),
                container.on(BLUR, Y.bind(this._onDomEvent, this), container)
            );
 
            inst.__use = inst.use;
 
            inst.use = Y.bind(this.use, this);
        },
 
        /**
        * Called once the content is available in the ContentEditable element and calls the final use call
        * @private
        * @method _onContentReady
        * on the internal instance so that the modules are loaded properly.
        */
        _onContentReady: function(event) {
            if (!this._ready) {
                this._ready = true;
 
                var inst = this.getInstance(),
                    args = Y.clone(this.get(USE));
 
                this.fire(EVENT_CONTENT_READY);
 
                Y.log('On content available', 'info', 'contenteditable');
 
                if (event) {
                    inst.config.doc = YNode.getDOMNode(event.target);
                }
 
                args.push(Y.bind(function() {
                    Y.log('Callback from final internal use call', 'info', 'contenteditable');
 
                    if (inst.EditorSelection) {
                        inst.EditorSelection.DEFAULT_BLOCK_TAG = this.get('defaultblock');
 
                        inst.EditorSelection.ROOT = this.get(CONTAINER);
                    }
 
                    this.fire(EVENT_READY);
                }, this));
 
                Y.log('Calling use on internal instance: ' + args, 'info', 'contentEditable');
 
                inst.use.apply(inst, args);
            }
        },
 
        /**
        * Retrieves defaultblock value from host attribute
        * @private
        * @method _getDefaultBlock
        * @return {String}
        */
        _getDefaultBlock: function() {
            return this._getHostValue('defaultblock');
        },
 
        /**
        * Retrieves dir value from host attribute
        * @private
        * @method _getDir
        * @return {String}
        */
        _getDir: function() {
            return this._getHostValue('dir');
        },
 
        /**
        * Retrieves extracss value from host attribute
        * @private
        * @method _getExtraCSS
        * @return {String}
        */
        _getExtraCSS: function() {
            return this._getHostValue('extracss');
        },
 
        /**
        * Get the content from the container
        * @private
        * @method _getHTML
        * @param {String} html The raw HTML from the container.
        * @return {String}
        */
        _getHTML: function() {
            var html, container;
 
            if (this._ready) {
                container = this.get(CONTAINER);
 
                html = container.get(INNER_HTML);
            }
 
            return html;
        },
 
        /**
        * Retrieves a value from host attribute
        * @private
        * @method _getHostValue
        * @param {attr} The attribute which value should be returned from the host
        * @return {String|Object}
        */
        _getHostValue: function(attr) {
            var host = this.get(HOST);
 
            if (host) {
                return host.get(attr);
            }
        },
 
        /**
        * Set the content of the container
        * @private
        * @method _setHTML
        * @param {String} html The raw HTML to set to the container.
        * @return {String}
        */
        _setHTML: function(html) {
            if (this._ready) {
                var container = this.get(CONTAINER);
 
                container.set(INNER_HTML, html);
            } else {
                //This needs to be wrapped in a contentready callback for the !_ready state
                this.once(EVENT_CONTENT_READY, Y.bind(this._setHTML, this, html));
            }
 
            return html;
        },
 
        /**
        * Sets the linked CSS on the instance.
        * @private
        * @method _setLinkedCSS
        * @param {String} css The linkedcss value
        * @return {String}
        */
        _setLinkedCSS: function(css) {
            if (this._ready) {
                var inst = this.getInstance();
                inst.Get.css(css);
            } else {
                //This needs to be wrapped in a contentready callback for the !_ready state
                this.once(EVENT_CONTENT_READY, Y.bind(this._setLinkedCSS, this, css));
            }
 
            return css;
        },
 
        /**
        * Sets the dir (language direction) attribute on the container.
        * @private
        * @method _setDir
        * @param {String} value The language direction
        * @return {String}
        */
        _setDir: function(value) {
            var container;
 
            if (this._ready) {
                container = this.get(CONTAINER);
 
                container.setAttribute('dir', value);
            } else {
                //This needs to be wrapped in a contentready callback for the !_ready state
                this.once(EVENT_CONTENT_READY, Y.bind(this._setDir, this, value));
            }
 
            return value;
        },
 
        /**
        * Set's the extra CSS on the instance.
        * @private
        * @method _setExtraCSS
        * @param {String} css The CSS style to be set as extra css
        * @return {String}
        */
        _setExtraCSS: function(css) {
            if (this._ready) {
                if (css) {
                    var inst = this.getInstance(),
                        head = inst.one('head');
 
                    if (this._extraCSSNode) {
                        this._extraCSSNode.remove();
                    }
 
                    this._extraCSSNode = YNode.create('<style>' + css + '</style>');
 
                    head.append(this._extraCSSNode);
                }
            } else {
                //This needs to be wrapped in a contentready callback for the !_ready state
                this.once(EVENT_CONTENT_READY, Y.bind(this._setExtraCSS, this, css));
            }
 
            return css;
        },
 
        /**
        * Sets the language value on the instance.
        * @private
        * @method _setLang
        * @param {String} value The language to be set
        * @return {String}
        */
        _setLang: function(value) {
            var container;
 
            if (this._ready) {
                container = this.get(CONTAINER);
 
                container.setAttribute('lang', value);
            } else {
                //This needs to be wrapped in a contentready callback for the !_ready state
                this.once(EVENT_CONTENT_READY, Y.bind(this._setLang, this, value));
            }
 
            return value;
        },
 
        /**
        * Called from the first YUI instance that sets up the internal instance.
        * This loads the content into the ContentEditable element and attaches the contentready event.
        * @private
        * @method _instanceLoaded
        * @param {YUI} inst The internal YUI instance bound to the ContentEditable element
        */
        _instanceLoaded: function(inst) {
            this._instance = inst;
 
            this._onContentReady();
 
            var doc = this._instance.config.doc;
 
            if (!Y.UA.ie) {
                try {
                    //Force other browsers into non CSS styling
                    doc.execCommand('styleWithCSS', false, false);
                    doc.execCommand('insertbronreturn', false, false);
                } catch (err) {}
            }
        },
 
 
        /**
        * Validates linkedcss property
        *
        * @method _validateLinkedCSS
        * @private
        */
        _validateLinkedCSS: function(value) {
            return Lang.isString(value) || Lang.isArray(value);
        },
 
        //BEGIN PUBLIC METHODS
        /**
        * This is a scoped version of the normal YUI.use method & is bound to the ContentEditable element
        * At setup, the inst.use method is mapped to this method.
        * @method use
        */
        use: function() {
            Y.log('Calling augmented use after ready', 'info', 'contenteditable');
 
            var inst = this.getInstance(),
                args = Y.Array(arguments),
                callback = false;
 
            if (Lang.isFunction(args[args.length - 1])) {
                callback = args.pop();
            }
 
            if (callback) {
                args.push(function() {
                    Y.log('Internal callback from augmented use', 'info', 'contenteditable');
 
                    callback.apply(inst, arguments);
                });
            }
 
            return inst.__use.apply(inst, args);
        },
 
        /**
        * A delegate method passed to the instance's delegate method
        * @method delegate
        * @param {String} type The type of event to listen for
        * @param {Function} fn The method to attach
        * @param {String, Node} cont The container to act as a delegate, if no "sel" passed, the container is assumed.
        * @param {String} sel The selector to match in the event (optional)
        * @return {EventHandle} The Event handle returned from Y.delegate
        */
        delegate: function(type, fn, cont, sel) {
            var inst = this.getInstance();
 
            if (!inst) {
                Y.log('Delegate events can not be attached until after the ready event has fired.', 'error', 'contenteditable');
 
                return false;
            }
 
            if (!sel) {
                sel = cont;
 
                cont = this.get(CONTAINER);
            }
 
            return inst.delegate(type, fn, cont, sel);
        },
 
        /**
        * Get a reference to the internal YUI instance.
        * @method getInstance
        * @return {YUI} The internal YUI instance
        */
        getInstance: function() {
            return this._instance;
        },
 
        /**
        * @method render
        * @param {String/HTMLElement/Node} node The node to render to
        * @return {ContentEditable}
        * @chainable
        */
        render: function(node) {
            var args, inst, fn;
 
            if (this._rendered) {
                Y.log('Container already rendered.', 'warn', 'contentEditable');
 
                return this;
            }
 
            if (node) {
                this.set(CONTAINER, node);
            }
 
            container = this.get(CONTAINER);
 
            if (!container) {
                container = YNode.create(ContentEditable.HTML);
 
                Y.one('body').prepend(container);
 
                this.set(CONTAINER, container);
            }
 
            this._rendered = true;
 
            this._container.setAttribute(CONTENT_EDITABLE, true);
 
            args = Y.clone(this.get(USE));
 
            fn = Y.bind(function() {
                inst = YUI();
 
                inst.host = this.get(HOST); //Cross reference to Editor
 
                inst.log = Y.log; //Dump the instance logs to the parent instance.
 
                Y.log('Creating new internal instance with node-base only', 'info', 'contenteditable');
                inst.use('node-base', Y.bind(this._instanceLoaded, this));
            }, this);
 
            args.push(fn);
 
            Y.log('Adding new modules to main instance: ' + args, 'info', 'contenteditable');
            Y.use.apply(Y, args);
 
            return this;
        },
 
        /**
        * Set the focus to the container
        * @method focus
        * @param {Function} fn Callback function to execute after focus happens
        * @return {ContentEditable}
        * @chainable
        */
        focus: function() {
            this._container.focus();
 
            return this;
        },
        /**
        * Show the iframe instance
        * @method show
        * @return {ContentEditable}
        * @chainable
        */
        show: function() {
            this._container.show();
 
            this.focus();
 
            return this;
        },
 
        /**
        * Hide the iframe instance
        * @method hide
        * @return {ContentEditable}
        * @chainable
        */
        hide: function() {
            this._container.hide();
 
            return this;
        }
    },
    {
        /**
        * The throttle time for key events in IE
        * @static
        * @property THROTTLE_TIME
        * @type Number
        * @default 100
        */
        THROTTLE_TIME: 100,
 
        /**
        * The DomEvents that the frame automatically attaches and bubbles
        * @static
        * @property DOM_EVENTS
        * @type Object
        */
        DOM_EVENTS: {
            click: 1,
            dblclick: 1,
            focusin: 1,
            focusout: 1,
            keydown: 1,
            keypress: 1,
            keyup: 1,
            mousedown: 1,
            mouseup: 1,
            paste: 1
        },
 
        /**
        * The template string used to create the ContentEditable element
        * @static
        * @property HTML
        * @type String
        */
        HTML: '<div></div>',
 
        /**
        * The name of the class (contentEditable)
        * @static
        * @property NAME
        * @type String
        */
        NAME: 'contentEditable',
 
        /**
        * The namespace on which ContentEditable plugin will reside.
        *
        * @property NS
        * @type String
        * @default 'contentEditable'
        * @static
        */
        NS: CONTENT_EDITABLE,
 
        ATTRS: {
            /**
            * The default text direction for this ContentEditable element. Default: ltr
            * @attribute dir
            * @type String
            */
            dir: {
                lazyAdd: false,
                validator: Lang.isString,
                setter: '_setDir',
                valueFn: '_getDir'
            },
 
            /**
            * The container to set contentEditable=true or to create on render.
            * @attribute container
            * @type String/HTMLElement/Node
            */
            container: {
                setter: function(n) {
                    this._container = Y.one(n);
 
                    return this._container;
                }
            },
 
            /**
            * The string to inject as Editor content. Default '<br>'
            * @attribute content
            * @type String
            */
            content: {
                getter: '_getHTML',
                lazyAdd: false,
                setter: '_setHTML',
                validator: Lang.isString,
                value: '<br>'
            },
 
            /**
            * The default tag to use for block level items, defaults to: p
            * @attribute defaultblock
            * @type String
            */
            defaultblock: {
                validator: Lang.isString,
                value: TAG_PARAGRAPH,
                valueFn: '_getDefaultBlock'
            },
 
            /**
            * A string of CSS to add to the Head of the Editor
            * @attribute extracss
            * @type String
            */
            extracss: {
                lazyAdd: false,
                setter: '_setExtraCSS',
                validator: Lang.isString,
                valueFn: '_getExtraCSS'
            },
 
            /**
            * Set the id of the new Node. (optional)
            * @attribute id
            * @type String
            * @writeonce
            */
            id: {
                writeOnce: true,
                getter: function(id) {
                    if (!id) {
                        id = 'inlineedit-' + Y.guid();
                    }
 
                    return id;
                }
            },
 
            /**
            * The default language. Default: en-US
            * @attribute lang
            * @type String
            */
            lang: {
                validator: Lang.isString,
                setter: '_setLang',
                lazyAdd: false,
                value: 'en-US'
            },
 
            /**
            * An array of url's to external linked style sheets
            * @attribute linkedcss
            * @type String|Array
            */
            linkedcss: {
                setter: '_setLinkedCSS',
                validator: '_validateLinkedCSS'
                //value: ''
            },
 
            /**
            * The Node instance of the container.
            * @attribute node
            * @type Node
            */
            node: {
                readOnly: true,
                value: null,
                getter: function() {
                    return this._container;
                }
            },
 
            /**
            * Array of modules to include in the scoped YUI instance at render time. Default: ['node-base', 'editor-selection', 'stylesheet']
            * @attribute use
            * @writeonce
            * @type Array
            */
            use: {
                validator: Lang.isArray,
                writeOnce: true,
                value: ['node-base', 'editor-selection', 'stylesheet']
            }
        }
    });
 
    Y.namespace('Plugin');
 
    Y.Plugin.ContentEditable = ContentEditable;