/*
 Copyright (C) 2004-2005 SKYRIX Software AG
 
 This file is part of SOPE.
 
 SOPE is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the
 Free Software Foundation; either version 2, or (at your option) any
 later version.
 
 SOPE is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with SOPE; see the file COPYING.  If not, write to the
 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 02111-1307, USA.
*/

#include "iCalRecurrenceCalculator.h"
#include <NGExtensions/NGCalendarDateRange.h>
#include "iCalRecurrenceRule.h"
#include "NSCalendarDate+ICal.h"
#include "common.h"

/* class cluster */

@interface iCalDailyRecurrenceCalculator : iCalRecurrenceCalculator
{
}
@end

@interface iCalWeeklyRecurrenceCalculator : iCalRecurrenceCalculator
{
}
@end

@interface iCalMonthlyRecurrenceCalculator : iCalRecurrenceCalculator
{
}
@end

@interface iCalYearlyRecurrenceCalculator : iCalRecurrenceCalculator
{
}
@end

/* Private */

@interface iCalRecurrenceCalculator (PrivateAPI)
- (NSCalendarDate *)lastInstanceStartDate;
@end

@implementation iCalRecurrenceCalculator

static Class dailyCalcClass   = Nil;
static Class weeklyCalcClass  = Nil;
static Class monthlyCalcClass = Nil;
static Class yearlyCalcClass  = Nil;

+ (void)initialize {
  static BOOL didInit = NO;
  
  if (didInit) return;
  didInit = YES;

  dailyCalcClass   = [iCalDailyRecurrenceCalculator   class];
  weeklyCalcClass  = [iCalWeeklyRecurrenceCalculator  class];
  monthlyCalcClass = [iCalMonthlyRecurrenceCalculator class];
  yearlyCalcClass  = [iCalYearlyRecurrenceCalculator  class];
}

+ (id)recurrenceCalculatorForRecurrenceRule:(iCalRecurrenceRule *)_rrule
         withFirstInstanceCalendarDateRange:(NGCalendarDateRange *)_range
{
  return [[[self alloc] initWithRecurrenceRule:_rrule
                        firstInstanceCalendarDateRange:_range] autorelease];
}

- (id)initWithRecurrenceRule:(iCalRecurrenceRule *)_rrule
  firstInstanceCalendarDateRange:(NGCalendarDateRange *)_range
{
  iCalRecurrenceFrequency freq;
  Class calcClass = Nil;

  freq = [_rrule frequency];
  if (freq == iCalRecurrenceFrequenceDaily)
    calcClass = dailyCalcClass;
  else if (freq == iCalRecurrenceFrequenceWeekly)
    calcClass = weeklyCalcClass;
  else if (freq == iCalRecurrenceFrequenceMonthly)
    calcClass = monthlyCalcClass;
  else if (freq == iCalRecurrenceFrequenceYearly)
    calcClass = yearlyCalcClass;

  [self autorelease];
  if (calcClass == Nil)
    return nil;

  self = [[calcClass alloc] init];
  ASSIGN(self->rrule, _rrule);
  ASSIGN(self->firstRange, _range);
  return self;  
}


/* calculation */

- (NSArray *)recurrenceRangesWithinCalendarDateRange:(NGCalendarDateRange *)_r {
  return nil; /* subclass responsibility */
}
- (BOOL)doesRecurrWithinCalendarDateRange:(NGCalendarDateRange *)_range {
  NSArray *ranges;

  ranges = [self recurrenceRangesWithinCalendarDateRange:_range];
  return (ranges == nil || [ranges count] == 0) ? NO : YES;
}

- (NGCalendarDateRange *)firstInstanceCalendarDateRange {
  return self->firstRange;
}

- (NGCalendarDateRange *)lastInstanceCalendarDateRange {
  NSCalendarDate *start, *end;

  start = [self lastInstanceStartDate];
  if (!start)
    return nil;
  end   = [start addTimeInterval:[self->firstRange duration]];
  return [NGCalendarDateRange calendarDateRangeWithStartDate:start
                              endDate:end];
}

- (NSCalendarDate *)lastInstanceStartDate {
  NSCalendarDate *until;
  
  /* NOTE: this is horribly inaccurate and doesn't even consider the use
  of repeatCount. It MUST be implemented by subclasses properly! However,
  it does the trick for SOGO 1.0 - that's why it's left here.
  */
  if ((until = [self->rrule untilDate]) != nil)
    return until;
  return nil;
}

@end /* iCalRecurrenceCalculator */


@implementation iCalDailyRecurrenceCalculator

- (NSArray *)recurrenceRangesWithinCalendarDateRange:(NGCalendarDateRange *)_r {
  NSMutableArray *ranges;
  NSCalendarDate *firStart;
  long           i, jnFirst, jnStart, jnEnd, startEndCount;
  unsigned       interval;

  firStart = [self->firstRange startDate];
  jnFirst  = [firStart julianNumber];
  jnEnd    = [[_r endDate] julianNumber];
  
  if (jnFirst > jnEnd)
    return nil;
  
  jnStart  = [[_r startDate] julianNumber];
  interval = [self->rrule repeatInterval];
  
  /* if rule is bound, check the bounds */
  if (![self->rrule isInfinite]) {
    NSCalendarDate *until;
    long           jnRuleLast;
    
    until = [self->rrule untilDate];
    if (until) {
      if ([until compare:[_r startDate]] == NSOrderedAscending)
        return nil;
      jnRuleLast = [until julianNumber];
    }
    else {
      jnRuleLast = (interval * [self->rrule repeatCount])
      + jnFirst;
      if (jnRuleLast < jnStart)
        return nil;
    }
    /* jnStart < jnRuleLast < jnEnd ? */
    if (jnEnd > jnRuleLast)
      jnEnd = jnRuleLast;
  }

  startEndCount = (jnEnd - jnStart) + 1;
  ranges        = [NSMutableArray arrayWithCapacity:startEndCount];
  for (i = 0 ; i < startEndCount; i++) {
    long jnCurrent;
    
    jnCurrent = jnStart + i;
    if (jnCurrent >= jnFirst) {
      long jnTest;
      
      jnTest = jnCurrent - jnFirst;
      if ((jnTest % interval) == 0) {
        NSCalendarDate      *start, *end;
        NGCalendarDateRange *r;
      
        start = [NSCalendarDate dateForJulianNumber:jnCurrent];
        start = [start hour:  [firStart hourOfDay]
                       minute:[firStart minuteOfHour]
                       second:[firStart secondOfMinute]];
        end   = [start addTimeInterval:[self->firstRange duration]];
        r     = [NGCalendarDateRange calendarDateRangeWithStartDate:start
                                     endDate:end];
        [ranges addObject:r];
      }
    }
  }
  return ranges;
}

- (NSCalendarDate *)lastInstanceStartDate {
  if ([self->rrule repeatCount] > 0) {
    long           jnFirst, jnRuleLast;
    NSCalendarDate *firStart, *until;

    firStart   = [self->firstRange startDate];
    jnFirst    = [firStart julianNumber];
    jnRuleLast = ([self->rrule repeatInterval] *
                  [self->rrule repeatCount]) +
                  jnFirst;
    until      = [NSCalendarDate dateForJulianNumber:jnRuleLast];
    until      = [until hour:  [firStart hourOfDay]
                        minute:[firStart minuteOfHour]
                        second:[firStart secondOfMinute]];
    return until;
  }
  return [super lastInstanceStartDate];
}

@end /* iCalDailyRecurrenceCalculator */


/*
   TODO: If BYDAY is specified, lastInstanceStartDate and recurrences will
         differ significantly!
*/
@implementation iCalWeeklyRecurrenceCalculator

- (NSArray *)recurrenceRangesWithinCalendarDateRange:(NGCalendarDateRange *)_r {
  NSMutableArray *ranges;
  NSCalendarDate *firStart;
  long           i, jnFirst, jnStart, jnEnd, startEndCount;
  unsigned       interval, byDayMask;

  firStart = [self->firstRange startDate];
  jnFirst  = [firStart julianNumber];
  jnEnd    = [[_r endDate] julianNumber];
  
  if (jnFirst > jnEnd)
    return nil;
  
  jnStart  = [[_r startDate] julianNumber];
  interval = [self->rrule repeatInterval];
  
  /* if rule is bound, check the bounds */
  if (![self->rrule isInfinite]) {
    NSCalendarDate *until;
    long           jnRuleLast;
    
    until = [self->rrule untilDate];
    if (until) {
      if ([until compare:[_r startDate]] == NSOrderedAscending)
        return nil;
      jnRuleLast = [until julianNumber];
    }
    else {
      jnRuleLast = (interval * [self->rrule repeatCount] * 7)
      + jnFirst;
      if (jnRuleLast < jnStart)
        return nil;
    }
    /* jnStart < jnRuleLast < jnEnd ? */
    if (jnEnd > jnRuleLast)
      jnEnd = jnRuleLast;
  }
  
  startEndCount = (jnEnd - jnStart) + 1;
  ranges        = [NSMutableArray arrayWithCapacity:startEndCount];
  byDayMask     = [self->rrule byDayMask];
  if (!byDayMask) {
    for (i = 0 ; i < startEndCount; i++) {
      long jnCurrent;
      
      jnCurrent = jnStart + i;
      if (jnCurrent >= jnFirst) {
        long jnDiff;
        
        jnDiff = jnCurrent - jnFirst; /* difference in days */
        if ((jnDiff % (interval * 7)) == 0) {
          NSCalendarDate      *start, *end;
          NGCalendarDateRange *r;
          
          start = [NSCalendarDate dateForJulianNumber:jnCurrent];
          start = [start hour:  [firStart hourOfDay]
                         minute:[firStart minuteOfHour]
                         second:[firStart secondOfMinute]];
          end   = [start addTimeInterval:[self->firstRange duration]];
          r     = [NGCalendarDateRange calendarDateRangeWithStartDate:start
                                       endDate:end];
          [ranges addObject:r];
        }
      }
    }
  }
  else {
    [self errorWithFormat:@"Cannot calculate rules with byDayMask, yet!"];
  }
  return ranges;
}

- (NSCalendarDate *)lastInstanceStartDate {
  if ([self->rrule repeatCount] > 0) {
    long           jnFirst, jnRuleLast;
    NSCalendarDate *firStart, *until;
    
    firStart   = [self->firstRange startDate];
    jnFirst    = [firStart julianNumber];
    jnRuleLast = ([self->rrule repeatInterval] *
                  [self->rrule repeatCount] * 7) +
                  jnFirst;
    until      = [NSCalendarDate dateForJulianNumber:jnRuleLast];
    until      = [until hour:  [firStart hourOfDay]
                        minute:[firStart minuteOfHour]
                        second:[firStart secondOfMinute]];
    return until;
  }
  return [super lastInstanceStartDate];
}

@end /* iCalWeeklyRecurrenceCalculator */

@implementation iCalMonthlyRecurrenceCalculator

- (NSArray *)recurrenceRangesWithinCalendarDateRange:(NGCalendarDateRange *)_r {
  NSMutableArray *ranges;
  NSCalendarDate *firStart, *rStart, *rEnd, *until;
  unsigned       i, count, interval, diff;

  firStart = [self->firstRange startDate];
  rStart   = [_r startDate];
  rEnd     = [_r endDate];
  interval = [self->rrule repeatInterval];
  until    = [self lastInstanceStartDate];

  if (until) {
    if ([until compare:rStart] == NSOrderedAscending)
      return nil;
    if ([until compare:rEnd] == NSOrderedDescending)
      rEnd = until;
  }

  diff   = [firStart monthsBetweenDate:rStart];
  count  = [rStart monthsBetweenDate:rEnd] + 1;
  ranges = [NSMutableArray arrayWithCapacity:count];
  for (i = 0 ; i < count; i++) {
    unsigned test;
    
    test = diff + i;
    if ((test % interval) == 0) {
      NSCalendarDate      *start, *end;
      NGCalendarDateRange *r;
      
      start = [firStart dateByAddingYears:0
                        months:diff + i
                        days:0];
      end   = [start addTimeInterval:[self->firstRange duration]];
      r     = [NGCalendarDateRange calendarDateRangeWithStartDate:start
                                   endDate:end];
      [ranges addObject:r];
    }
  }
  return ranges;
}

- (NSCalendarDate *)lastInstanceStartDate {
  if ([self->rrule repeatCount] > 0) {
    NSCalendarDate *until;
    unsigned       months, interval;

    interval = [self->rrule repeatInterval];
    months   = [self->rrule repeatCount] * interval;
    until    = [[self->firstRange startDate] dateByAddingYears:0
                                             months:months
                                             days:0];
    return until;
  }
  return [super lastInstanceStartDate];
}

@end /* iCalMonthlyRecurrenceCalculator */

@implementation iCalYearlyRecurrenceCalculator

- (NSArray *)recurrenceRangesWithinCalendarDateRange:(NGCalendarDateRange *)_r {
  NSMutableArray *ranges;
  NSCalendarDate *firStart, *rStart, *rEnd, *until;
  unsigned       i, count, interval, diff;
  
  firStart = [self->firstRange startDate];
  rStart   = [_r startDate];
  rEnd     = [_r endDate];
  interval = [self->rrule repeatInterval];
  until    = [self lastInstanceStartDate];
  
  if (until) {
    if ([until compare:rStart] == NSOrderedAscending)
      return nil;
    if ([until compare:rEnd] == NSOrderedDescending)
      rEnd = until;
  }
  
  diff   = [firStart yearsBetweenDate:rStart];
  count  = [rStart yearsBetweenDate:rEnd] + 1;
  ranges = [NSMutableArray arrayWithCapacity:count];
  for (i = 0 ; i < count; i++) {
    unsigned test;
    
    test = diff + i;
    if ((test % interval) == 0) {
      NSCalendarDate      *start, *end;
      NGCalendarDateRange *r;
      
      start = [firStart dateByAddingYears:diff + i
                        months:0
                        days:0];
      end   = [start addTimeInterval:[self->firstRange duration]];
      r     = [NGCalendarDateRange calendarDateRangeWithStartDate:start
                                   endDate:end];
      [ranges addObject:r];
    }
  }
  return ranges;
}

- (NSCalendarDate *)lastInstanceStartDate {
  if ([self->rrule repeatCount] > 0) {
    NSCalendarDate *until;
    unsigned       years, interval;
    
    interval = [self->rrule repeatInterval];
    years    = [self->rrule repeatCount] * interval;
    until    = [[self->firstRange startDate] dateByAddingYears:years
                                             months:0
                                             days:0];
    return until;
  }
  return [super lastInstanceStartDate];
}

@end /* iCalYearlyRecurrenceCalculator */
