//
//  HFSharedMemoryByteSlice.m
//  HexFiend_2
//
//  Copyright 2008 ridiculous_fish. All rights reserved.
//

#import <HexFiend/HFByteSlice_Private.h>
#import <HexFiend/HFSharedMemoryByteSlice.h>

#define MAX_FAST_PATH_SIZE (1 << 13)

#define MAX_TAIL_LENGTH (sizeof ((HFSharedMemoryByteSlice *)NULL)->inlineTail / sizeof *((HFSharedMemoryByteSlice *)NULL)->inlineTail)

@implementation HFSharedMemoryByteSlice

- (instancetype)initWithUnsharedData:(NSData *)unsharedData {
    self = [super init];
    REQUIRE_NOT_NULL(unsharedData);
    NSUInteger dataLength = [unsharedData length];
    NSUInteger inlineAmount = MIN(dataLength, MAX_TAIL_LENGTH);
    NSUInteger sharedAmount = dataLength - inlineAmount;
    HFASSERT(inlineAmount <= UCHAR_MAX);
    inlineTailLength = (unsigned char)inlineAmount;
    length = sharedAmount;
    if (inlineAmount > 0) {
        [unsharedData getBytes:inlineTail range:NSMakeRange(dataLength - inlineAmount, inlineAmount)];
    }
    if (sharedAmount > 0) {
        data = [[NSMutableData alloc] initWithBytes:[unsharedData bytes] length:sharedAmount];
    }
    return self;
}

// retains, does not copy
- (instancetype)initWithData:(NSMutableData *)dat {
    REQUIRE_NOT_NULL(dat);
    return [self initWithData:dat offset:0 length:[dat length]];
}

- (instancetype)initWithData:(NSMutableData *)dat offset:(NSUInteger)off length:(NSUInteger)len {
    self = [super init];
    REQUIRE_NOT_NULL(dat);
    HFASSERT(off + len >= off); //check for overflow
    HFASSERT(off + len <= [dat length]);
    offset = off;
    length = len;
    data = [dat retain];
    return self;
}

- (instancetype)initWithSharedData:(NSMutableData *)dat offset:(NSUInteger)off length:(NSUInteger)len tail:(const void *)tail tailLength:(NSUInteger)tailLen {
    self = [super init];
    if (off || len) REQUIRE_NOT_NULL(dat);
    if (tailLen) REQUIRE_NOT_NULL(tail);
    HFASSERT(tailLen <= MAX_TAIL_LENGTH);
    HFASSERT(off + len >= off);
    HFASSERT(off + len <= [dat length]);
    offset = off;
    length = len;
    data = [dat retain];
    HFASSERT(tailLen <= UCHAR_MAX);
    inlineTailLength = (unsigned char)tailLen;
    memcpy(inlineTail, tail, tailLen);
    HFASSERT([self length] == tailLen + len);
    return self;
}

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

- (unsigned long long)length {
    return length + inlineTailLength;
}

- (void)copyBytes:(unsigned char *)dst range:(HFRange)lrange {
    HFASSERT(HFSum(length, inlineTailLength) >= HFMaxRange(lrange));
    NSRange requestedRange = NSMakeRange(ll2l(lrange.location), ll2l(lrange.length));
    NSRange dataRange = NSMakeRange(0, length);
    NSRange tailRange = NSMakeRange(length, inlineTailLength);
    NSRange dataRangeToCopy = NSIntersectionRange(requestedRange, dataRange);
    NSRange tailRangeToCopy = NSIntersectionRange(requestedRange, tailRange);
    HFASSERT(HFSum(dataRangeToCopy.length, tailRangeToCopy.length) == lrange.length);
    
    if (dataRangeToCopy.length > 0) {
        HFASSERT(HFSum(NSMaxRange(dataRangeToCopy), offset) <= [data length]);
        const void *bytes = [data bytes];
        memcpy(dst, bytes + dataRangeToCopy.location + offset, dataRangeToCopy.length);
    }
    if (tailRangeToCopy.length > 0) {
        HFASSERT(tailRangeToCopy.location >= length);
        HFASSERT(NSMaxRange(tailRangeToCopy) - length <= inlineTailLength);
        memcpy(dst + dataRangeToCopy.length, inlineTail + tailRangeToCopy.location - length, tailRangeToCopy.length);
    }
}

- (HFByteSlice *)subsliceWithRange:(HFRange)lrange {
    if (HFRangeEqualsRange(lrange, HFRangeMake(0, HFSum(length, inlineTailLength)))) return [[self retain] autorelease];
    
    HFByteSlice *result;
    HFASSERT(lrange.length > 0);
    HFASSERT(HFSum(length, inlineTailLength) >= HFMaxRange(lrange));
    NSRange requestedRange = NSMakeRange(ll2l(lrange.location), ll2l(lrange.length));
    NSRange dataRange = NSMakeRange(0, length);
    NSRange tailRange = NSMakeRange(length, inlineTailLength);
    NSRange dataRangeToCopy = NSIntersectionRange(requestedRange, dataRange);
    NSRange tailRangeToCopy = NSIntersectionRange(requestedRange, tailRange);
    HFASSERT(HFSum(dataRangeToCopy.length, tailRangeToCopy.length) == lrange.length);
    
    NSMutableData *resultData = NULL;
    NSUInteger resultOffset = 0;
    NSUInteger resultLength = 0;
    const unsigned char *tail = NULL;
    NSUInteger tailLength = 0;
    if (dataRangeToCopy.length > 0) {
        resultData = data;
        HFASSERT(resultData != NULL);
        resultOffset = offset + dataRangeToCopy.location;
        resultLength = dataRangeToCopy.length;
        HFASSERT(HFSum(resultOffset, resultLength) <= [data length]);
    }
    if (tailRangeToCopy.length > 0) {
        tail = inlineTail + tailRangeToCopy.location - length;
        tailLength = tailRangeToCopy.length;
        HFASSERT(tail >= inlineTail && tail + tailLength <= inlineTail + inlineTailLength);
    }
    HFASSERT(resultLength + tailLength == lrange.length);
    result = [[[[self class] alloc] initWithSharedData:resultData offset:resultOffset length:resultLength tail:tail tailLength:tailLength] autorelease];
    HFASSERT([result length] == lrange.length);
    return result;
}

- (HFByteSlice *)byteSliceByAppendingSlice:(HFByteSlice *)slice {
    REQUIRE_NOT_NULL(slice);
    const unsigned long long sliceLength = [slice length];
    if (sliceLength == 0) return self;
    
    const unsigned long long thisLength = [self length];
    
    HFASSERT(inlineTailLength <= MAX_TAIL_LENGTH);
    NSUInteger spaceRemainingInTail = MAX_TAIL_LENGTH - inlineTailLength;
    
    if (sliceLength <= spaceRemainingInTail) {
        /* We can do our work entirely within the tail */
        NSUInteger newTailLength = (NSUInteger)sliceLength + inlineTailLength;
        unsigned char newTail[MAX_TAIL_LENGTH];
        memcpy(newTail, inlineTail, inlineTailLength);
        [slice copyBytes:newTail + inlineTailLength range:HFRangeMake(0, sliceLength)];
        HFByteSlice *result = [[[[self class] alloc] initWithSharedData:data offset:offset length:length tail:newTail tailLength:newTailLength] autorelease];
        HFASSERT([result length] == HFSum(sliceLength, thisLength));
        return result;
    }
    else {
        /* We can't do our work entirely in the tail; see if we can append some shared data. */
        HFASSERT(offset + length >= offset);
        if (offset + length == [data length]) {
            /* We can append some shared data.  But impose some reasonable limit on how big our slice can get; this is 16 MB */
            if (HFSum(thisLength, sliceLength) < (1ULL << 24)) {
                NSUInteger newDataOffset = offset;
                NSUInteger newDataLength = length;
                unsigned char newDataTail[MAX_TAIL_LENGTH];
                unsigned char newDataTailLength = MAX_TAIL_LENGTH;
                NSMutableData *newData = (data ? data : [[[NSMutableData alloc] init] autorelease]);
                
                NSUInteger sliceLengthInt = ll2l(sliceLength);
                NSUInteger newTotalTailLength = sliceLengthInt + inlineTailLength;
                HFASSERT(newTotalTailLength >= MAX_TAIL_LENGTH);
                NSUInteger amountToShiftIntoSharedData = newTotalTailLength - MAX_TAIL_LENGTH;
                NSUInteger amountToShiftIntoSharedDataFromTail = MIN(amountToShiftIntoSharedData, inlineTailLength);
                NSUInteger amountToShiftIntoSharedDataFromNewSlice = amountToShiftIntoSharedData - amountToShiftIntoSharedDataFromTail;
                
                if (amountToShiftIntoSharedDataFromTail > 0) {
                    HFASSERT(amountToShiftIntoSharedDataFromTail <= inlineTailLength);
                    [newData appendBytes:inlineTail length:amountToShiftIntoSharedDataFromTail];
                    newDataLength += amountToShiftIntoSharedDataFromTail;
                }
                if (amountToShiftIntoSharedDataFromNewSlice > 0) {
                    HFASSERT(amountToShiftIntoSharedDataFromNewSlice <= [slice length]);
                    NSUInteger dataLength = offset + length + amountToShiftIntoSharedDataFromTail;
                    HFASSERT([newData length] == dataLength);
                    [newData setLength:dataLength + amountToShiftIntoSharedDataFromNewSlice];
                    [slice copyBytes:[newData mutableBytes] + dataLength range:HFRangeMake(0, amountToShiftIntoSharedDataFromNewSlice)];
                    newDataLength += amountToShiftIntoSharedDataFromNewSlice;
                }
                
                /* We've updated our data; now figure out the tail */
                NSUInteger amountOfTailFromNewSlice = sliceLengthInt - amountToShiftIntoSharedDataFromNewSlice;
                HFASSERT(amountOfTailFromNewSlice <= MAX_TAIL_LENGTH);
                [slice copyBytes:newDataTail + MAX_TAIL_LENGTH - amountOfTailFromNewSlice range:HFRangeMake(sliceLengthInt - amountOfTailFromNewSlice, amountOfTailFromNewSlice)];
                
                /* Copy the rest, if any, from the end of self */
                NSUInteger amountOfTailFromSelf = MAX_TAIL_LENGTH - amountOfTailFromNewSlice;
                HFASSERT(amountOfTailFromSelf <= inlineTailLength);
                if (amountOfTailFromSelf > 0) {
                    memcpy(newDataTail, inlineTail + inlineTailLength - amountOfTailFromSelf, amountOfTailFromSelf);
                }
                
                HFByteSlice *result = [[[[self class] alloc] initWithSharedData:newData offset:newDataOffset length:newDataLength tail:newDataTail tailLength:newDataTailLength] autorelease];
                HFASSERT([result length] == HFSum([slice length], [self length]));
                return result;
            }
        }
    }
    return nil;
}

@end