#import "HTTPDynamicFileResponse.h"
#import "HTTPConnection.h"
#import "HTTPLogging.h"

#if ! __has_feature(objc_arc)
#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
#endif

// Log levels : off, error, warn, info, verbose
// Other flags: trace
static const DDLogLevel httpLogLevel = DDLogLevelWarning; // | HTTP_LOG_FLAG_TRACE;

#define NULL_FD  -1


@implementation HTTPDynamicFileResponse

- (id)initWithFilePath:(NSString *)fpath
         forConnection:(HTTPConnection *)parent
             separator:(NSString *)separatorStr
 replacementDictionary:(NSDictionary *)dict
{
    if ((self = [super initWithFilePath:fpath forConnection:parent]))
    {
        HTTPLogTrace();
        
        separator = [separatorStr dataUsingEncoding:NSUTF8StringEncoding];
        replacementDict = dict;
    }
    return self;
}

- (BOOL)isChunked
{
    HTTPLogTrace();
    
    return YES;
}

- (UInt64)contentLength
{
    // This method shouldn't be called since we're using a chunked response.
    // We override it just to be safe.
    
    HTTPLogTrace();
    
    return 0;
}

- (void)setOffset:(UInt64)offset
{
    // This method shouldn't be called since we're using a chunked response.
    // We override it just to be safe.
    
    HTTPLogTrace();
}

- (BOOL)isDone
{
    BOOL result = (readOffset == fileLength) && (readBufferOffset == 0);
    
    HTTPLogTrace2(@"%@[%p]: isDone - %@", THIS_FILE, self, (result ? @"YES" : @"NO"));
    
    return result;
}

- (void)processReadBuffer
{
    HTTPLogTrace();
    
    // At this point, the readBuffer has readBufferOffset bytes available.
    // This method is in charge of updating the readBufferOffset.
    
    NSUInteger bufLen = readBufferOffset;
    NSUInteger sepLen = [separator length];
    
    // We're going to start looking for the separator at the beginning of the buffer,
    // and stop when we get to the point where the separator would no longer fit in the buffer.
    
    NSUInteger offset = 0;
    NSUInteger stopOffset = (bufLen > sepLen) ? bufLen - sepLen + 1 : 0;
    
    // In order to do the replacement, we need to find the starting and ending separator.
    // For example:
    // 
    // %%USER_NAME%%
    // 
    // Where "%%" is the separator.
    
    BOOL found1 = NO;
    BOOL found2 = NO;
    
    NSUInteger s1 = 0;
    NSUInteger s2 = 0;
    
    const void *sep = [separator bytes];
    
    while (offset < stopOffset)
    {
        const void *subBuffer = readBuffer + offset;
        
        if (memcmp(subBuffer, sep, sepLen) == 0)
        {
            if (!found1)
            {
                // Found the first separator
                
                found1 = YES;
                s1 = offset;
                offset += sepLen;
                
                HTTPLogVerbose(@"%@[%p]: Found s1 at %lu", THIS_FILE, self, (unsigned long)s1);
            }
            else
            {
                // Found the second separator
                
                found2 = YES;
                s2 = offset;
                offset += sepLen;
                
                HTTPLogVerbose(@"%@[%p]: Found s2 at %lu", THIS_FILE, self, (unsigned long)s2);
            }
            
            if (found1 && found2)
            {
                // We found our separators.
                // Now extract the string between the two separators.
                
                NSRange fullRange = NSMakeRange(s1, (s2 - s1 + sepLen));
                NSRange strRange = NSMakeRange(s1 + sepLen, (s2 - s1 - sepLen));
                
                // Wish we could use the simple subdataWithRange method.
                // But that method copies the bytes...
                // So for performance reasons, we need to use the methods that don't copy the bytes.
                
                void *strBuf = readBuffer + strRange.location;
                NSUInteger strLen = strRange.length;
                
                NSString *key = [[NSString alloc] initWithBytes:strBuf length:strLen encoding:NSUTF8StringEncoding];
                if (key)
                {
                    // Is there a given replacement for this key?
                    
                    id value = [replacementDict objectForKey:key];
                    if (value)
                    {
                        // Found the replacement value.
                        // Now perform the replacement in the buffer.
                        
                        HTTPLogVerbose(@"%@[%p]: key(%@) -> value(%@)", THIS_FILE, self, key, value);
                        
                        NSData *v = [[value description] dataUsingEncoding:NSUTF8StringEncoding];
                        NSUInteger vLength = [v length];
                        
                        if (fullRange.length == vLength)
                        {
                            // Replacement is exactly the same size as what it is replacing
                            
                            // memcpy(void *restrict dst, const void *restrict src, size_t n);
                            
                            memcpy(readBuffer + fullRange.location, [v bytes], vLength);
                        }
                        else // (fullRange.length != vLength)
                        {
                            NSInteger diff = (NSInteger)vLength - (NSInteger)fullRange.length;
                            
                            if (diff > 0)
                            {
                                // Replacement is bigger than what it is replacing.
                                // Make sure there is room in the buffer for the replacement.
                                
                                if (diff > (readBufferSize - bufLen))
                                {
                                    NSUInteger inc = MAX(diff, 256);
                                    
                                    readBufferSize += inc;
                                    readBuffer = reallocf(readBuffer, readBufferSize);
                                }
                            }
                            
                            // Move the data that comes after the replacement.
                            // 
                            // If replacement is smaller than what it is replacing,
                            // then we are shifting the data toward the beginning of the buffer.
                            // 
                            // If replacement is bigger than what it is replacing,
                            // then we are shifting the data toward the end of the buffer.
                            // 
                            // memmove(void *dst, const void *src, size_t n);
                            // 
                            // The memmove() function copies n bytes from src to dst.
                            // The two areas may overlap; the copy is always done in a non-destructive manner.
                            
                            void *src = readBuffer + fullRange.location + fullRange.length;
                            void *dst = readBuffer + fullRange.location + vLength;
                            
                            NSUInteger remaining = bufLen - (fullRange.location + fullRange.length);
                            
                            memmove(dst, src, remaining);
                            
                            // Now copy the replacement into its location.
                            // 
                            // memcpy(void *restrict dst, const void *restrict src, size_t n)
                            // 
                            // The memcpy() function copies n bytes from src to dst.
                            // If the two areas overlap, behavior is undefined.
                            
                            memcpy(readBuffer + fullRange.location, [v bytes], vLength);
                            
                            // And don't forget to update our indices.
                            
                            bufLen     += diff;
                            offset     += diff;
                            stopOffset += diff;
                        }
                    }
                    
                }
                
                found1 = found2 = NO;
            }
        }
        else
        {
            offset++;
        }
    }
    
    // We've gone through our buffer now, and performed all the replacements that we could.
    // It's now time to update the amount of available data we have.
    
    if (readOffset == fileLength)
    {
        // We've read in the entire file.
        // So there can be no more replacements.
        
        data = [[NSData alloc] initWithBytes:readBuffer length:bufLen];
        readBufferOffset = 0;
    }
    else
    {
        // There are a couple different situations that we need to take into account here.
        // 
        // Imagine the following file:
        // My name is %%USER_NAME%%
        // 
        // Situation 1:
        // The first chunk of data we read was "My name is %%".
        // So we found the first separator, but not the second.
        // In this case we can only return the data that precedes the first separator.
        // 
        // Situation 2:
        // The first chunk of data we read was "My name is %".
        // So we didn't find any separators, but part of a separator may be included in our buffer.
        
        NSUInteger available;
        if (found1)
        {
            // Situation 1
            available = s1;
        }
        else
        {
            // Situation 2
            available = stopOffset;
        }
        
        // Copy available data
        
        data = [[NSData alloc] initWithBytes:readBuffer length:available];
        
        // Remove the copied data from the buffer.
        // We do this by shifting the remaining data toward the beginning of the buffer.
        
        NSUInteger remaining = bufLen - available;
        
        memmove(readBuffer, readBuffer + available, remaining);
        readBufferOffset = remaining;
    }
    
    [connection responseHasAvailableData:self];
}

- (void)dealloc
{
    HTTPLogTrace();
    
    
}

@end