$(document).ready(function() {
	
	// Sidebar Accodrion
	$(".accordion").tabs(".pane", {tabs: 'h2', effect: 'slide'});
	
	// Tabs
	$("ul.tabs").tabs("div.pane", {
		event: "click",
		tabs: "li"
	});
	
	$("div.pane").hide();
	$("div.pane:first").show();
	
	
	// show areas edited by ECS front end link
	$('a.ECS_content_edit').mouseover(function() {
		$(this).parent().parent().css('background-color', '#ffc');
	}).mouseout(function() {
		$(this).parent().parent().css('background-color', 'transparent');
	});
	
	$('#ECS_tools a img').mouseover(function() {
		$(this).after('<span>' + $(this).attr('alt') + '</span>');
	}).mouseout(function() {
		$(this).next('span').remove();
	});;
	
	$('#ECS_tools_toogle').bind('click', function () {
		$('.ECS_tool').toggle();
	});
	
	
	// Produktansichten mit mehreren Produkten
	var config = [];
	config = {
		numPerPage: 8,
		offset: 0,
		page: 0,
		totalRows: 0,
		totalPages: 0
	};
		
	//alert($('select.sort-select').find('option').size());
	$('div.sortable').each(function() {
		var $produktliste = $(this);
		
		$('table.sort-select th.sorting').each(function($option) {
				var findSortKey;
				
				if ($(this).is('.sort-alpha')) {
					findSortKey = function($cell) {
						// sort-alpha
						return $cell.find('.sort-key').text().toUpperCase() + ' ' + $cell.text().toUpperCase();
					};
				} else if ($(this).is('.sort-numeric')) {
					findSortKey = function($cell) {
						// sort-numeric
						var key = parseFloat($cell.text().replace(',', '.').replace(/^[^\d.]*/, ''));
						return isNaN(key) ? 9999 : key;
					};

				} else if ($(this).is('.sort-numeric-desc')) {
					findSortKey = function($cell) {
						// sort-numeric
						var key = parseFloat($cell.text().replace(',', '.').replace(/^[^\d.]*/, ''));
						return isNaN(key) ? -9999 : -key;
					};

				} else if ($(this).is('.sort-date')) {
					findSortKey = function($cell) {
						// sort-date
						return Date.parse('1 ' + $cell.text());
					};
				}
				
				//alert($(this).attr("name"));
				
				if (findSortKey) {
					$(this).bind('click', function(event) {
						var newDirection = 1;
						if ($(this).is('.sorted-asc')) {
							newDirection = -1;
						}
						
						
						// assign filter mages
						//alert($(this).text());
						$('table.sort-select th.sorting').removeClass('sorted-asc').removeClass('sorted-desc');
						if (newDirection == 1) {
							$(this).addClass('sorted-asc');
							
						} else {
							$(this).addClass('sorted-desc');
						}
						
						
						
						
						produkte = $produktliste.find('div.produkt').get();
						
						$.each(produkte, function(index, row) {
							row.sortKey = findSortKey($(row).find('span').eq($option));
						});
						
						produkte.sort(function(a, b) {
							if (a.sortKey < b.sortKey) return -newDirection;
							if (a.sortKey > b.sortKey) return newDirection;
							return 0;
						});
						
						$.each(produkte, function(index, row) {
							$produktliste.append(row);
							row.sortKey = null;
						});
						
						$produktliste.trigger('repaginate');
					});
				}
			
		});
	});

	$('div.paginated').each(function() {
		var currentPage = 0;
		var numPerPage = 8;
		var rows = 0;
		var $produktliste = $(this);
		var numRows = $produktliste.find('div.produkt').length;
		var $pager = $('<div class="pager" style="float:left;"></div>');
		
		config.totalRows = numRows;
		
		var $div_pagesize = $('span.page_numPerPage');
		$produktliste.bind('repaginate', function() {
			
			//rows = $produktliste.find('div.produkt').size();
			numPerPage = config.numPerPage;
			
			var numPages = Math.ceil(numRows / numPerPage);
			numRows = config.totalRows;
			
			config.totalPages = numPages;
			
			// alle anzeigen
			$produktliste.find('div.produkt').show();
			
			for (var line = 0; line < numRows; line++) {
				if(line < currentPage * numPerPage || line > (currentPage + 1) * numPerPage - 1) {
					$produktliste.find('div.produkt').eq(line).hide();
				}
			}
			
			config.page = currentPage;
			
			$pager.empty();
			$pager.append('<span style="float:left;">Seite:&nbsp;&nbsp;</span>');
			
			for (var page = 0; page < numPages; page++) {
				$('<span class="page-number" title="page_'+(page)+'">&nbsp;' + (page + 1) + '&nbsp;</span>\r\n')
				.bind('click', {'newPage': page}, function(event) {
					currentPage = event.data['newPage'];
					$produktliste.trigger('repaginate');
					$(this).addClass('active').siblings().removeClass('active');
				})
				.appendTo($pager).addClass('clickable');
			}
			
			$pager.find('span.page-number:first').addClass('active');
			$pager.insertBefore($div_pagesize);
			
			
			
			// enable page controls
			$('#control_first').unbind('click').bind('click', {'newPage': 0}, function(event) {
				currentPage = event.data['newPage'];
				$produktliste.trigger('repaginate');
			});

			newPage = config.page-1;
			if(newPage <= 0) {newPage = 0;}
			$('#control_prev').unbind('click').bind('click', {'newPage': newPage}, function(event) {
				currentPage = event.data['newPage'];
				$produktliste.trigger('repaginate');
			});
			
			newPage = config.page+1;
			if(newPage > config.totalPages-1) {newPage = config.totalPages-1;}
			$('#control_next').unbind('click').bind('click', {'newPage': newPage}, function(event) {
				currentPage = event.data['newPage'];
				$produktliste.trigger('repaginate');
			});
			
			newPage = config.totalPages-1;
			$('#control_last').unbind('click').bind('click', {'newPage': newPage}, function(event) {
				currentPage = event.data['newPage'];
				$produktliste.trigger('repaginate');
			});
			
			
			// hover page links
			
			pagelinks = $('.page-number');
			$('.page-number').each(function() {
				pagelink = $(this);
				if(pagelink.attr('title') == "page_"+config.page) {
					pagelink.addClass('active');
				} else {
					pagelink.removeClass('active')
				}
			});
			
		});
		
		
		// enable pagsize-selection
		$('span.numPerPage').each(function() {}).bind('click', {'newPage': 0}, function(event) {
				
				option = $(this);
				config.numPerPage = option.attr('title');
				
				$(this).addClass('active').siblings().removeClass('active');
				
				currentPage = event.data['newPage'];
				$produktliste.trigger('repaginate');
				
			});
		
		if(config.totalRows > config.numPerPage) {
			$('.produktliste_footer').show();
			$('span.numPerPage:first').addClass('active');
		}
		$produktliste.trigger('repaginate');
		
	});
	
	
	// Load popup-Elements
	$(document).ready(function(){
		$("a[rel^='popup']").prettyPhoto({theme:'dark_rounded'});
		$("a[rel^='popup_white']").prettyPhoto({theme:'light_rounded'});
	});
	
	// CONFIG
	//{
	//	animationSpeed: 'fast', /* fast/slow/normal */
	//	padding: 40, /* padding for each side of the picture */
	//	opacity: 0.35, /* Value betwee 0 and 1 */
	//	showTitle: true, /* true/false */
	//	allowresize: true, /* true/false */
	//	counter_separator_label: '/', /* The separator for the gallery counter 1 "of" 2 */
	//	theme: 'light_rounded', /* light_rounded / dark_rounded / light_square / dark_square */
	//	hideflash: false, /* Hides all the flash object on a page, set to TRUE if flash appears over prettyPhoto */
	//	modal: false, /* If set to true, only the close button will close the window */
	//	changepicturecallback: function(){}, /* Called everytime an item is shown/changed */
	//	callback: function(){} /* Called when prettyPhoto is closed */
	//}
	
});






/*
* Copyright (c) 2008 Justin Britten justinbritten at gmail.com
*
* Some code was borrowed from:
* 1. Greg Weber's uiTableFilter project (http://gregweber.info/projects/uitablefilter)
* 2. Denny Ferrassoli & Charles Christolini's TypeWatch project (www.dennydotnet.com)
*
* Dual licensed under the MIT and GPL licenses:
* http://www.opensource.org/licenses/mit-license.php
* http://www.gnu.org/licenses/gpl.html
*
*/
 
/*
(function($) {
  $.extend({
    tablesorterFilter: new function() {
 
      // Default filterFunction implementation (element text, search words, case-sensitive flag)
      function has_words(str, words, caseSensitive) {
        var text = caseSensitive ? str : str.toLowerCase();
 
        for (var i=0; i < words.length; i++) {
          if (words[i].charAt(0) == '-') {
            if (text.indexOf(words[i].substr(1)) != -1) return false; // Negated word must not be in text
          } else if (text.indexOf(words[i]) == -1) return false; // Normal word must be in text
        }
 
        return true;
      }
 
 
      function doFilter(table) {
        if(table.config.debug) { var cacheTime = new Date(); }
 
        // Build multiple filters from input boxes
        // TODO: enable incremental filtering by caching result and applying only single filter action
        var filters = [];
        for(var i=0; i < table.config.filter.length; i++) {
          var container = $(table.config.filter[i].filterContainer);
          // Trim and unify whitespace before splitting
          var phrase = jQuery.trim(container.val()).replace(/\s+/g, ' ');
          if(phrase.length != 0) {
            var caseSensitive = table.config.filter[i].filterCaseSensitive;
            filters.push({
              caseSensitive: caseSensitive,
              words: caseSensitive ? phrase.split(" ") : phrase.toLowerCase().split(" "),
              findStr: table.config.filter[i].filterColumns ? "td:eq(" + table.config.filter[i].filterColumns.join("),td:eq(") + ")" : "",
              filterFunction: table.config.filter[i].filterFunction
            });
          }
        }
        var filterCount = filters.length;
 
        // Filter cleared?
        if(filterCount == 0) {
          var search_text = function() {
            var elem = jQuery(this);
            resultRows[resultRows.length] = elem;
          }
        } else {
          var search_text = function() {
            var elem = jQuery(this);
            for(var i=0; i < filterCount; i++) {
              if(! filters[i].filterFunction( (filters[i].findStr ? elem.find(filters[i].findStr) : elem).text(), filters[i].words, filters[i].caseSensitive)) {
                return true; // Skip elem and continue to next element
              }
            }
            resultRows[resultRows.length] = elem;
          }
        }
 
        // Walk through all of the table's rows and search.
        // Rows which match the string will be pushed into the resultRows array.
        var allRows = table.config.cache.row;
        var resultRows = [];
 
        var allRowsCount = allRows.length;
        for (var i=0; i < allRowsCount; i++) {
          allRows[i].each ( search_text );
        }
 
        // Clear the table
        $.tablesorter.clearTableBody(table);
 
        // Push all rows which matched the search string onto the table for display.
        var resultRowsCount = resultRows.length;
        for (var i=0; i < resultRowsCount; i++) {
          $(table.tBodies[0]).append(resultRows[i]);
        }
 
        // Update the table by executing some of tablesorter's triggers
        // This will apply any widgets or pagination, if used.
        $(table).trigger("update");
        if (resultRows.length) {
          $(table).trigger("appendCache");
          // Apply current sorting after restoring rows
          $(table).trigger("sorton", [table.config.sortList]);
        }
 
        if(table.config.debug) { $.tablesorter.benchmark("Apply filter:", cacheTime); }
 
        // Inform subscribers that filtering finished
        $(table).trigger("filterEnd");
 
        return table;
      };
 
      function clearFilter(table) {
        if(table.config.debug) { var cacheTime = new Date(); }
 
        // Reset all filter values
        for(var i=0; i < table.config.filter.length; i++)
          $(table.config.filter[i].filterContainer).val('').get(0).lastValue = '';
 
        var allRows = table.config.cache.row;
 
        $.tablesorter.clearTableBody(table);
 
        for (var i=0; i < allRows.length; i++) {
          $(table.tBodies[0]).append(allRows[i]);
        }
 
        $(table).trigger("update");
        $(table).trigger("appendCache");
        // Apply current sorting after restoring all rows
        $(table).trigger("sorton", [table.config.sortList]);
 
        if(table.config.debug) { $.tablesorter.benchmark("Clear filter:", cacheTime); }
 
        $(table).trigger("filterCleared");
 
        return table;
      };
 
      this.defaults = {
        filterContainer: '#filter-box',
        filterClearContainer: '#filter-clear-button',
        filterColumns: null,
        filterCaseSensitive: false,
        filterWaitTime: 500,
        filterFunction: has_words
      };
 
 
      this.construct = function() {
        var settings = arguments; // Allow multiple config objects in constructor call
 
        return this.each(function() {
          this.config.filter = new Array(settings.length);
          var config = this.config;
          config.filter = new Array(settings.length);
 
          for (var i = 0; i < settings.length; i++)
            config.filter[i] = $.extend(this.config.filter[i], $.tablesorterFilter.defaults, settings[i]);
 
          var table = this;
 
          // Create a timer which gets reset upon every keyup event.
          //
          // Perform filter only when the timer's wait is reached (user finished typing or paused long enough to elapse the timer).
          //
          // Do not perform the filter is the query has not changed.
          //
          // Immediately perform the filter if the ENTER key is pressed.
 
          function checkInputBox(inputBox, override) {
            var value = inputBox.value;
 
            if ((value != inputBox.lastValue) || (override)) {
              inputBox.lastValue = value;
              doFilter( table );
            }
          };
 
          var timer = new Array(settings.length);
 
          for (var i = 0; i < settings.length; i++) {
            var container = $(config.filter[i].filterContainer);
            // TODO: throw error for non-existing filter container?
            if(container.length)
              container[0].filterIndex = i;
            container.keyup(function(e, phrase) {
              var index = this.filterIndex;
              if(undefined !== phrase)
                $(this).val(phrase);
              var inputBox = this;
 
              // Was ENTER pushed?
              if (inputBox.keyCode == 13 || undefined !== phrase) {
                var timerWait = 1;
                var overrideBool = true;
              } else {
                var timerWait = config.filter[index].filterWaitTime || 500;
                var overrideBool = false;
              }
 
              var timerCallback = function() {
                checkInputBox(inputBox, overrideBool);
              }
 
              // Reset the timer
              clearTimeout(timer[index]);
              timer[index] = setTimeout(timerCallback, timerWait);
 
              return false;
            });
 
            // Avoid binding click event to whole document if no clearContainer has been defined
            if(config.filter[i].filterClearContainer) {
              var container = $(config.filter[i].filterClearContainer);
              if(container.length) {
                container[0].filterIndex = i;
                container.click(function() {
                  var index = this.filterIndex;
                  var container = $(config.filter[index].filterContainer);
                  container.val("");
                  // Support entering the same filter text after clearing
                  container[0].lastValue = "";
                  // TODO: Clear single filter only
                  doFilter(table);
                  if(container[0].type != 'hidden')
                    container.focus();
                });
              }
            }
          }
 
          $(table).bind("doFilter",function() {
            doFilter(table);
          });
          $(table).bind("clearFilter",function() {
            clearFilter(table);
          });
        });
      };
 
    }
  });
 
  // extend plugin scope
  $.fn.extend({
    tablesorterFilter: $.tablesorterFilter.construct
  });
 
})(jQuery);

*/