/**
 * Floating-Tools
 * Author: Philipp Stracker (2013)
 * Project page: http://stracker-phil.github.com/Floating-Tools/
 */
(function() {

var floatingtools = function() {
this.dom = null;  // the main toolbar-object
this.toolbars = [];
this.is_visible = false;

this.hide_on_blur = true; //!TODO: Make this an configuration option

this.toolbarsize = false;
this.editoroffset = false;
this.mousepos = {x:0, y:0};
};




CKEDITOR.plugins.add( 'floating-tools', {
requires: 'toolbar',


init: function( editor ) {


/**
* Create the UI elements required by this plugin
* UI is the floating toolbar
* Many parts of this function are taken from the toolbar plugin
*/
editor.on( 'uiSpace', function( event ) {
// Create toolbar only once...
event.removeListener();

editor.floatingtools = new floatingtools();

var labelId = CKEDITOR.tools.getNextId();

var output = [
// Did not find a nicer way to include the CSS required for the toolbar...
'<style>',
'.pos-relative {position:relative}',
'.cke_floatingtools{',
'position:absolute;',
'left:0;',
'top:-500px;',
'padding: 5px 0 0 6px;',
'border:1px solid #b1b1b1;',
'border-radius:3px;',
'box-shadow: 0 1px 10px rgba(0,0,0,0.3);',
'transition:opacity .1s;-o-transition:opacity .1s;-moz-transition:opacity .1s;-webkit-transition:opacity .1s;',
'}',
'</style>',
'<span id="', labelId, '" class="cke_voice_label">', editor.lang.toolbar.toolbars, '</span>',
'<span id="' + editor.ui.spaceId( 'floatingtools' ) + '" class="cke_floatingtools cke_top" role="group" aria-labelledby="', labelId, '" onmousedown="return false;">' ];

var groupStarted, pendingSeparator;
var toolbars = editor.floatingtools.toolbars,
toolbar = getFloatingToolbarConfig( editor );


// Build the toolbar
for ( var r = 0; r < toolbar.length; r++ ) {
var toolbarId,
toolbarObj = 0,
toolbarName,
row = toolbar[ r ],
items;

// It's better to check if the row object is really
// available because it's a common mistake to leave
// an extra comma in the toolbar definition
// settings, which leads on the editor not loading
// at all in IE. (#3983)
if ( !row )
continue;

if ( groupStarted ) {
output.push( '</span>' );
groupStarted = 0;
pendingSeparator = 0;
}

if ( row === '/' ) {
output.push( '<span class="cke_toolbar_break"></span>' );
continue;
}

items = row.items || row;

// Create all items defined for this toolbar.
for ( var i = 0; i < items.length; i++ ) {
var item = items[ i ],
canGroup;

if ( item ) {
if ( item.type == CKEDITOR.UI_SEPARATOR ) {
// Do not add the separator immediately. Just save
// it be included if we already have something in
// the toolbar and if a new item is to be added (later).
pendingSeparator = groupStarted && item;
continue;
}

canGroup = item.canGroup !== false;

// Initialize the toolbar first, if needed.
if ( !toolbarObj ) {
// Create the basic toolbar object.
toolbarId = CKEDITOR.tools.getNextId();
toolbarObj = { id: toolbarId, items: [] };
toolbarName = row.name && ( editor.lang.toolbar.toolbarGroups[ row.name ] || row.name );

// Output the toolbar opener.
output.push( '<span id="', toolbarId, '" class="cke_toolbar"', ( toolbarName ? ' aria-labelledby="' + toolbarId + '_label"' : '' ), ' role="toolbar">' );

// If a toolbar name is available, send the voice label.
toolbarName && output.push( '<span id="', toolbarId, '_label" class="cke_voice_label">', toolbarName, '</span>' );

output.push( '<span class="cke_toolbar_start"></span>' );

// Add the toolbar to the "editor.toolbox.toolbars"
// array.
var index = toolbars.push( toolbarObj ) - 1;

// Create the next/previous reference.
if ( index > 0 ) {
toolbarObj.previous = toolbars[ index - 1 ];
toolbarObj.previous.next = toolbarObj;
}
}

if ( canGroup ) {
if ( !groupStarted ) {
output.push( '<span class="cke_toolgroup" role="presentation">' );
groupStarted = 1;
}
} else if ( groupStarted ) {
output.push( '</span>' );
groupStarted = 0;
}

function addItem( item ) {
var itemObj = item.render( editor, output );
index = toolbarObj.items.push( itemObj ) - 1;

if ( index > 0 ) {
itemObj.previous = toolbarObj.items[ index - 1 ];
itemObj.previous.next = itemObj;
}

itemObj.toolbar = toolbarObj;

// No need for keyboard handlers, the toolbar is only accessibly by mouse
/*
itemObj.onkey = itemKeystroke;

// Fix for #3052:
// Prevent JAWS from focusing the toolbar after document load.
itemObj.onfocus = function() {
if ( !editor.toolbox.focusCommandExecuted )
editor.focus();
};
*/
}

if ( pendingSeparator ) {
addItem( pendingSeparator );
pendingSeparator = 0;
}

addItem( item );

}
}

if ( groupStarted ) {
output.push( '</span>' );
groupStarted = 0;
pendingSeparator = 0;
}

if ( toolbarObj )
output.push( '<span class="cke_toolbar_end"></span></span>' );

}


output.push( '</span>' );
event.data.html += output.join( '' );
});



/**
* Do the magic: Attach eventhandlers to see if text is selected
* When text is selected then show the floating toolbar, else hide it
*/
editor.on('contentDom', function( event ) {

unfocus_toolbar();

/**
* Attach an eventhandler to the mouse-up event
*/
editor.document.on('mouseup', function( mouse_event ) {
// When user right-clicks, ctrl-clicks, etc. then do not show the toolbar
data = mouse_event.data.$;
if (data.button !== 0 || data.ctrlKey || data.altKey || data.shiftKey) return true;

// When the user clears the selection by single-clicking in the editor then this event is fired before the selection is removed
// So we add a short delay to give the browser a chance to remove the selection before we do anything
setTimeout( function() {
if (is_text_selected()) {
// Save the current mouse-position
set_mousepos (mouse_event.data.$);
// when there is text selected after mouse-up: show the toolbar
editor.execCommand('showFloatingTools');
} else {
// when no text is selected then hide the toolbar
editor.execCommand('hideFloatingTools');
}
}, 100);
});


/**
* On keypress we will always hide the toolbar
* The toolbar is only accessible via mouse
*/
editor.document.on('keyup', function( key_event ) {
editor.execCommand('hideFloatingTools');
});


/**
* On blur hide the toolbar (editor looses focus)
*/
editor.on('blur', function( e ) {
if (editor.floatingtools.hide_on_blur) {
hide_toolbar();
}
});


/**
* Attach the mouse-over event to the toolbar.
* When cursor is above the toolbar then set opacity to 1
*/
toolbar = get_element();
toolbar.on('mouseover', function( mouse_event ) {
focus_toolbar();
});


/**
* When the mouse moves out of the toolbar then make it transparent again
*/
toolbar.on('mouseout', function( mouse_event ) {
unfocus_toolbar();
})

editor.container.addClass('pos-relative');
console.log(editor.container);
});



/**
* Display the floating toolbar
*/
editor.addCommand( 'showFloatingTools', {
exec : function( editor ) {
if (is_text_selected()) {
toolbar = get_element();
unfocus_toolbar();
toolbar.show();

// Get the size of the toolbar
size = get_toolbar_size()
// Get the offset of the editor
offset = get_editor_offset();
// Get the mouse position
pos = get_mousepos();

// Calculate the position for the toolbar
toolpos = calculate_position(pos, size, offset);

toolbar.setStyles({
'left' : toolpos.x + 'px',
'top' : toolpos.y + 'px'
});
editor.floatingtools.is_visible = true;
}
}
});


/**
* Hide the floating toolbar
*/
editor.addCommand( 'hideFloatingTools', {
exec : function( editor ) {
hide_toolbar();
}
});


/**
* ===== Behind the scenes. Getters, setters, calculation, etc.
*/


hide_toolbar = function() {
if (false != editor.floatingtools.is_visible) {
toolbar = get_element();
toolbar.hide();
editor.floatingtools.is_visible = false;
}
}


/**
* Store the current mouse-position, so we can position the toolbar near the cursor
*/
set_mousepos = function(data) {
editor.floatingtools.mousepos = {
left: data.clientX,
top: data.clientY
};
}



/**
* Store the current mouse-position, so we can position the toolbar near the cursor
*/
get_mousepos = function() {
return editor.floatingtools.mousepos;
}


/**
* Returns the main toolbar-object (the parent of all items in the floating-toolbar)
*/
get_element = function() {
if (! editor.floatingtools.dom) {
var dom_id = editor.ui.spaceId( 'floatingtools' );
editor.floatingtools.dom = CKEDITOR.document.getById( dom_id );
}
return editor.floatingtools.dom;
}



/**
* Returns the offset of the editor area (effectively the height of the top-toolbar)
*/
get_editor_offset = function() {
if (! editor.floatingtools.editoroffset) {
var editor_id = editor.ui.spaceId( 'contents' );
var obj = CKEDITOR.document.getById( editor_id );
editor.floatingtools.editoroffset = {
left:   obj.$.offsetLeft,
top:    obj.$.offsetTop,
width:  obj.$.offsetWidth,
height: obj.$.offsetHeight
};
}
return editor.floatingtools.editoroffset;
}


/**
* Calculates the position for the toolbar
*/
calculate_position = function(pos, toolbar_size, offset) {
toolpos = {
x: pos.left + offset.left - (toolbar_size.width/2),
y: pos.top + offset.top - (toolbar_size.height + 20)
}

// make sure toolbar does not extend out of the left CKEditor border
if (toolpos.x < offset.left + 2) toolpos.x = offset.left + 2;

// make sure toolbar does not extend out of the right CKEditor border
if (pos.left + (toolbar_size.width/2) >= offset.left + offset.width-2 )
toolpos.x = offset.left + offset.width - toolbar_size.width - 2;

// Make sure toolbar does no go into the top toolbar area
if (toolpos.y < offset.top) toolpos.y = offset.top;

// make sure toolbar does not cover the mouse-cursor when text in the top line is selected
if (offset.top+pos.top > toolpos.y
&& offset.top+pos.top < toolpos.y+toolbar_size.height)
toolpos.y = offset.top + pos.top + 24; // display toolbar below the cursor

return toolpos;
}


/**
* Returns the size of the floating toolbar
*/
get_toolbar_size = function() {
if (! editor.floatingtools.toolbarsize) {
var obj = get_element();
editor.floatingtools.toolbarsize = {
width: obj.$.offsetWidth,
height: obj.$.offsetHeight
};
}
return editor.floatingtools.toolbarsize;
}


/**
* Check if text is selected.
* Retrns true when there is at least 1 character selected in the editor
*/
is_text_selected = function () {
var text = editor.getSelection().getSelectedText();
return text != '';
}


/**
* Make the toolbar opaque
*/
focus_toolbar = function() {
obj = get_element();
obj.setOpacity(1);
}


/**
* Make the toolbar transparent
*/
unfocus_toolbar = function() {
obj = get_element();
obj.setOpacity(0.25);
},


/**
* Get the plugin configuration.
* Kidnapped from the toolbar-plugin...
*/
getFloatingToolbarConfig = function( editor ) {
var removeButtons = editor.config.removeButtons;

removeButtons = removeButtons && removeButtons.split( ',' );

function buildToolbarConfig() {
// Take the base for the new toolbar, which is basically a toolbar
// definition without items.
var toolbar = getPrivateFloatingToolbarGroups( editor );
return populateToolbarConfig( toolbar );

}

// Returns an object containing all toolbar groups used by ui items.
function getItemDefinedGroups() {
var groups = {},
itemName, item, itemToolbar, group, order;

for ( itemName in editor.ui.items ) {
item = editor.ui.items[ itemName ];
itemToolbar = item.toolbar || 'others';
if ( itemToolbar ) {
// Break the toolbar property into its parts: "group_name[,order]".
itemToolbar = itemToolbar.split( ',' );
group = itemToolbar[ 0 ];
order = parseInt( itemToolbar[ 1 ] || -1, 10 );

// Initialize the group, if necessary.
groups[ group ] || ( groups[ group ] = [] );

// Push the data used to build the toolbar later.
groups[ group ].push( { name: itemName, order: order} );
}
}

// Put the items in the right order.
for ( group in groups ) {
groups[ group ] = groups[ group ].sort( function( a, b ) {
return a.order == b.order ? 0 :
b.order < 0 ? -1 :
a.order < 0 ? 1 :
a.order < b.order ? -1 :
1;
});
}

return groups;
}

function fillGroup( toolbarGroup, uiItems ) {
if ( uiItems.length ) {
if ( toolbarGroup.items )
toolbarGroup.items.push( editor.ui.create( '-' ) );
else
toolbarGroup.items = [];

var item, name;
while ( ( item = uiItems.shift() ) ) {
name = typeof item == 'string' ? item : item.name;

// Ignore items that are configured to be removed.
if ( !removeButtons || CKEDITOR.tools.indexOf( removeButtons, name ) == -1 ) {
item = editor.ui.create( name );

if ( !item )
continue;

if ( !editor.addFeature( item ) )
continue;

toolbarGroup.items.push( item );
}
}
}
}

function populateToolbarConfig( config ) {
var toolbar = [],
i, group, newGroup;

for ( i = 0; i < config.length; ++i ) {
group = config[ i ];
newGroup = {};

if ( group == '/' )
toolbar.push( group );
else if ( CKEDITOR.tools.isArray( group) ) {
fillGroup( newGroup, CKEDITOR.tools.clone( group ) );
toolbar.push( newGroup );
}
else if ( group.items ) {
fillGroup( newGroup, CKEDITOR.tools.clone( group.items ) );
newGroup.name = group.name;
toolbar.push( newGroup);
}
}

return toolbar;
}

var toolbar = editor.config.floatingtools;

// If it is a string, return the relative "toolbar_name" config.
if ( typeof toolbar == 'string' )
toolbar = editor.config[ 'floatingtools_' + toolbar ];

return ( editor.toolbar = toolbar ? populateToolbarConfig( toolbar ) : buildToolbarConfig() );
},


/**
* Return the default toolbar configuration.
*/
getPrivateFloatingToolbarGroups = function( editor ) {
return editor._.floatingToolsGroups || ( editor._.floatingToolsGroups = [
{ name: 'styles',    items: [ 'Font','FontSize' ]},
{ name: 'format',    items: [ 'Bold','Italic' ]},
{ name: 'paragraph', items: [ 'JustifyCenter','Outdent','Indent','NumberedList','BulletedList' ]}
]);
}

}

} );


})();