//
//  MHProxy.m
//  MineHelmet
//
//  Created by Dylan Lukes on 10/24/10.
//  Copyright 2010 Dylan Lukes. All rights reserved.
//

#import "MHProxy.h"

#define MAX_READ_SIZE 512

@interface MHProxy (PrivateMethods)

- (void)handleClientInputEvent:(NSStreamEvent)event;
- (void)handleClientOutputEvent:(NSStreamEvent)event;
- (void)handleServerInputEvent:(NSStreamEvent)event;
- (void)handleServerOutputEvent:(NSStreamEvent)event;

@end


@implementation MHProxy

- (id)initWithClientDescriptor:(int)clientfd serverDescriptor:(int)serverfd {
    if (self = [super init]) {
        clientWriteQueue = [[NSMutableArray alloc] init];
        serverWriteQueue = [[NSMutableArray alloc] init];

        CFStreamCreatePairWithSocket(NULL,
                                     clientfd,
                                     (CFReadStreamRef *)&fromClient,
                                     (CFWriteStreamRef *)&toClient);
        CFStreamCreatePairWithSocket(NULL,
                                     serverfd,
                                     (CFReadStreamRef *)&fromServer,
                                     (CFWriteStreamRef *)&toServer);

        [fromClient retain];
        [toClient   retain];
        [fromServer retain];
        [toServer   retain];

        [fromClient setDelegate:self];
        [toClient   setDelegate:self];
        [fromServer setDelegate:self];
        [toServer   setDelegate:self];

        [fromClient scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
        [toClient   scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
        [fromServer scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
        [toServer   scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];

        [fromClient open];
        [toClient   open];
        [fromServer open];
        [toServer   open];
    }
    return self;
}

- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)streamEvent {
    // Check for errors:
    if (streamEvent == NSStreamEventErrorOccurred) {
        [NSApp presentError:[stream streamError]];
    }

    // Dispatch events
    if (stream == fromClient && streamEvent == NSStreamEventHasBytesAvailable)
        [self handleClientInputEvent:streamEvent];
    if (stream == toClient   && streamEvent == NSStreamEventHasSpaceAvailable)
        [self handleClientOutputEvent:streamEvent];
    if (stream == fromServer && streamEvent == NSStreamEventHasBytesAvailable)
        [self handleServerInputEvent:streamEvent];
    if (stream == toServer   && streamEvent == NSStreamEventHasSpaceAvailable)
        [self handleServerOutputEvent:streamEvent];
}

- (void)handleClientInputEvent:(NSStreamEvent)event{
    uint8_t buffer[512];
    NSInteger bytesRead = [fromClient read:buffer maxLength:512];

    // Enqueue data for output
    [serverWriteQueue addObject:[NSData dataWithBytes:buffer length:bytesRead]];
}

- (void)handleClientOutputEvent:(NSStreamEvent)event{
    if ([clientWriteQueue count] > 0) {
        NSData *data = [clientWriteQueue objectAtIndex:0];
        [toClient write:[data bytes] maxLength:[data length]];
    }
}

- (void)handleServerInputEvent:(NSStreamEvent)event{
    uint8_t buffer[512];
    NSInteger bytesRead = [fromServer read:buffer maxLength:512];

    // Enqueue data for output
    [clientWriteQueue addObject:[NSData dataWithBytes:buffer length:bytesRead]];
}

- (void)handleServerOutputEvent:(NSStreamEvent)event{
    if ([serverWriteQueue count] > 0) {
        NSData *data = [serverWriteQueue objectAtIndex:0];
        [toServer write:[data bytes] maxLength:[data length]];
    }
}

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

@end