//
//  PithosActivityFacility.m
//  pithos-macos
//
// Copyright 2011-2012 GRNET S.A. All rights reserved.
//
// Redistribution and use in source and binary forms, with or
// without modification, are permitted provided that the following
// conditions are met:
// 
//   1. Redistributions of source code must retain the above
//      copyright notice, this list of conditions and the following
//      disclaimer.
// 
//   2. Redistributions in binary form must reproduce the above
//      copyright notice, this list of conditions and the following
//      disclaimer in the documentation and/or other materials
//      provided with the distribution.
// 
// THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
// USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// 
// The views and conclusions contained in the software and
// documentation are those of the authors and should not be
// interpreted as representing official policies, either expressed
// or implied, of GRNET S.A.

#import "PithosActivityFacility.h"
#import "PithosAccount.h"
#import "pithos_macosAppDelegate.h"

static PithosActivityFacility *defaultPithosActivityFacility = nil;

@implementation PithosActivityFacility
@synthesize delegate;

#pragma mark -
#pragma mark - Singleton

+ (id)defaultPithosActivityFacility {
	@synchronized(self) {
		if (!defaultPithosActivityFacility)
			[[self alloc] init]; // Assignment not done here
	}
	return defaultPithosActivityFacility;
}

+ (id)allocWithZone:(NSZone *)zone {
    @synchronized(self) {
        if (!defaultPithosActivityFacility) {
            defaultPithosActivityFacility = [super allocWithZone:zone];
            return defaultPithosActivityFacility;
        }
    }
    return nil;
}

- (id)copyWithZone:(NSZone *)zone {
    return self;
}

- (id)retain {
    return self;
}

- (NSUInteger)retainCount {
    return UINT_MAX; // Can not be released
}

- (void)release {
    // Do nothing
}

- (id)autorelease {
    return self;
}

#pragma mark -
#pragma mark Object Lifecycle

- (id)init {
    if ((self = [super init])) {
        [self reset];
    }
    return self;
}

- (void)dealloc {
    [timer invalidate];
    [timer release];
    [runningActivities release];
    [endingActivities release];
    [super dealloc];
}

- (void)reset {
    @synchronized(self) {
        [timer invalidate];
        [timer release];
        
        [runningActivities release];
        runningActivities = [[NSMutableArray alloc] init];
        [endingActivities release];
        endingActivities = [[NSMutableArray alloc] init];
        totalUploadBytes = 0;
        currentUploadBytes = 0;
        totalDownloadBytes = 0;
        currentDownloadBytes = 0;
        
        pickedRunning = NO;
        
        timer = [[NSTimer scheduledTimerWithTimeInterval:[(pithos_macosAppDelegate *)[[NSApplication sharedApplication] delegate] activityFacilityTimeInterval] 
                                                  target:self 
                                                selector:@selector(update:) 
                                                userInfo:nil 
                                                 repeats:YES] retain];
    }
}

- (NSString *)description {
    return [NSString stringWithFormat:@"running activities: %lu, ending activities: %lu, totalUploadBytes: %lu, currentUploadBytes: %lu, totalDownloadBytes: %lu, currentDownloadBytes: %lu", 
            [runningActivities count], [endingActivities count], totalUploadBytes, currentUploadBytes, totalDownloadBytes, currentDownloadBytes];
}

#pragma mark -
#pragma mark Timer

- (void)update:(NSTimer *)aTimer {
    NSMutableDictionary *info = [NSMutableDictionary dictionary];
    @synchronized(self) {
        PithosActivity *activity = nil;
        NSUInteger endingActivitiesCount = [endingActivities count];
        NSUInteger runningActivitiesCount = [runningActivities count];
        if ((pickedRunning || !runningActivitiesCount) && endingActivitiesCount) {
            NSUInteger index;
            for (index = 0 ; index < endingActivitiesCount; index++) {
                activity = [endingActivities objectAtIndex:index];
                switch (activity.type) {
                    case PithosActivityUpload:
                        totalUploadBytes -= activity.totalBytes;
                        currentUploadBytes -= activity.currentBytes;
                        break;
                    case PithosActivityDownload:
                        totalDownloadBytes -= activity.totalBytes;
                        currentDownloadBytes -= activity.currentBytes;
                        break;
                    default:
                        break;
                }
                if (activity.message)
                    break;
            }
            [activity retain];
            [endingActivities removeObjectsInRange:NSMakeRange(0, (index + 1))];
            pickedRunning = NO;
        } else if (runningActivitiesCount) {
            NSUInteger count;
            for (count = 0 ; count < runningActivitiesCount; count++) {
                activity = [[runningActivities objectAtIndex:0] retain];
                [runningActivities removeObjectAtIndex:0];
                [runningActivities addObject:activity];
                if (activity.message) {
                    break;
                } else {
                    [activity release];
                    activity = nil;
                }
            }
            pickedRunning = YES;
        }
        if (activity && activity.message) {
            if (activity.pithosAccount)
                [info setObject:[NSString stringWithFormat:@"[%@] %@", activity.pithosAccount.name, activity.message] forKey:@"message"];
            else
                [info setObject:activity.message forKey:@"message"];
        }
        [info setObject:[NSNumber numberWithUnsignedInteger:[runningActivities count]] forKey:@"runningActivitiesCount"];
        [info setObject:[NSNumber numberWithUnsignedInteger:[endingActivities count]] forKey:@"endingActivitiesCount"];
        [info setObject:[NSNumber numberWithUnsignedInteger:totalUploadBytes] forKey:@"totalUploadBytes"];
        [info setObject:[NSNumber numberWithUnsignedInteger:currentUploadBytes] forKey:@"currentUploadBytes"];
        [info setObject:[NSNumber numberWithUnsignedInteger:totalDownloadBytes] forKey:@"totalDownloadBytes"];
        [info setObject:[NSNumber numberWithUnsignedInteger:currentDownloadBytes] forKey:@"currentDownloadBytes"];
        [activity release];
    }
    if (delegate) {
        [delegate activityUpdate:info];
    }
}

#pragma mark -
#pragma mark Activity Actions

- (PithosActivity *)startActivityWithType:(PithosActivityType)type 
                                  message:(NSString *)message 
                               totalBytes:(NSUInteger)totalBytes 
                             currentBytes:(NSUInteger)currentBytes 
                            pithosAccount:(PithosAccount *)pithosAccount {
    PithosActivity *activity = [[[PithosActivity alloc] initWithType:type pithosAccount:pithosAccount] autorelease];
    activity.message = message;
    activity.totalBytes = totalBytes;
    activity.currentBytes = currentBytes;
    NSLog(@"PithosActivityFacility startedActivity %@", activity);
    
    switch (type) {
        case PithosActivityUpload:
            @synchronized(self) {
                totalUploadBytes += totalBytes;
                currentUploadBytes += currentBytes;
            }
            break;
        case PithosActivityDownload:
            @synchronized(self) {
                totalDownloadBytes += totalBytes;
                currentDownloadBytes += currentBytes;
            }
            break;
        default:
            break;
    }
    
    @synchronized(self) {
        [runningActivities addObject:activity];
    }
    NSLog(@"PithosActivityFacility %@", self);
    
    return activity;
}

- (PithosActivity *)startActivityWithType:(PithosActivityType)type 
                                  message:(NSString *)message 
                               totalBytes:(NSUInteger)totalBytes 
                             currentBytes:(NSUInteger)currentBytes {
    return [self startActivityWithType:type message:message totalBytes:totalBytes currentBytes:currentBytes pithosAccount:nil];
}

- (PithosActivity *)startActivityWithType:(PithosActivityType)type 
                                  message:(NSString *)message 
                            pithosAccount:(PithosAccount *)pithosAccount {
    return [self startActivityWithType:type message:message totalBytes:0 currentBytes:0 pithosAccount:pithosAccount];
}

- (PithosActivity *)startActivityWithType:(PithosActivityType)type 
                                  message:(NSString *)message {
    return [self startActivityWithType:type message:message pithosAccount:nil];
}

- (PithosActivity *)startAndEndActivityWithType:(PithosActivityType)type 
                                        message:(NSString *)message 
                                  pithosAccount:(PithosAccount *)pithosAccount {
    PithosActivity *activity = [[[PithosActivity alloc] initWithType:type pithosAccount:pithosAccount] autorelease];
    activity.message = message;
    activity.totalBytes = 0;
    activity.currentBytes = 0;
    @synchronized(self) {
        [endingActivities addObject:activity];
    }
    NSLog(@"PithosActivityFacility startedAndEndedActivity %@", activity);
    
    return activity;
}

- (PithosActivity *)startAndEndActivityWithType:(PithosActivityType)type message:(NSString *)message {
    return [self startAndEndActivityWithType:type message:message pithosAccount:nil];
}

- (void)updateActivity:(PithosActivity *)activity 
           withMessage:(NSString *)message 
            totalBytes:(NSUInteger)totalBytes 
          currentBytes:(NSUInteger)currentBytes {
    if (!activity)
        return;
    NSLog(@"PithosActivityFacility updatedActivity %@", activity);
    @synchronized(self) {
        activity.message = message;
        switch (activity.type) {
            case PithosActivityUpload:
                totalUploadBytes += totalBytes - activity.totalBytes;
                activity.totalBytes = totalBytes;
                currentUploadBytes += currentBytes - activity.currentBytes;
                activity.currentBytes = currentBytes;
                break;
            case PithosActivityDownload:
                totalDownloadBytes += totalBytes - activity.totalBytes;
                activity.totalBytes = totalBytes;
                currentDownloadBytes += currentBytes - activity.currentBytes;
                activity.currentBytes = currentBytes;
                break;
            default:
                break;
        }
    }
    NSLog(@"PithosActivityFacility %@", self);
}

- (void)updateActivity:(PithosActivity *)activity 
           withMessage:(NSString *)message {
    [self updateActivity:activity withMessage:message totalBytes:activity.totalBytes currentBytes:activity.currentBytes];
}

- (void)endActivity:(PithosActivity *)activity 
        withMessage:(NSString *)message 
         totalBytes:(NSUInteger)totalBytes 
       currentBytes:(NSUInteger)currentBytes {
    if (!activity)
        return;
    @synchronized(self) {
        [runningActivities removeObject:activity];
        activity.message = message;
        switch (activity.type) {
            case PithosActivityUpload:
                totalUploadBytes += totalBytes - activity.totalBytes;
                activity.totalBytes = totalBytes;
                currentUploadBytes += currentBytes - activity.currentBytes;
                activity.currentBytes = currentBytes;
                break;
            case PithosActivityDownload:
                totalDownloadBytes += totalBytes - activity.totalBytes;
                activity.totalBytes = totalBytes;
                currentDownloadBytes += currentBytes - activity.currentBytes;
                activity.currentBytes = currentBytes;
                break;
            default:
                break;
        }
        [endingActivities addObject:activity];
    }
    NSLog(@"PithosActivityFacility endedActivity %@", activity);
    NSLog(@"PithosActivityFacility %@", self);
}

- (void)endActivity:(PithosActivity *)activity 
        withMessage:(NSString *)message {
    [self endActivity:activity withMessage:message totalBytes:activity.totalBytes currentBytes:activity.currentBytes];
}

@end