/* -*- Mode: javascript; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

(function() {
  'use strict';

  /**
   * @name Attendees
   * @constructor
   * @param {object} component - a Component object instance
   */
  function Attendees(component) {
    this.component = component;
    if (this.component.attendees) {
      _.forEach(this.component.attendees, function(attendee) {
        attendee.image = Attendees.$gravatar(attendee.email, 32);
      });
    }
    this.workDaysOnly = true;
    this.slotStartTimeLimit = new Date();
    this.slotStartTimeLimit.setMinutes(0);
    this.slotStartTimeLimit.setHours(Attendees.dayStartHour);
    this.slotEndTimeLimit = new Date();
    this.slotEndTimeLimit.setMinutes(0);
    this.slotEndTimeLimit.setHours(Attendees.dayEndHour);
    this.$days = [];
    this.$futureFreebusyData = {};
    this.updateFreeBusyCoverage();
    this.updateFreeBusy();
    if (this.$days.length == 0) {
      this.getDays();
    }
  }

  /**
   * @memberof Attendees
   * @desc The factory we'll use to register with Angular
   * @returns the Attendees constructor
   */
  Attendees.$factory = ['$q', '$timeout', '$log', 'sgSettings', 'Attendees_ROLES', 'Preferences', 'User', 'Card', 'Gravatar', 'Resource', function($q, $timeout, $log, Settings, ROLES, Preferences, User, Card, Gravatar, Resource) {
    angular.extend(Attendees, {
      $q: $q,
      $timeout: $timeout,
      $log: $log,
      $settings: Settings,
      $User: User,
      $Preferences: Preferences,
      $Card: Card,
      $gravatar: Gravatar,
      $$resource: new Resource(Settings.activeUser('folderURL') + 'Calendar', Settings.activeUser()),
      ROLES: ROLES
    });

    Attendees.dayStartHour = parseInt(Preferences.defaults.SOGoDayStartTime.split(':')[0]);
    Attendees.dayEndHour = parseInt(Preferences.defaults.SOGoDayEndTime.split(':')[0]);

    return Attendees; // return constructor
  }];

  /**
   * @module SOGo.SchedulerUI
   * @desc Factory registration of Attendees in Angular module.
   */
  try {
    angular.module('SOGo.SchedulerUI');
  }
  catch(e) {
    angular.module('SOGo.SchedulerUI', ['SOGo.Common']);
  }
  angular.module('SOGo.SchedulerUI')
    .constant('Attendees_ROLES', {
      REQ_PARTICIPANT: 'req-participant',
      OPT_PARTICIPANT: 'opt-participant',
      NON_PARTICIPANT: 'non-participant',
      CHAIR: 'chair'
    })
    .factory('Attendees', Attendees.$factory);

  /**
   * @function timeToQuarters
   * @memberof Attendees
   * @param {date} dateTime - a Date object instance
   * @desc Return the number of quarters matching the time
   * @returns the number of quarters
   */
  Attendees.timeToQuarters = function(dateTime) {
    return dateTime.getHours() * 4 + Math.ceil(dateTime.getMinutes()/15);
  };

  /**
   * @function getLength
   * @memberof Attendees.prototype
   * @returns the number of attendees
   */
  Attendees.prototype.getLength = function() {
    return this.component.attendees ? this.component.attendees.length : 0;
  };

  /**
   * @function initOrganizer
   * @memberof Attendees.prototype
   * @desc Extend instance with organizer including her freebusy information.
   * @param {object} calendar - Calendar instance associated to current component
   */
  Attendees.prototype.initOrganizer = function(calendar) {
    var _this = this, promise;
    if (calendar && calendar.isSubscription) {
      promise = Attendees.$User.$filter(calendar.owner).then(function(results) {
        var owner = results[0];
        _this.component.organizer = {
          uid: owner.uid,
          name: owner.cn,
          email: owner.c_email
        };
      });
    }
    else {
      if (!this.component.organizer) {
        this.component.organizer = {
          uid: Attendees.$settings.activeUser('login'),
          name: Attendees.$settings.activeUser('identification'),
          email: Attendees.$settings.activeUser('email')
        };
      }
      promise = Attendees.$q.when();
    }
    // Fetch organizer's freebusy
    promise.then(function() {
      _this.updateFreeBusyAttendee(_this.component.organizer);
    });
  };

  /**
   * @function add
   * @memberof Attendees.prototype
   * @desc Add an attendee and fetch his freebusy info.
   * @param {Object} card - an Card object instance to be added to the attendees list
   */
  Attendees.prototype.add = function(card, options) {
    var _this = this, attendee, list, url, params, promise = Attendees.$q.when();
    if (card) {
      if (!this.component.attendees || (options && options.organizerCalendar)) {
        // No attendee yet; initialize the organizer
        this.initOrganizer(options? options.organizerCalendar : null);
      }
      if (card.$isList({expandable: true})) {
        // Decompose list members
        list = Attendees.$Card.$find(card.container, card.c_name);
        promise = list.$id().then(function(listId) {
          _.forEach(list.refs, function(ref) {
            attendee = {
              name: ref.c_cn,
              email: ref.$preferredEmail(options? options.partial : null),
              role: Attendees.ROLES.REQ_PARTICIPANT,
              partstat: 'needs-action',
              uid: ref.c_uid,
              $avatarIcon: 'person',
            };
            if (!_.find(_this.component.attendees, function(o) {
              return o.email == attendee.email;
            })) {
              // Contact is not already an attendee, add it
              attendee.image = Attendees.$gravatar(attendee.email, 32);
              if (_this.component.attendees)
                _this.component.attendees.push(attendee);
              else
                _this.component.attendees = [attendee];
              _this.updateFreeBusyAttendee(attendee);
            }
          });
        });
      }
      else {
        // Single contact
        attendee = {
          uid: card.c_uid,
          domain: card.c_domain,
          isMSExchange: card.ismsexchange,
          isGroup: card.$isList(),
          isExpandableGroup: false,
          isResource: card.isresource,
          name: card.c_cn,
          email: card.$$email,
          role: Attendees.ROLES.REQ_PARTICIPANT,
          partstat: 'needs-action',
          $avatarIcon: card.$avatarIcon
        };
        if (!_.find(this.attendees, function(o) {
          return o.email == attendee.email;
        })) {
          if (card.$isList() && Attendees.$Preferences.defaults.SOGoLDAPGroupExpansionEnabled) {
            // LDAP list -- preload members
            promise = card.$members().then(function(members) {
              attendee.members = members;
              attendee.isExpandableGroup = true;
            });
          }
          attendee.image = Attendees.$gravatar(attendee.email, 32);
          if (this.component.attendees) {
            if (_.findIndex(this.component.attendees, { email: attendee.email }) < 0)
              this.component.attendees.push(attendee);
          }
          else
            this.component.attendees = [attendee];
          this.updateFreeBusyAttendee(attendee);
        }
      }
    }

    return promise;
  };

  /**
   * @function nextRole
   * @memberof Attendees.prototype
   * @desc Switch the attendee to the next participation role.
   * @param {Object} attendee - the attendee definition
   */
  Attendees.prototype.nextRole = function(attendee) {
    var roles = _.values(Attendees.ROLES);
    var index = _.findIndex(roles, function(role) {
      return attendee.role === role;
    });
    attendee.role = roles[++index % 4];
  };

  /**
   * @function hasAttendee
   * @memberof Attendees.prototype
   * @desc Verify if one of the email addresses of a Card instance matches an attendee.
   * @param {Object} card - an Card object instance
   * @returns true if the Card matches an attendee
   */
  Attendees.prototype.hasAttendee = function(card) {
    var attendee = _.find(this.component.attendees, function(attendee) {
      return _.find(card.emails, function(email) {
        return email.value == attendee.email;
      });
    });
    return angular.isDefined(attendee);
  };

  /**
   * @function remove
   * @memberof Attendees.prototype
   * @desc Remove an attendee from the component.
   * @param {Object} attendee - an object literal defining an attendee
   */
  Attendees.prototype.remove = function(attendee) {
    var index = _.findIndex(this.component.attendees, function(currentAttendee) {
      return currentAttendee.email == attendee.email;
    });
    if (index > -1)
      this.component.attendees.splice(index, 1);
    delete this.$futureFreebusyData[attendee.uid];
  };

  /**
   * @function updateFreeBusyCoverage
   * @memberof Attendees.prototype
   * @desc Build a 15-minute-based representation of the component's period.
   * @returns an object literal hashed by days and hours and arrays of four 1's and 0's
   */
  Attendees.prototype.updateFreeBusyCoverage = function() {
    var _this = this, freebusy = {};
    var roundedStart, roundedEnd, startQuarter, endQuarter;

    if (this.component.start && this.component.end) {
      roundedStart = new Date(this.component.start.getTime());
      roundedEnd = new Date(this.component.end.getTime());
      if (this.component.isAllDay) {
        roundedStart.setHours(Attendees.dayStartHour);
        roundedStart.setMinutes(0);
        roundedEnd.setHours(Attendees.dayEndHour);
        roundedEnd.setMinutes(0);
        startQuarter = endQuarter = 0;
      }
      else {
        startQuarter = parseInt(roundedStart.getMinutes()/15 + 0.5);
        endQuarter = parseInt(roundedEnd.getMinutes()/15 + 0.5);
      }
      roundedStart.setMinutes(15*startQuarter);
      roundedEnd.setMinutes(15*endQuarter);

      _.forEach(roundedStart.beginOfDay().daysUpTo(roundedEnd.beginOfDay()), function(date, index) {
        if (date < roundedStart)
          date = new Date(roundedStart.getTime());
        var currentDay = date.getDate(),
            dayKey = date.getDayString(),
            hourKey;
        if (dayKey === roundedStart.getDayString()) {
          hourKey = date.getHours().toString();
          freebusy[dayKey] = {};
          freebusy[dayKey][hourKey] = [];
          while (startQuarter > 0) {
            freebusy[dayKey][hourKey].push(0);
            startQuarter--;
          }
        }
        else {
          date = date.beginOfDay();
          freebusy[dayKey] = {};
        }
        while (date.getTime() < roundedEnd.getTime() &&
               date.getDate() == currentDay) {
          hourKey = date.getHours().toString();
          if (angular.isUndefined(freebusy[dayKey][hourKey]))
            freebusy[dayKey][hourKey] = [];
          freebusy[dayKey][hourKey].push(1);
          date.addMinutes(15);
        }
      });
      this.freebusy = freebusy;
    }
  };

  /**
   * @function coversFreeBusy
   * @memberof Attendees.prototype
   * @desc Check if a specific quarter matches the component's period.
   * @returns true if the quarter covers the component's period
   */
  Attendees.prototype.coversFreeBusy = function(day, hour, quarter) {
    var b = (this.freebusy &&
             angular.isDefined(this.freebusy[day]) &&
             angular.isDefined(this.freebusy[day][hour]) &&
             this.freebusy[day][hour][quarter] == 1);
    return b;
  };

  /**
   * @function getDays
   * @memberof Attendees.prototype
   * @desc Define a period of one week before and one week after the component's period or a reference date.
   * @param refDate - a Date object
   * @returns an array of objects representing the days
   */
  Attendees.prototype.getDays = function(refDate) {
    var _this = this, sd, ed, formatFcn;

    if (refDate) {
      sd = refDate;
      ed = new Date(refDate.getTime());
      ed.addMinutes(this.component.delta);
    }
    else {
      sd = this.component.start;
      ed = this.component.end;
    }

    if (this.$days.length === 0 ||
        _.findIndex(this.$days, ['getDayString', sd.getDayString()]) < 0 ||
        _.findIndex(this.$days, ['getDayString', ed.getDayString()]) < 0) {
      sd = sd.beginOfDay().addDays(-7);
      ed = ed.beginOfDay().addDays(7);
      formatFcn = Attendees.$Preferences.$mdDateLocaleProvider.formatDate;
      this.$days.splice(0, this.$days.length);
      _.forEach(sd.daysUpTo(ed), function(date) {
        date.$dateFormat = Attendees.$Preferences.defaults.SOGoLongDateFormat;
        _this.$days.push({
          stringWithSeparator: formatFcn(date),
          getDayString: date.getDayString()
        });
      });
    }

    return this.$days;
  };

  /**
   * @function updateFreeBusy
   * @memberof Attendees.prototype
   * @desc Fetch the freebusy information of the organizer and all attendees.
   * @returns a promise of the all HTTP operations
   */
  Attendees.prototype.updateFreeBusy = function(refDate) {
    var _this = this, promises = [];

    if (this.getLength() > 0) {
      if (this.component.organizer) {
        promises.push(this.updateFreeBusyAttendee(this.component.organizer, refDate));
      }
      _.forEach(_.filter(this.component.attendees, 'uid'), function(attendee) {
        promises.push(_this.updateFreeBusyAttendee(attendee, refDate));
      });
    }

    return Attendees.$q.all(promises);
  };

  /**
   * @function updateFreeBusyAttendee
   * @memberof Attendees.prototype
   * @desc Update the freebusy information for the component's period for a specific attendee.
   * @param {Object} card - an Card object instance of the attendee
   * @returns a promise of the HTTP operation if the information was not cached
   */
  Attendees.prototype.updateFreeBusyAttendee = function(attendee, refDate) {
    var promise, resource, uid, sd, ed, params, days;

    if (attendee.uid) {
      uid = attendee.uid;
      if (attendee.domain)
        uid += '@' + attendee.domain;
      days = _.map(this.getDays(refDate), 'getDayString');
      params =
        {
          sday: days[0],
          eday: days[days.length - 1]
        };

      if (attendee.isMSExchange) {
        // Attendee is not a local user, but her freebusy data is available from an external MS Exchange server;
        // we query /SOGo/so/<login_user>/freebusy.ifb/ajaxRead?uid=<uid>
        resource = Attendees.$$resource.userResource();
        params.uid = uid;
      }
      else {
        // Attendee is a user;
        // web query /SOGo/so/<uid>/freebusy.ifb/ajaxRead
        resource = Attendees.$$resource.userResource(uid);
      }

      if (angular.isUndefined(attendee.freebusy))
        attendee.freebusy = {};

      if (_.intersection(_.keys(attendee.freebusy), days).length !== days.length) {
        // Fetch FreeBusy information
        promise = resource.fetch('freebusy.ifb', 'ajaxRead', params).then(function(data) {
          _.forEach(days, function(day) {
            var hour;

            if (angular.isUndefined(attendee.freebusy[day]))
              attendee.freebusy[day] = {};

            if (angular.isUndefined(data[day]))
              data[day] = {};

            for (var i = 0; i <= 23; i++) {
              hour = i.toString();
              if (data[day][hour])
                attendee.freebusy[day][hour] = [
                  data[day][hour]["0"],
                  data[day][hour]["15"],
                  data[day][hour]["30"],
                  data[day][hour]["45"]
                ];
              else
                attendee.freebusy[day][hour] = [0, 0, 0, 0];
            }
          });
        });
      }
      else {
        promise = Attendees.$q.when();
      }

      this.$futureFreebusyData[attendee.uid] = promise;

      return promise;
    }
  };


  /**
   * @function forwardFindDate
   * @memberof Attendees.prototype
   * @desc Find the next slot for which all attendees are available whitin the reference day
   * @param {date} currentStart - the reference day
   * @returns a date object or null if no slot were found
   */
  Attendees.prototype.forwardFindDate = function(currentStart) {
    var foundDate = null;
    var maxOffset = this.endLimit - this.duration;
    var offset = 0;

    if (this.firstStep) {
      offset = Math.floor(this.start.getHours() * 4 + this.start.getMinutes() / 15) + 1;
      this.firstStep = false;
    }
    else {
      offset = this.currentEntries.indexOf(0);
    }
    if (offset > -1 && offset < this.startLimit) {
      offset = this.startLimit;
    }

    while (!foundDate && offset > -1 && offset <= maxOffset) {
      var testDuration = 0;
      while (this.currentEntries[offset] === 0 && testDuration < this.duration) {
        testDuration++;
        offset++;
      }
      if (testDuration == this.duration) {
        foundDate = new Date();
        var foundTime = (currentStart.getTime() + (offset - testDuration) * 900000);
        foundDate.setTime(foundTime);
      }
      else {
        offset = this.currentEntries.indexOf(0, offset + 1);
      }
    }

    return foundDate;
  };

  /**
   * @function forwardAdjustCurrentStart
   * @memberof Attendees.prototype
   * @desc Adjust a date to the next non-weekend day
   * @param {date} currentStart - the reference day
   */
  Attendees.prototype.forwardAdjustCurrentStart = function (currentStart) {
    var day = currentStart.getDay();
    if (day === 0) {
      currentStart.addDays(1);
    }
    else if (day === 6) {
      currentStart.addDays(2);
    }
  };

  /**
   * @function backwardFindDate
   * @memberof Attendees.prototype
   * @desc Find the previous slot for which all attendees are available whitin the reference day
   * @param {date} currentStart - the reference day
   * @returns a date object or null if no slot were found
   */
  Attendees.prototype.backwardFindDate = function (currentStart) {
    var foundDate = null;
    var maxOffset = this.endLimit - this.duration;
    var offset;
    if (this.firstStep) {
      offset = Math.floor(this.start.getHours() * 4 + this.start.getMinutes() / 15) - 1;
      this.firstStep = false;
    }
    else {
      offset = this.currentEntries.lastIndexOf(0);
    }
    if (offset > maxOffset) {
      offset = maxOffset;
    }
    while (!foundDate && offset >= this.startLimit) {
      var testDuration = 0;
      var testOffset = offset;
      while (this.currentEntries[testOffset] === 0 && testDuration < this.duration) {
        testDuration++;
        testOffset++;
      }
      if (testDuration == this.duration) {
        foundDate = new Date();
        var foundTime = (currentStart.getTime() + offset * 900000);
        foundDate.setTime(foundTime);
      }
      else {
        offset = this.currentEntries.lastIndexOf(0, offset - 1);
      }
    }
    Attendees.$log.debug(['found = ' + foundDate, offset]);
    return foundDate;
  };

  /**
   * @function backwardAdjustCurrentStart
   * @memberof Attendees.prototype
   * @desc Adjust a date to the previous non-weekend day
   * @param {date} currentStart - the reference day
   */
  Attendees.prototype.backwardAdjustCurrentStart = function (currentStart) {
    var day = currentStart.getDay();
    if (day == 0) {
      currentStart.addDays(-2);
    }
    else if (day == 6) {
      currentStart.addDays(-1);
    }
  };

  /**
   * @function findSlot
   * @memberof Attendees.prototype
   * @desc Find the next or previous slot when all attendees are available.
   * @param {number} direction - the search direction (1 or -1)
   */
  Attendees.prototype.findSlot = function(direction) {
    var _this = this, currentStart;

    this.direction = direction;
    this.firstStep = true;

    if (direction > 0) {
      this.findDate = this.forwardFindDate;
      this.adjustCurrentStart = this.forwardAdjustCurrentStart;
    }
    else {
      this.findDate = this.backwardFindDate;
      this.adjustCurrentStart = this.backwardAdjustCurrentStart;
    }

    if (this.component.isAllDay) {
      // Event lasts all day within limits
      this.start = this.component.start.clone();
      this.start.setHours(Attendees.dayStartHour);
      this.start.setMinutes(0);
      this.start.setSeconds(0);

      this.end = this.component.end.clone();
      this.end.setHours(Attendees.dayEndHour);
      this.end.setMinutes(0);
      this.end.setSeconds(0);

      this.startLimit = Attendees.dayStartHour * 4; // from user's defaults
      this.endLimit = Attendees.dayEndHour * 4; // from user's defaults

      this.duration = (Attendees.dayEndHour - Attendees.dayStartHour) * 4;
    }
    else {
      // Event can be outside limits
      this.start = this.component.start;
      this.end = this.component.end;

      this.startLimit = Attendees.timeToQuarters(this.slotStartTimeLimit); // from time picker
      this.endLimit = Attendees.timeToQuarters(this.slotEndTimeLimit); // from time picker

      this.duration = Math.ceil((this.end.getTime() - this.start.getTime()) / 900000);
    }

    currentStart = this.component.start.clone();
    currentStart.setHours(0, 0, 0, 0);

    if (this.workDaysOnly) {
      this.adjustCurrentStart(currentStart);
    }

    // Start a recursive search
    return this.step(currentStart).then(function (foundDate) {
      _this.component.start = new Date(foundDate.getTime());
      _this.component.end = new Date(_this.component.start.getTime());
      _this.component.end.addMinutes(_this.component.delta);
      _this.updateFreeBusyCoverage();
      return foundDate;
    }).catch(function (err) {
      _this.updateFreeBusy();
      throw err;
    });
  };

  /**
   * @function mergeFreebusy
   * @memberof Attendees.prototype
   * @desc Merge freebusy information of organizer and all attendees for a referene date.
   * @param {date) start - the reference date
   */
  Attendees.prototype.mergeFreebusy = function(start) {
    var _this = this;
    var startDay = start.getDayString();

    return this.updateFreeBusy(start).then(function () {
      var i, j, attendee, attendeeEntries;
      _this.currentEntries = _.flatMap(_this.component.organizer.freebusy[startDay]);
      for (i = 0; i < _this.component.attendees.length; i++) {
        attendee = _this.component.attendees[i];
        if (attendee.freebusy && attendee.role !== Attendees.ROLES.NON_PARTICIPANT) {
          attendeeEntries = _.flatMap(attendee.freebusy[startDay]);
          for (j = 0; j < _this.currentEntries.length; j++) {
            _this.currentEntries[j] += attendeeEntries[j];
          }
        }
      }
    });
  };

  /**
   * @function step
   * @memberof Attendees.prototype
   * @desc Recursively search for the next available slot, one day a the time.
   * @param {date) currentStart - the starting day
   */
  Attendees.prototype.step = function(currentStart, count) {
    var _this = this;
    if (!parseInt(count)) {
      count = 0;
    } else if (count >= 30) {
      return Attendees.$q.reject(l('There\'s no free slot available for all attendees in the next 30 days. Please try a different date or length.'));
    }
    // var currentStartDay = currentStart.getDayString();
    return this.mergeFreebusy(currentStart).then(function () {
      var foundDate = _this.findDate(currentStart);
      if (foundDate) {
        return foundDate;
      }
      else {
        currentStart.addDays(_this.direction > 0 ? 1 : -1);
        currentStart.setHours(0, 0, 0, 0);
        if (_this.workDaysOnly) {
          _this.adjustCurrentStart(currentStart);
        }
        return _this.step(currentStart, count + 1);
      }
    });
  };

})();