//TODO: recuperar esses valores no init do Calendar
User = {
  
    init: function(){
      
    this.moduleName = 'expressoCalendar';
	this.me = DataLayer.dispatch( "me" );
	
	var objTime = DataLayer.dispatch( "timezones" );
	this.timezones = objTime.timezones;
	this.isDaylightSaving = objTime.isDaylightSaving;
    this.lastView = 0;
	this.load();      
    },
  
    load: function(){

	var defaultPreferences = { dateFormat: "dd/MM/yyyy",
		hourFormat: "HH:mm",
		defaultCalView: "month",
		defaultDuration: 30,
		backgroundColor: "36C",
		borderColor: "36C",
		fontColor: "fff",
		timezone: 'America/Sao_Paulo',
		weekStart: 'SUN'
	  };

	var pref = DataLayer.get( "modulePreference:detail", ['and',[ "=", "user", this.me.id ], [ "=", "module", this.moduleName ]] );
	
	this.preferences = $.isEmptyObject( pref.values ) ? defaultPreferences : pref.values;
	this.preferenceIds = pref.ids;
    }
}

UI = {
	dialogs: {
		addEvent: null,
		importCalendar: null
	}
}

DataLayer.codec( "calendarSignature", "calendar", {
  
      decoder: function(){

	  

      },
      
      encoder: function( signatures ){

	return $.map( signatures, function( signature ){
	      
		  return { events: function( start, end, callback ){
			
				var viewKey = start + ':' + end;

				if( Calendar.currentViewKey !== viewKey )
				{
				    Calendar.currentViewKey = viewKey;

				    Calendar.currentView = DataLayer.get( 'schedulable:calendar', { start: start, end: end } );
				}
				
				var view = Calendar.currentView[ signature.calendar.id ];
				
				callback( view && !view.hidden ? view : [] );

			   },

			   backgroundColor: '#' + signature.backgroundColor || User.preferences.backgroundColor,
			   borderColor: '#' + signature.borderColor || User.preferences.borderColor,
			   textColor: '#' + signature.fontColor || User.preferences.fontColor,
			   className: 'calendar-' + signature.calendar.id,
			   editable:  signature.isOwner }
	       });
      }

      
});

Calendar = {
  
      load: function(){

	  this.signatures  = DataLayer.get("calendarSignature", {filter: ['=', 'user', User.me.id], criteria: {deepness: 2}});
	  //this.signatures  = DataLayer.get( "calendarSignature", [ "=", "user", User.me.id ] );
	  
	  var prevSources = this.sources;

	  this.sources = DataLayer.encode( "calendarSignature:calendar", this.signatures );

	  if( prevSources )
	  {     
	      var newSources = DataLayer.diff( { 'diff': prevSources }, { 'diff': this.sources } ).diff;
 
	       for( var i = 0; i < newSources.length; i++ )
		  $('#calendar').fullCalendar( 'addEventSource', newSources[i] );
	    
	      var removeSources = DataLayer.diff( { 'diff': newSources }, { 'diff': prevSources } ).diff;

	      for( var i = 0; i < removeSources.length; i++ )
		  $('#calendar').fullCalendar( 'removeEventSource', removeSources[i] );
	  }

	  this.calendarIds = [], this.signatureOf = {}, this.calendars = [];

	  for( var i = 0; i < this.signatures.length; i++ )
	  {
	      this.signatureOf[ this.calendarIds[i] = ( this.calendars[ this.calendars.length ] = this.signatures[i].calendar ).id ] = this.signatures[i];
	  }
	  delete Calendar.currentViewKey;
      }
}

Alarms = {
	load: function(){
		var eventsDay = DataLayer.get('alarm:schedulable',['=', 'date', new Date().toString("yyyy-MM-dd")]);

		for(var i = 0; i < eventsDay.length; i++){
			this.addAlarm( eventsDay[i] );
		}
	},
	
	addAlarm: function( eventDay ){
		DataLayer.task( parseInt(eventDay.sendTime) , function( timestamp ){
			DataLayer.render('templates/alarm.ejs',{event: eventDay}, function( html ){
				var dlgAlarm = jQuery('#div-alarm').html( html ).find('.alarm-event.active');
				dlgAlarm.dialog({resizable: false, modal:true, width:400, minHeight: 100,position: 'center', close:function(){$(this).dialog('destroy');$(this).dialog('open');}});
			});
		});
	}
}

DataLayer.codec( "modulePreference", "detail", {
	decoder: function( evtObj ){

	if( notArray = $.type(evtObj) !== "array" )
		evtObj = [ evtObj ];
		
		var res = $.map(evtObj, function( form ){
			var returns = [];
			var cont = 0;
			for (var name in form){
				returns[cont] = {
					name: name,
					user: User.me.id,
					value: form[name],
					module: User.moduleName
				};
				if(typeof(User.preferenceIds[ name ]) != 'undefined')
					returns[cont].id = User.preferenceIds[ name ];
				cont++;
			}
		return [returns];
		});
	
	return notArray ? res[0] : res;
	},

    encoder: function( evtObj ){
		var val = {};
		var id = {}
		for (var i in evtObj){
			val[evtObj[i].name] = evtObj[i].value; 
			id[evtObj[i].name] = evtObj[i].id; 
		}
		return {values: val,ids: id};
	
	}
});

User.init();
Calendar.load();

//DataLayer.poll( "schedulable" );

DataLayer.listen( "schedulable", function( status, updateData){
  
    if( status === 'serverclient' ){
		DataLayer.commit( false, false, function(){
			delete Calendar.currentViewKey;
			$('#calendar').fullCalendar( 'refetchEvents' );
			var calendarNotSelected = getNotSelectedCalendars();
			for(var i = 0; i < calendarNotSelected.length; i++)
				Calendar.currentView[ calendarNotSelected[i] ].hidden = true;
			//Necessita ser chamado novamente para atualizar os eventos na tela para o usuário
			//de acordo com as a agendas selecionadas
			$('#calendar').fullCalendar( 'refetchEvents' );
			//Atualiza a listagem de eventos apenas se estiver na aba de listagem
			if($tabs.tabs('option' ,'selected') == 1)
				pageselectCallback("", 0);
		});
    }	
});

DataLayer.listen( "calendarSignature", function( status ){

    switch( status )
    {
      case 'serverclient':  DataLayer.commit( false, false, function( received ){

	  delete Calendar.currentViewKey;

	  Calendar.load();
	  refresh_calendars();
      });
      break;
      case 'client':  
      break;
    }
});

DataLayer.listen( "modulePreference", function( status ){

    switch( status )
    {
	case 'serverclient':  DataLayer.commit( false, false, function(){

	    User.load();

	});
	break;
	case 'client':  
	break;
    }

});

// DataLayer.listen( "calendar", function( status ){
// 
//     if( status === 'serverclient' )
//     {
// 	DataLayer.commit( false, false, function(){ 
// 
// 	  $('#calendar').fullCalendar( 'refetchEvents' );
// 
// 	});
//     }
// 
// });

DataLayer.listen( "alarm", function( created, updated, deleted ){

});

DataLayer.listen( "calendar", function( status, updateData ){

      if (updateData === false)
	switch( status )
	{
	  case 'serverclient':  DataLayer.commit( false, false, function(){
	    
	      Calendar.load();
	      refresh_calendars();
	    
	  });
	  break;
	  case 'client':  
	  break;
    }
});

DataLayer.codec( "calendarSignature", "configure", {
	decoder: function( evtObj ){
		Encoder.EncodeType = "entity";
		
		if( notArray = $.type(evtObj) !== "array" )
			evtObj = [ evtObj ];
		
		var res = $.map(evtObj, function( form ){
			return{
				id: form.signature,
				user: User.me.id,	
				calendar: {
					id: DataLayer.get('calendarSignature', form.signature).calendar,
					name: Encoder.htmlEncode(form.name),
					description: Encoder.htmlEncode(form.description),
					timezone: form.timezone,
					defaultDuration: form.duration != "" ? form.duration : 30,
					location: form.location
				},
				isOwner: 1,
				fontColor: Encoder.htmlEncode(form.fontColor.substring(1)),
				backgroundColor: Encoder.htmlEncode(form.backgroundColor.substring(1)),
				borderColor: Encoder.htmlEncode(form.borderColor.substring(1)),
				msgAdd: Encoder.htmlEncode(form.msgAdd),
				msgCancel: Encoder.htmlEncode(form.msgCancel),
				msgUpdate: Encoder.htmlEncode(form.msgUpdate),
				msgReply: Encoder.htmlEncode(form.msgReply),
				msgAlarm: Encoder.htmlEncode(form.msgAlarm),
				calendarSignatureAlarms: $.map( form.alarmTime || [], function( alarmTime, i ){
					if(form.alarmId[i] === "")
						return{type: form.alarmType[i],	unit: form.alarmUnit[i], time: form.alarmTime[i]};
					else
						return{type: form.alarmType[i],	unit: form.alarmUnit[i], time: form.alarmTime[i], id: form.alarmId[i]};
				})
			};
		
		});
	
	return notArray ? res[0] : res;
	},

    encoder: function( evtObj ){
	
	}
});

DataLayer.codec( "alarm", "schedulable", {

    decoder: function( evtObj ){
		return false;
    },
	
	encoder: function (evtObjt){
	
			if(notArray = typeof(evtObjt) == 'array' )
				evtObjt = [evtObjt];
			
			var res = $.map(evtObjt, function( objEvent ){	
				var timezone = User.timezones[objEvent.schedulable.timezone];
				var timeEvent = function(time, idCalendar){
					var data =  new Date();
					data.setTime(time);
					return dateFormat(setDateTimezone(data, timezone, true, idCalendar), User.preferences.hourFormat.replace(/m/g,'M'))			
				}
				
				var dateEvent = function( time){
					return new Date( parseInt(time) ).setTimezoneOffset(timezone).toString( User.preferences.dateFormat); 
				}
				
				var unitTemp = function(unit, time){
					switch (unit.toLowerCase()){
						case 'h':
							if(parseInt(time) > 1)
								return 'horas';
							return 'hora';
						case 'd':
							if(parseInt(time) > 1)
								return 'dias';
							return 'dia';
						case 'm':
							if(parseInt(time) > 1)
								return 'minutos';
							return 'minuto';
					}
				}
			
				return{
					id: objEvent.id,
					event_start: dateEvent(objEvent.schedulable.startTime),
					sendTime: objEvent.sendTime,
					schedulable: {
						startTime: timeEvent(objEvent.schedulable.startTime),
						id: objEvent.schedulable.id,
						summary: objEvent.schedulable.summary,
						time: objEvent.time,	
						unit: unitTemp(objEvent.unit ,objEvent.time)
					}
				}
			});
		return notArray ? res[0] : res;
	}
});

DataLayer.codec( "schedulable", "preview", {

    decoder: function( evtObj ){
		Encoder.EncodeType = "entity";
	
		if( notArray = $.type(evtObj) !== "array" )
			evtObj = [ evtObj ];

		var pref = User.preferences;

		var res = $.map(evtObj, function( form ){
			
			return {
				id: form.idEvent,
				calendar: form.calendar,
				participants : [{
					user: User.me.id,
					status: form.status,
					id: form.attendee_organizer[0],
					isOrganizer: 0,
					alarms: typeof(form.alarmTime) != 'undefined' ? 
						$.map( form.alarmTime || [], function( alarmTime, i ){

							if( alarmTime === "" )
								return( null );

							if(form.alarmId[i] === "")
								return { type: form.alarmType[i],unit: form.alarmUnit[i], time: form.alarmTime[i] };
							else
								return { type: form.alarmType[i], unit: form.alarmUnit[i], time: form.alarmTime[i], id: form.alarmId[i] };
						}) : []
					}]
			}
		});
		
		return notArray ? res[0] : res;
    },

    encoder: function( evtObj ){

	var notArray = false;
      
	if( notArray = $.type(evtObj) !== "array" )
	    evtObj = [ evtObj ];

	var pref = User.preferences;
	var statusParticipants = [];
	for (var i = 1; i <= 5; i++)
		statusParticipants[i] = 0;
		
	var statusObject = function(status){
		return{
			accepted: status[1],
			tentative: status[2],
			cancelled: status[3],
			unanswered: status[4],
			delegated: status[5]		
		}
	};	

	var isOrganizer = !!evtObj[0].id ? 0 : 1;
	
	var res = $.map(evtObj, function( objEvent ){			
		    
			var existsTimezone = false;
			var participantInfo = {}, me = { uid: User.me.id, name: User.me.name, mail: User.me.mail};
			var timezone = '';
			if(objEvent.timezone){
				timezone = User.timezones[objEvent.timezone];
				existsTimezone = true;
			}else{
				var tzId = pref.timezone;
				timezone = User.timezones[ tzId ];
			}
			
		    var dateEvent = function( time, allDayEnd){
			
			return new Date( parseInt(time) - ((allDayEnd) ? 86400000 : 0)  ).setTimezoneOffset(timezone).toString( User.preferences.dateFormat); }

			var timeEvent = function(time, idCalendar){
				var data =  new Date();
				data.setTime(time);
				return dateFormat(setDateTimezone(data, timezone, existsTimezone, idCalendar), User.preferences.hourFormat.replace(/m/g,'M'))			
			}						
			var alarmParticipant = function(obj){
				var alarms = [];
				for(var i = 0; i < obj.length; i++){ 
					alarms.push(DataLayer.get('alarm', obj[i]));
				}
				return alarms;
			}
		    return {
			      "class": objEvent["class"],
			      id: objEvent.id,
			      location: objEvent.location,
			      category: objEvent.category,
			      calendars: Calendar.calendars,
			      calendar: objEvent.calendar,
			      summary: objEvent.summary,
			      description: objEvent.description,
			      timezone: objEvent.timezone,
			      timezones: User.timezones,
			      startDate: dateEvent( objEvent.startTime, false ),
			      startHour: timeEvent(objEvent.startTime, objEvent.calendar ),
			      endDate: dateEvent( objEvent.endTime, (!!parseInt(objEvent.allDay)) ? true : false ),
			      endHour: timeEvent(objEvent.endTime, objEvent.calendar),
			      allDay: !!parseInt( objEvent.allDay ),
	  // 				attachments: this.decode( "attachment:detail", form ),
			      attendee: $.map(objEvent.participants || [], function( participant, i ){						
					
					var attend = DataLayer.get('participant', participant);
					attend.user = DataLayer.get('user', attend.user)
					
					statusParticipants[attend.status]++;  	
					 
					  var person = { uid: attend.id,
						 name: attend.user.name != 'false' ? attend.user.name : '',
						 mail: attend.user.mail,
						 isExternal: attend.isExternal
						};

					  if( attend.user.id ===  me.uid )
					  {
					      participantInfo.status = attend.status;
					      participantInfo.alarms = alarmParticipant(attend.alarms);
						  me.uid = attend.id;
					  }
					  if( parseInt( attend.isOrganizer ) )
					  {
						 isOrganizer = ((attend.user.id == User.me.id) || (!!!attend.user)) ? 1 : 0;
					      participantInfo.organizer = person;
						  return(null);
					  }

					  return( person );

				      }),
			      organizer: participantInfo.organizer || me,
			      alarms: participantInfo.alarms || [],
			      status: participantInfo.status || 1,
			      me: me
			    };
		});
	res[0].isOrganizer = isOrganizer;
	res[0].statusParticipants = statusObject(statusParticipants);
	if( !notArray )
	{
	    var dates = {};

	    for (var i=0; i<res.length; i++) {

		    var startDate = Date.parseExact( res[i]['startDate'], User.preferences.dateFormat );
		    var endDate   = Date.parseExact( res[i]['endDate'], User.preferences.dateFormat );

		    var counter   = startDate.clone();

		    while (counter.compareTo(startDate) == 0) {

			    if (!dates[counter.toString(User.preferences.dateFormat)]) 
				dates[counter.toString(User.preferences.dateFormat)] = { startDate:false, events:[] };
			    if (!dates[counter.toString(User.preferences.dateFormat)].startDate) 
				dates[counter.toString(User.preferences.dateFormat)].startDate = counter.toString(User.preferences.dateFormat);

			    dates[counter.toString(User.preferences.dateFormat)].events.push(res[i]);
			    counter.addDays(-1);
		    } 
	    }

	    res = { events_list: dates };
	}

	return notArray ? res[0] : res;
    }
});



DataLayer.codec( "schedulable", "detail", {

    decoder: function( evtObj ){

	Encoder.EncodeType = "entity";
	
	if( notArray = $.type(evtObj) !== "array" )
		evtObj = [ evtObj ];

	var pref = User.preferences;

	var res = $.map(evtObj, function( form ){
			var tzId = '';
		    if(form.timezone == ''){
				calendar = DataLayer.get('calendar', form.calendar);
				tzId = calendar.timezone || User.preferences.timezone;
			}else
				tzId = form.timezone;
		    timezone = User.timezones[ tzId ];

		    opposites = { '-':'+', '+':'-' },

		    formatString = ( typeof form.allDay !== "undefined" && !!form.allDay )? pref.dateFormat+" HH:mm" : pref.dateFormat + " " + pref.hourFormat;
			
		    participants = []; 

		    //if( form.idEvent )
			//	participants = DataLayer.get( "participant:detail", [ "=", "schedulable", form.idEvent ] );
			
			var spaces = function(hours){
				return hours.replace(/\s$/, "");
			};
			
			var startDate = Date.parseExact( !!form.allDay ? form.startDate+ " 00:00": form.startDate + " " + spaces(form.startHour) , formatString );
			startDate = getDateUTC(startDate, timezone);
			
			var endDate = Date.parseExact( !!form.allDay ? form.endDate + " 00:00": form.endDate + " " + spaces(form.endHour), formatString );
			endDate = getDateUTC(endDate, timezone);
		    return {
			      "class": form["class"],
				  startTime: startDate.getTime(),
				  endTime: !!form.allDay ? (new Date(endDate.getTime() + (86400000)).getTime()) : endDate.getTime(),
				  allDay: ( !!form.allDay ? 1 : 0 ),
			      id: form.idEvent,
			      location: form.location,
			      category: form.category,
			      calendar: form.calendar,
			      summary: form.summary,
			      description: form.description,
			      timezone: tzId,
			      participants: $.map( form.attendee || [], function( attendee, i ){

						if( !attendee || attendee === "" )
							return( null );

						var participant = {};
						participant.user = (attendee!= User.me.id) ? DataLayer.get('participant', attendee).user : attendee ;
						
						if( participant.user === User.me.id ){
							if(!!form.idEvent )
								participant.id = attendee;
							participant.isOrganizer = ( !i ? 1 : 0 );
							var obj = form.alarmTime ? form : pref;
							participant.alarms = $.map( obj.alarmTime || [], function( alarmTime, i ){

								if( alarmTime === "" )
									return( null );

								if(obj.alarmId[i] === "")
									return { type: obj.alarmType[i],unit: obj.alarmUnit[i], time: obj.alarmTime[i] };
								else
									return { type: obj.alarmType[i], unit: obj.alarmUnit[i], time: obj.alarmTime[i], id: obj.alarmId[i] };
							});
							participant.status = form.status;
						}else{
							participant.id = attendee;
							participant.isOrganizer = ( !i ? 1 : 0 );
							if(!!parseInt(form.attendeeType[i]))
								participant.isExternal= 1;
						}
						if( participants[ attendee ] ){
							participant.id = participants[ attendee ].id;
						}
						return( participant );
					  })
			    };
		    });

	return notArray ? res[0] : res;
    },

    encoder: function( evtObj ){

	var notArray = false;
      
	if( notArray = $.type(evtObj) !== "array" )
	    evtObj = [ evtObj ];

	var pref = User.preferences;

	var res = $.map(evtObj, function( objEvent ){			
		    
			var participantInfo = {}, me = { uid: User.me.id, name: User.me.name };

			var timezone = User.timezones[ (!!objEvent && !!objEvent.timezone) ? objEvent.timezone : User.preferences.timezone ];
			
		    var dateEvent = function( time){
			return new Date( parseInt(time) ).setTimezoneOffset( User.timezones[ pref.timezone] ).toString( User.preferences.dateFormat); }

			var timeEvent = function(time){
				if(time){
					var data =  new Date();
					data.setTime(time);
					data = getDateTimezone(data, timezone);
					return dateFormat(data, User.preferences.hourFormat.replace(/m/g,'M'))			
				}
			}
			if(!!objEvent)
		    return {
			      "class": objEvent["class"],
			      id: objEvent.id,
			      location: objEvent.location,
			      category: objEvent.category,
			      calendars: Calendar.calendars,
			      calendar: objEvent.calendar,
			      summary: objEvent.summary,
			      description: objEvent.description,
			      timezone: objEvent.timezone,
			      timezones: User.timezones,
			      startDate: dateEvent( objEvent.startTime ),
			      startHour: timeEvent(objEvent.startTime ),
			      endDate: dateEvent( objEvent.endTime ),
			      endHour: timeEvent(objEvent.endTime),
			      allDay: !!parseInt( objEvent.allDay ),
	  // 				attachments: this.decode( "attachment:detail", form ),
			      attendee: $.map(objEvent.participants || [], function( participant ){

					  participant = DataLayer.get( "participant", participant );

					  var user = DataLayer.get( "user", participant.user.id || participant.user );

					  var person = { uid: user.id,
						         name: user.name };

					  if( person.uid ===  me.uid )
					  {
					      participantInfo.status = participant.status;
					      participantInfo.alarms = participant.alarms;
					  }

					  if( parseInt( participant.isOrganizer ) )
					  {
					      participantInfo.organizer = person;
						  return(null);
					  }

					  return( person );

				      }),
			      organizer: participantInfo.organizer || me,
			      alarms: participantInfo.alarms || [],
			      status: participantInfo.status || 1,
			      me: me
			    };
		});

	if( !notArray )
	{
	    var dates = {};

	    for (var i=0; i<res.length; i++) {

		    var startDate = Date.parseExact( res[i]['startDate'], User.preferences.dateFormat );
		    var endDate   = Date.parseExact( res[i]['endDate'], User.preferences.dateFormat );

		    var counter   = startDate.clone();

		    while (counter.compareTo(startDate) == 0) {

			    if (!dates[counter.toString(User.preferences.dateFormat)]) 
				dates[counter.toString(User.preferences.dateFormat)] = { startDate:false, events:[] };
			    if (!dates[counter.toString(User.preferences.dateFormat)].startDate) 
				dates[counter.toString(User.preferences.dateFormat)].startDate = counter.toString(User.preferences.dateFormat);

			    dates[counter.toString(User.preferences.dateFormat)].events.push(res[i]);
			    counter.addDays(-1);
		    } 
	    }
	    res = { events_list: dates,
				count : res.length
			};
	}

	return notArray ? res[0] : res;
    }

});

DataLayer.codec( "participant", "detail", {
  
    encoder: function( participants ){

	  var result = {};
      
	  for( var i = 0; i< participants.length; i++ )
	  {
	      result[ participants[i].user.id || participants[i].user ] = participants[i];
	  }

	  return( result );
    }
});

DataLayer.codec( "calendar", "list", {
  
    encoder: function( calendars ){

	var result = { my_calendars: [], others_calendars: [] };

	for( var i = 0; i < calendars.length; i++ )
	{
	    if( Calendar.signatureOf[ calendars[i].id ].isOwner )
		result.my_calendars.push( calendars[i] );
	    else
		result.others_calendars.push( calendars[i] );
	}

	return { agendas_usuario: result };

    }

});

DataLayer.codec( "schedulable", "calendar", {

    decoder:function( evtObj ){
	
	if( notArray = $.type(evtObj) !== "array" )
	    evtObj = [ evtObj ];
	
	var res = $.map(evtObj, function( evt ){

		    return { id: evt.id,
			     summary: evt.title,
			     startTime: evt.start.getTime(),
			     endTime: ( !!evt.allDay ? (( evt.end || evt.start ).getTime() + 86400000) :( evt.end || evt.start ).getTime()),
			     allDay: ( !!evt.allDay ? 1 : 0 )
			     /*calendar: evt.id && User.calendarOf[ evt.id ].id*/ };
	});

	return notArray ? res[0] : res;
    },

    encoder: function( evtObj, filter ){
      
	if( !evtObj )
	    return( false );

//       if( notArray = $.type(evtObj) !== "array" )
// 	  evtObj = [ evtObj ];
// 	alert( evtObj );
	var filtered = evtObj;
	
	// repeat:{
// 	  frequency: "weekly",
// 	  endTime: Date.parse("+10 days").getTime(),
// 	  interval: 3,
// 	  byday: 3,
// 	  bysecond: 3,
// 	  byminute: 3,
// 	  bymonthday: 3,
// 	  byyearday: 3,
// 	  byweekno: 3,
// 	  bysetpos: 3,
// 	  wkst: "monday"/*,
// 	  duration: true*/
//       }

// 	$.each(evtObj, function( index, evt ){

// 		alert( dump(!!evt.repeat) );

// 		if( evt && !!evt.repeat && (evt.startTime < filter.end || (evt.repeat.endTime || 0) > filter.start ) )
// 		{
// // 		    var interval = evt.repeat.interval;
// 
// 		    var current = new Date( evt.startTime );
// 		    var begin = new Date( filter.start );
// 		    var end = new Date( filter.end );
// 		    var offset = evt.endTime - evt.startTime;
// 
// 		    var ocurrence = [];
// 
// 		    while( Date.compare( current, begin ) !== 1 )
// 			current = current.parse( "+" + evt.repeat.interval + " " + frequency + "s" );
// 
// 		    while( current.before( end ) && (ocurrence[ ocurrence.length ] = current) )
// 			current = current.parse( "+" + evt.repeat.interval + " " + frequency + "s" );
// 
// 		    for( var i = 0; i < ocurrences.length; i++ )
// 			filtered[ filtered.length ] = { URI: evt.URI,
// 							summary: evt.summary,
// 							start: new Date( ocurrences[i] ),
// 							end: new Date( ocurrences[i] + offset ),
// 							allDay: evt.allDay };
// 
// // 		    switch( evt.repeat.frequency )
// // 		    {
// // 		      case "yearly":   interval *= 12;
// // 		      case "monthly":  interval *= 30; //TODO: get the month variant
// // 		      case "weekly":   interval *= 7;
// // 		      case "daily":    interval *= 24;
// // 		      case "hourly":   interval *= 60;
// // 		      case "minutely": interval *= 60; 
// // 		      case "secondly": interval *= 1000;
// // 		    }
// // 		  
// // 		    var rest = ( filter.start - evt.startTime ) % interval;
// // 
// // 		    var offset = evt.endTime - evt.startTime;
// // 
// // 		    if( rest < offset )
// // 		    {
// // 			var freq = Math.floor( offset - rest / interval );
// // 
// // 			
// // 
// // 			for( var i = 0; i < freq; i++ )
// // 			{
// // 			     var ocurrence = filter.start + rest + ( interval * i );
// // 
// // 			     
// // 			}
// // 
// // 			
// // 		    }
// 		}

// 		if( parseInt( evt.endTime ) > filter[1][0][2] || parseInt( evt.startTime ) < filter[1][1][2] )
// 		    filtered[ filtered.length ] = evt;
// 
// 	});

	var grouped = {};

	$.map(filtered, function( evt ){

		evt.calendar = evt.calendar || "1";

		if( !grouped[ evt.calendar ] )
		    grouped[ evt.calendar ] = [];
			
		var calendar = DataLayer.get('calendar', evt.calendar);
		
		var timesEvent = function(time, timezone){
			return getDateTimezone(time, User.timezones[timezone], false )
		};
	  
		grouped[ evt.calendar ].push( { id: evt.URI || evt.id,
						title: Encoder.htmlDecode(evt.summary),
						start: timesEvent(new Date( parseInt( evt.startTime )), calendar.timezone),
						end: !!parseInt(evt.allDay) ? timesEvent(new Date( (parseInt( evt.endTime ) - 86400000) )) : timesEvent(new Date( parseInt( evt.endTime ) ), calendar.timezone),
						allDay: !!parseInt( evt.allDay ) } );
	});

	return(/* notArray ? filtered[0] :*/ grouped );
    },
    
    criteria: function( filter ){
      
	if( $.type(filter.start) !== 'date' )
	    filter.start = new Date( filter.start * 1000 );
	if( $.type(filter.end) !== 'date' )
	    filter.end = new Date( filter.end * 1000 );

	return { filter: ["AND", 

			    [ ">=", "rangeStart", filter.start.toString( "dd-MM-yyyy" ) ],
			    [ "<=", "rangeEnd", filter.end.toString( "dd-MM-yyyy" ) ],
			    [ "IN", "calendar", Calendar.calendarIds ]

			  ], 
		 criteria: { deepness: 2 } }
    }
});


DataLayer.codec( "preference", "detail", {
  
  decoder:function( pref ){
	
	var res = [];

      pref.defaultAlarm = $.map( pref.alarmTime || [], function( alarmTime, i ){
	      
	    return { type: pref.alarmType[i], 
		     time: alarmTime,
		     unit: pref.alarmUnit[i] };
	
      });

      $.each( pref, function( i, el ){
	
	  res[ res.length ] = { name: i, value: el };
	
      });
    
      return( res );
      
  },

  encoder:function( pref ){

      return( pref );

  }

});

DataLayer.codec( "schedulable", "export", {
  
      decoder: function(){

	  

      },
      
      encoder: function( signatures ){

	  

      },
      
      criteria: function( filter ){
	
	  if( isCal  = filter && filter.calendar )
	      filter = filter.calendar;

	    return {

		      filter: filter ? [  "=", ( isCal ? "calendar" : "id" ), filter ] : false,

		      criteria: { format: 'iCal', deepness: 2 }
	    };
      }


});

Alarms.load();

// DataLayer.decoder( "participant", "detail", function( form ){
//  
// //     if( $.type( attObj ) !== "array" ){
// // 	notArray = true;
// // 	attObj = [ attObj ];
// //     }
// 
//     
// 
//     return( participants );
// 
// });

// DataLayer.decoder( "alarm", "detail", function( form ){
// 
// //       if( $.type( attObj ) !== "array" ){
// // 	    notArray = true;
// // 	    attObj = [ attObj ];
// //     }
// 
//     var alarms = [];
// 
//     if( form.alarmType /*&& !form.*/ )
// 	for( var i = 0; i < form.alarmType.length; i++ )
// 	{
// 	    if( form.alarmTime[i] === "" )
// 		continue;
// 	  
// 	    alarms[i] = { type: form.alarmType[i], 
// 			  unit: form.alarmUnit[i], 
// 			  time: form.alarmTime[i] };
// 	}
// 
//     return( alarms );
// 
// });