//
//  BCSequence.m
//  BioCocoa
//
//  Created by Koen van der Drift on Sun Aug 15 2004.
//  Copyright (c) 2004 The BioCocoa Project. All rights reserved.
//

#import "BCSequence.h"
#import "BCMassCalculator.h"

@implementation BCSequence

////////////////////////////////////////////////////////////////////////////
#pragma mark â 
#pragma mark âINITIALIZATION METHODS
//
//  INFORMATIONAL METHODS
////////////////////////////////////////////////////////////////////////////

- (id)init
{    
    if ( self = [super init] ) {
        sequenceArray = nil;
        sequenceCountedSet = nil;
        sequenceType = BCOtherSequence;
    }
    
    return self;
}

- (id)initWithString:(NSString*)aString
{
    return nil;
}


- (id)initWithString:(NSString*)aString withRange:(NSRange)aRange {
    
    return nil;
}



- (id)initWithArray:(NSArray *)anArray {
    
    if (self = [super init])
    {
        sequenceArray = [[NSMutableArray alloc] init];
        
        NSEnumerator *theEnumerator = [anArray objectEnumerator];
        id aSymbol;
        while ( aSymbol = [theEnumerator nextObject] )
            if ( [aSymbol isKindOfClass: [BCSymbol class]] )
                [sequenceArray addObject: aSymbol];
        
        sequenceType = BCOtherSequence;
        sequenceCountedSet = [[NSCountedSet alloc] init];
    }
    
    return self;
    
}


- (id)copyWithZone:(NSZone *)zone{
	
    BCSequence *copy = [[[self class] allocWithZone: zone] init];

    [copy setSequenceType : [self sequenceType ]];
    [copy setSequenceArray: [self sequenceArray]];
    [copy setSequenceCountedSet: [self sequenceCountedSet]];
    [copy setRange: [self range]];
    [copy setStartPosition: [self startPosition]];
    [copy setEndPosition: [self endPosition]];
	
    return copy;
}


- (void)dealloc
{
    [sequenceArray release];
    [sequenceCountedSet release];
    
    [super dealloc];
}




////////////////////////////////////////////////////////////////////////////
#pragma mark â 
#pragma mark âOBTAINING SEQUENCE INFORMATION
//
//  INFORMATIONAL METHODS
////////////////////////////////////////////////////////////////////////////

- (BCSequenceType) sequenceType {
    return sequenceType;
}

- (void) setSequenceType:(BCSequenceType)aType
{
	sequenceType = aType;
}

- (unsigned int) length {
    return [sequenceArray count];
}


- (id)symbolAtIndex: (int)theIndex {
    if ( theIndex >= [sequenceArray count] )
        return nil;
    return [sequenceArray objectAtIndex: theIndex];
}


- (NSString*)sequenceString
{
    return [self subSequenceStringInRange: NSMakeRange( 0, [sequenceArray count] ) ];
}


- (NSArray *)sequenceArray
{
    return [[sequenceArray copy] autorelease];
}


- (void) setSequenceArray: (NSArray *) anArray
{
	[anArray retain];
	[sequenceArray release];
	sequenceArray = (NSMutableArray *)anArray;
}


- (NSString *)subSequenceStringInRange:(NSRange)aRange {
    if ( aRange.location + aRange.length > [sequenceArray count] )
        return nil;
    
    NSMutableString *theReturn = [NSMutableString stringWithString: @""];
    NSEnumerator *theEnumerator = [[sequenceArray subarrayWithRange: aRange] objectEnumerator];
    id aSymbol;
    NSString *aSymbolString;
    while ( aSymbol = [theEnumerator nextObject] ) {
        aSymbolString = [aSymbol symbolString];
        if ( aSymbolString != nil )
            [theReturn appendString: aSymbolString];
    }
    return [[theReturn copy] autorelease];
}


- (NSArray *)subSequenceArrayInRange:(NSRange)aRange
{
    if ( aRange.location + aRange.length > [sequenceArray count] )
        return nil;

    return [sequenceArray subarrayWithRange: aRange];
}


- (BCSequence *)subSequenceInRange:(NSRange)aRange {
    if ( aRange.location + aRange.length > [sequenceArray count] )
        return nil;
    
    return [[[BCSequence alloc] initWithArray: [sequenceArray subarrayWithRange: aRange]] autorelease];
}


- (float) molecularWeight :(BCMassType)type{
	
	BCMassCalculator *calculator = [[BCMassCalculator alloc] initWithSequence: self];
	
	[calculator setMassType: BCAverage];
	float totalMass = [calculator calculateMass];
	
	[calculator release];
	
	return totalMass;
}


- (NSString *) savableRepresentation {
    return [self sequenceString];
}


- (NSString *) description  {
    return [self sequenceString];
}



////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
#pragma mark â 
#pragma mark âMANIPULATING SEQUENCE CONTENTS
//
//  INFORMATIONAL METHODS
////////////////////////////////////////////////////////////////////////////


- (void)removeSymbolsInRange:(NSRange)aRange
{
    if ( aRange.location + aRange.length > [sequenceArray count] )
        return;
    [sequenceArray removeObjectsInRange: aRange];
}

- (void)removeSymbolAtIndex:(int)index
{
    if ( index > [sequenceArray count] - 1 )
        return;
    [sequenceArray removeObjectAtIndex:index];
}


- (void)insertSymbolsFromSequence:(BCSequence *)entry atIndex:(int)index
{
    if ( index > [sequenceArray count] - 1 )
        return;
    [sequenceArray replaceObjectsInRange:NSMakeRange(index,0) 
               withObjectsFromArray:[entry sequenceArray]];
}




- (void)setSequence:(NSMutableArray *)anArray
{
    [sequenceArray release];
    
    sequenceArray = [[NSMutableArray alloc] init];
    
    NSEnumerator *theEnumerator = [sequenceArray objectEnumerator];
    id aSymbol;
    while ( aSymbol = [theEnumerator nextObject] ) {
        if ( [aSymbol isKindOfClass: [BCSymbol class]] )
            [sequenceArray addObject: aSymbol];
    }
}


////////////////////////////////////////////////////////////////////////////
#pragma mark â 
#pragma mark âGETTING/SETTING INTERNAL VARIABLES
//
//  INFORMATIONAL METHODS
////////////////////////////////////////////////////////////////////////////


- (void)countSymbols
{
    BCSymbol			*aSymbol;
    NSEnumerator		*enumerator = [sequenceArray objectEnumerator];
    
    [sequenceCountedSet removeAllObjects];
    
    while (aSymbol = [enumerator nextObject])
    {
        [sequenceCountedSet addObject: [aSymbol symbolString]];
    }
}


- (NSCountedSet *)sequenceCountedSet
{
    return sequenceCountedSet;
}

- (void) setSequenceCountedSet: (NSCountedSet *)aSet
{
	[aSet retain];
	[sequenceCountedSet release];
	sequenceCountedSet = aSet;
}

- (int)startPosition
{
    return startPosition;
}

- (void)setStartPosition:(int)i
{
    startPosition = i;
}

- (int)endPosition
{
    return endPosition;
}

- (void)setEndPosition:(int)i
{
    endPosition = i;
}

- (NSRange)range
{
    return range;
}

- (void)setRange:(NSRange)aRange
{
    range = aRange;
    [self setStartPosition:(aRange.location + 1)];
    [self setEndPosition:(aRange.location + aRange.length - 1)];
}


@end