//
//  TCPClient.m
//  ETAMobile
//
//  Created by Daniel Reed on 11/9/10.
//  Copyright 2010 N/a. All rights reserved.
//
#import "TCPClient.h"

@interface TCPClient ()
-(void) readStream: (CFReadStreamRef) stream postedEvent: (CFStreamEventType) eventType;
-(void) writeStream: (CFWriteStreamRef) stream postedEvent: (CFStreamEventType) eventType;
@end

@implementation TCPClient
static void RSCallback(CFReadStreamRef stream, CFStreamEventType eventType, void* info)
{
    TCPClient* client = (TCPClient*) info;

    [client readStream: stream postedEvent: eventType];
}

static void WSCallback(CFWriteStreamRef stream, CFStreamEventType eventType, void* info)
{
    TCPClient* client = (TCPClient*) info;

    [client writeStream: stream postedEvent: eventType];
}

#pragma mark Synthesize directives
@synthesize delegate;

#pragma mark -
#pragma mark Initializers
-(id) initWithDelegate: (id <TCPClientDelegate>) theDelegate
{
    if (self = [super init])
    {
        [self setDelegate: theDelegate];
    }

    return self;
}
#pragma mark -
#pragma mark Memory management
-(void) dealloc
{
    // Invoke the inherited dealloc method.
    [super dealloc];
}

#pragma mark -
#pragma mark Public methods
-(void) connect: (NSString*) host port: (int) port
{
    CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, (CFStringRef) host, port, &readStream, &writeStream);

    // Setup the client context:
    ctx.version = 0;
    ctx.info = self;
    ctx.retain = NULL;
    ctx.release = NULL;
    ctx.copyDescription = NULL;

    // Determine option flags:
    CFOptionFlags flags = kCFStreamEventNone |
                          kCFStreamEventOpenCompleted |
                          kCFStreamEventHasBytesAvailable |
                          kCFStreamEventCanAcceptBytes |
                          kCFStreamEventErrorOccurred |
                          kCFStreamEventEndEncountered;

    // Assign stream clients:
    CFReadStreamSetClient(readStream,   flags, RSCallback, &ctx);
    CFWriteStreamSetClient(writeStream, flags, WSCallback, &ctx);

#if TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MAX_ALLOWED >= 40000
    // Indicate that streams should close the underlying socket when closed:
    CFReadStreamSetProperty(readStream,   kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
    CFWriteStreamSetProperty(writeStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);

    // Allow the connection to exist in the background on IOS4 devices:
    CFReadStreamSetProperty(readStream,   kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP);
    CFWriteStreamSetProperty(writeStream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP);
#endif

    // Schedule the streams in the main run loop:
    CFReadStreamScheduleWithRunLoop(readStream,   CFRunLoopGetMain(), kCFRunLoopDefaultMode);
    CFWriteStreamScheduleWithRunLoop(writeStream, CFRunLoopGetMain(), kCFRunLoopDefaultMode);

    // Open the stream pair:
    CFReadStreamOpen(readStream);
    CFWriteStreamOpen(writeStream);
}

-(void) close
{
    // Close the streams:
    CFReadStreamClose(readStream);
    CFWriteStreamClose(writeStream);

    // Release the retained streams:
    CFRelease(readStream);
    CFRelease(writeStream);

    // Set retained objects to NULL:
    readStream = NULL;
    writeStream = NULL;
}

-(int) read: (UInt8*) buffer offset: (int) offset count: (int) count
{
    if (!readStream)
    {
        return -1;
    }

    return CFReadStreamRead(readStream, &buffer[offset], count);
}

-(int) write: (UInt8*) buffer offset: (int) offset count: (int) count
{
    if (!writeStream)
    {
        return -1;
    }

    return CFWriteStreamWrite(writeStream, &buffer[offset], count);
}

#pragma mark -
#pragma mark Private methods
-(void) readStream: (CFReadStreamRef) stream postedEvent: (CFStreamEventType) eventType
{
    switch (eventType)
    {
        case kCFStreamEventNone:
            break;

        case kCFStreamEventOpenCompleted:
            [delegate clientDidConnect: self];
            break;

        case kCFStreamEventHasBytesAvailable:
            [delegate clientHasBytesAvailable: self];
            break;

        case kCFStreamEventCanAcceptBytes:
            break;

        case kCFStreamEventErrorOccurred:
            break;

        case kCFStreamEventEndEncountered:
            break;
    }
}

-(void) writeStream: (CFWriteStreamRef) stream postedEvent: (CFStreamEventType) eventType
{
    switch (eventType)
    {
        case kCFStreamEventNone:
            break;

        case kCFStreamEventOpenCompleted:
            break;

        case kCFStreamEventHasBytesAvailable:
            break;

        case kCFStreamEventCanAcceptBytes:
            break;

        case kCFStreamEventErrorOccurred:
            break;

        case kCFStreamEventEndEncountered:
            break;
    }
}
@end