@property (copy) void (^FBRequestCallback)(FBRequest*, id, NSError*);
@property (nonatomic, assign)  BOOL usesBlockCallback;
 
+ (FBRequest*) getRequestWithParams:(NSMutableDictionary *)params
                         httpMethod:(NSString *)httpMethod
                           callback:(void(^)(FBRequest *request, id result, NSError *error)) _block
                         requestURL:(NSString *)url;

@synthesize FBRequestCallback = _FBRequestCallback;
@synthesize usesBlockCallback;
 
+ (FBRequest*) getRequestWithParams:(NSMutableDictionary *)params
                         httpMethod:(NSString *)httpMethod
                           callback:(void(^)(FBRequest *request, id result, NSError *error)) _block
                         requestURL:(NSString *)url
{
    FBRequest* request = [[[FBRequest alloc] init] autorelease];
    request.delegate = nil;
    request.url = url;
    request.httpMethod = httpMethod;
    request.params = params;
    request.connection = nil;
    request.responseText = nil;
    request.FBRequestCallback = _block;
 
    return request;
}

- (void)handleResponseData:(NSData *)data {
  if ([_delegate respondsToSelector:
      @selector(request:didLoadRawResponse:)]) {
    [_delegate request:self didLoadRawResponse:data];
  }
 
    if (usesBlockCallback) {
        NSError* error = nil;
        id result = [self parseJsonResponse:data error:&error];
        _FBRequestCallback(self, result, error);
    }
    else if ([_delegate respondsToSelector:@selector(request:didLoad:)] ||
             [_delegate respondsToSelector:@selector(request:didFailWithError:)])
    {
        NSError* error = nil;
        id result = [self parseJsonResponse:data error:&error];
 
        if (error) {
            [self failWithError:error];
        }
        else if ([_delegate respondsToSelector:@selector(request:didLoad:)]) {
            [_delegate request:self didLoad:(result == nil ? data : result)];
        }
 
    }
}

- (void)dealloc {
    [_FBRequestCallback release];
    [_connection cancel];
    [_connection release];
    [_responseText release];
    [_url release];
    [_httpMethod release];
    [_params release];
    [super dealloc];
}

- (void) requestWithGraphPath:(NSString *) _graphPath
                       params:(NSMutableDictionary*) _params
                       method:(NSString*) _method
                     callback:(void(^)(FBRequest *request, id result, NSError *error)) _block;
 
- (void) requestWithMethodName:(NSString *) _methodName
                     andParams:(NSMutableDictionary *) _params
                 andHttpMethod:(NSString *) _method
                      callback:(void(^)(FBRequest *request, id result, NSError *error)) _block;

- (void) requestWithGraphPath:(NSString *) _graphPath
                       params:(NSMutableDictionary*) _params
                       method:(NSString*) _method
                     callback:(void(^)(FBRequest *request, id result, NSError *error)) _block
{
    NSString * fullURL = [kGraphBaseURL stringByAppendingString:_graphPath];
    [_params setValue:@"json" forKey:@"format"];
    [_params setValue:kSDK forKey:@"sdk"];
    [_params setValue:kSDKVersion forKey:@"sdk_version"];
    if ([self isSessionValid]) {
        [_params setValue:self.accessToken forKey:@"access_token"];
    }
 
    [_request release];
    //modify request to have block
    _request = [[FBRequest getRequestWithParams:_params
                                     httpMethod:_method
                                       callback:_block
                                     requestURL:fullURL] retain];
    [_request connect];
}
 
- (void) requestWithMethodName:(NSString *) _methodName
                     andParams:(NSMutableDictionary *) _params
                 andHttpMethod:(NSString *) _method
                      callback:(void(^)(FBRequest *request, id result, NSError *error)) _block
{
    NSString * fullURL = [kRestserverBaseURL stringByAppendingString:_methodName];
    [_params setValue:@"json" forKey:@"format"];
    [_params setValue:kSDK forKey:@"sdk"];
    [_params setValue:kSDKVersion forKey:@"sdk_version"];
    if ([self isSessionValid]) {
        [_params setValue:self.accessToken forKey:@"access_token"];
    }
 
    [_request release];
    //modify request to have block
    _request = [[FBRequest getRequestWithParams:_params
                                     httpMethod:_method
                                       callback:_block
                                     requestURL:fullURL] retain];
    [_request connect];
 
}

    NSMutableDictionary *params = [[[NSMutableDictionary alloc] init] autorelease];
    [facebook requestWithGraphPath:@"me/friends"
                                    params:params
                                    method:@"GET"
                                  callback:^(FBRequest *request, id result, NSError *error)
    {
        NSLog(@"friends %@", result);
        if ([result isKindOfClass:[NSDictionary class]]) {
            friendsList = [[result objectForKey:@"data"] retain];
            [table reloadData];
        }
 
    }];

#import "Facebook.h"
 
#define FB_APP_ID @"197366800287642"
#define FB_API_KEY @"3269fff9ef3b6fc13255e670ebb44c4d"
#define FB_APP_SECRET @"d038b12cc8632865952f69722fe26393"
 
@interface FBRequestWrapper : NSObject
{
	Facebook *facebook;
	BOOL isLoggedIn;
}
 
@property (nonatomic, assign) BOOL isLoggedIn;
 
+ (id) defaultManager;
- (void) setIsLoggedIn:(BOOL) _loggedIn;
- (void) FBSessionBegin:(id) _delegate;
- (void) FBLogout;
- (void) getFBRequestWithGraphPath:(NSString*) _path andDelegate:(id) _delegate;
- (void) sendFBRequestWithGraphPath:(NSString*) _path params:(NSMutableDictionary*) _params andDelegate:(id) _delegate;
 
@end

- (void) FBSessionBegin:(id) _delegate {
 
	if (facebook == nil) {
		facebook = [[Facebook alloc] init];
 
		NSString *token = [[NSUserDefaults standardUserDefaults] objectForKey:@"access_token"];
		NSDate *exp = [[NSUserDefaults standardUserDefaults] objectForKey:@"exp_date"];
 
		if (token != nil && exp != nil && [token length] > 2) {
			isLoggedIn = YES;
			facebook.accessToken = token;
            facebook.expirationDate = [NSDate distantFuture];
		} 
 
		[facebook retain];
	}
 
	NSArray * permissions = [NSArray arrayWithObjects:
							 @"publish_stream",
							 nil];
 
	//if no session is available login
	[facebook authorize:FB_APP_ID permissions:permissions delegate:_delegate];
}

// Used for publishing
- (void) sendFBRequestWithGraphPath:(NSString*) _path params:(NSMutableDictionary*) _params andDelegate:(id) _delegate {
 
	if (_delegate == nil)
		_delegate = self;
 
	if (_params != nil && _path != nil) {
 
		[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:YES];
		[facebook requestWithGraphPath:_path andParams:_params andHttpMethod:@"POST" andDelegate:_delegate];
	}
}

#import "FBRequestWrapper.h"
 
@protocol FBFeedPostDelegate;
 
typedef enum {
  FBPostTypeStatus = 0,
  FBPostTypePhoto = 1,
  FBPostTypeLink = 2
} FBPostType;
 
@interface FBFeedPost : NSObject
{
	NSString *url;
	NSString *message;
	NSString *caption;
	UIImage *image;
	FBPostType postType;
 
	id  delegate;
}
 
@property (nonatomic, assign) FBPostType postType;
@property (nonatomic, retain) NSString *url;
@property (nonatomic, retain) NSString *message;
@property (nonatomic, retain) NSString *caption;
@property (nonatomic, retain) UIImage *image;
 
@property (nonatomic, assign) id  delegate;
 
- (id) initWithLinkPath:(NSString*) _url caption:(NSString*) _caption;
- (id) initWithPostMessage:(NSString*) _message;
- (id) initWithPhoto:(UIImage*) _image name:(NSString*) _name;
- (void) publishPostWithDelegate:(id) _delegate;
 
@end
 
@protocol FBFeedPostDelegate
@required
- (void) failedToPublishPost:(FBFeedPost*) _post;
- (void) finishedPublishingPost:(FBFeedPost*) _post;
@end

- (id) initWithLinkPath:(NSString*) _url caption:(NSString*) _caption {
	self = [super init];
	if (self) {
		postType = FBPostTypeLink;
		url = [_url retain];
		caption = [_caption retain];
	}
	return self;
}
 
- (id) initWithPostMessage:(NSString*) _message {
	self = [super init];
	if (self) {
		postType = FBPostTypeStatus;
		message = [_message retain];
	}
	return self;
}
 
- (id) initWithPhoto:(UIImage*) _image name:(NSString*) _name {
	self = [super init];
	if (self) {
		postType = FBPostTypePhoto;
		image = [_image retain];
		caption = [_image retain];
	}
	return self;
}

 [[FBRequestWrapper defaultManager] sendFBRequestWithGraphPath:graphPath params:params andDelegate:self];

- (void) publishPostWithDelegate:(id) _delegate {
 
	//store the delegate incase the user needs to login
	self.delegate = _delegate;
 
	// if the user is not currently logged in begin the session
	BOOL loggedIn = [[FBRequestWrapper defaultManager] isLoggedIn];
	if (!loggedIn) {
		[[FBRequestWrapper defaultManager] FBSessionBegin:self];
	}
	else {
		NSMutableDictionary *params = [[[NSMutableDictionary alloc] init] autorelease];
 
		//Need to provide POST parameters to the Facebook SDK for the specific post type
		NSString *graphPath = @"me/feed";
 
		switch (postType) {
			case FBPostTypeLink:
			{
				[params setObject:@"link" forKey:@"type"];
				[params setObject:self.url forKey:@"link"];
				[params setObject:self.caption forKey:@"description"];
				break;
			}
			case FBPostTypeStatus:
			{
				[params setObject:@"status" forKey:@"type"];
				[params setObject:self.message forKey:@"message"];
				break;
			}
			case FBPostTypePhoto:
			{
				graphPath = @"me/photos";
				[params setObject:self.image forKey:@"source"];
				[params setObject:self.caption forKey:@"message"];
				break;
			}
			default:
				break;
		}
 
		[[FBRequestWrapper defaultManager] sendFBRequestWithGraphPath:graphPath params:params andDelegate:self];
	}
}
 
#pragma mark -
#pragma mark FacebookSessionDelegate
 
- (void)fbDidLogin {
	[[FBRequestWrapper defaultManager] setIsLoggedIn:YES];
 
	//after the user is logged in try to publish the post
	[self publishPostWithDelegate:self.delegate];
}
 
- (void)fbDidNotLogin:(BOOL)cancelled {
	[[FBRequestWrapper defaultManager] setIsLoggedIn:NO];
 
}
 
#pragma mark -
#pragma mark FBRequestDelegate
 
- (void)request:(FBRequest *)request didFailWithError:(NSError *)error {
	[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
	NSLog(@"ResponseFailed: %@", error);
 
	if ([self.delegate respondsToSelector:@selector(failedToPublishPost:)])
		[self.delegate failedToPublishPost:self];
}
 
- (void)request:(FBRequest *)request didLoad:(id)result {
	[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
	NSLog(@"Parsed Response: %@", result);
 
	if ([self.delegate respondsToSelector:@selector(finishedPublishingPost:)])
		[self.delegate finishedPublishingPost:self];
}

- (IBAction) btnPostPress:(id) sender {
 
	[self.txtView resignFirstResponder];
 
	//we will release this object when it is finished posting
	FBFeedPost *post = [[FBFeedPost alloc] initWithPostMessage:self.txtView.text];
	[post publishPostWithDelegate:self];
 
	IFNNotificationDisplay *display = [[IFNNotificationDisplay alloc] init];
	display.type = NotificationDisplayTypeLoading;
	display.tag = NOTIFICATION_DISPLAY_TAG;
	[display setNotificationText:@"Posting Status..."];
	[display displayInView:self.view atCenter:CGPointMake(self.view.center.x, self.view.center.y-100.0) withInterval:0.0];
	[display release];
}
 
#pragma mark -
#pragma mark FBFeedPostDelegate
 
- (void) failedToPublishPost:(FBFeedPost*) _post {
 
	UIView *dv = [self.view viewWithTag:NOTIFICATION_DISPLAY_TAG];
	[dv removeFromSuperview];
 
	IFNNotificationDisplay *display = [[IFNNotificationDisplay alloc] init];
	display.type = NotificationDisplayTypeText;
	[display setNotificationText:@"Failed To Post"];
	[display displayInView:self.view atCenter:CGPointMake(self.view.center.x, self.view.center.y-100.0) withInterval:1.5];
	[display release];
 
	//release the alloc'd post
	[_post release];
}
 
- (void) finishedPublishingPost:(FBFeedPost*) _post {
 
	UIView *dv = [self.view viewWithTag:NOTIFICATION_DISPLAY_TAG];
	[dv removeFromSuperview];
 
	IFNNotificationDisplay *display = [[IFNNotificationDisplay alloc] init];
	display.type = NotificationDisplayTypeText;
	[display setNotificationText:@"Finished Posting"];
	[display displayInView:self.view atCenter:CGPointMake(self.view.center.x, self.view.center.y-100.0) withInterval:1.5];
	[display release];
 
	//release the alloc'd post
	[_post release];
}