#import "GCDAsyncSocketFactory.h"
#import "GCDAsyncSocket.h"
#import "GCDAsyncHTTPSProxySocket.h"
#import "GCDAsyncSOCKSProxySocket.h"

#ifdef DEBUG
static const DDLogLevel ddLogLevel = DDLogLevelAll;
#else
static const DDLogLevel ddLogLevel = DDLogLevelNotice;
#endif

@implementation GCDAsyncSocketFactory

static void _AutoConfigurationCallback(void *info, CFArrayRef proxyList, CFErrorRef error);

struct AutoConfigLoadStatus {
    bool finished;
    CFArrayRef proxyList;
};

+ (GCDAsyncSocket*)proxyAwareAsyncSocketForHost:(NSString*)host port:(NSNumber*)port delegate:(nullable id<GCDAsyncSocketDelegate>)delegate delegateQueue:(nullable dispatch_queue_t)delegateQueue { 
    NSDictionary *systemProxies = (__bridge NSDictionary*)CFNetworkCopySystemProxySettings();
    NSURL *targetUrl = [NSURL URLWithString:[NSString stringWithFormat:@"https://%@:%@", host, port]];
    NSArray *urlProxies = (__bridge_transfer NSArray*)CFNetworkCopyProxiesForURL((__bridge CFURLRef _Nonnull)targetUrl, (__bridge CFDictionaryRef _Nonnull)systemProxies);
    
    return [GCDAsyncSocketFactory proxyAwareAsyncSocketForProxyList:urlProxies targetUrl:targetUrl delegate:delegate delegateQueue:delegateQueue];
}

+ (GCDAsyncSocket*)proxyAwareAsyncSocketForProxyList:(NSArray*)proxyList targetUrl:(NSURL*)targetUrl delegate:(nullable id<GCDAsyncSocketDelegate>)delegate delegateQueue:(nullable dispatch_queue_t)delegateQueue {
    if (proxyList.count > 0) {
        NSDictionary *proxy = proxyList[0];
        if ([proxy[(NSString*)kCFProxyTypeKey] isEqualToString:(NSString*)kCFProxyTypeSOCKS]) {
            NSString *host = proxy[(NSString*)kCFProxyHostNameKey];
            NSNumber *port = proxy[(NSString*)kCFProxyPortNumberKey];
            NSString *username = proxy[(NSString*)kCFProxyUsernameKey];
            NSString *password = proxy[(NSString*)kCFProxyPasswordKey];
            DDLogNotice(@"Using SOCKS proxy %@:%@", host, port);
            GCDAsyncSOCKSProxySocket *proxySocket = [[GCDAsyncSOCKSProxySocket alloc] initWithDelegate:delegate delegateQueue:delegateQueue];
            [proxySocket setProxyHost:host port:port.intValue version:GCDAsyncSocketSOCKSVersion5];
            if (username && password) {
                [proxySocket setProxyUsername:username password:password];
            }
            return proxySocket;
        } else if ([proxy[(NSString*)kCFProxyTypeKey] isEqualToString:(NSString*)kCFProxyTypeHTTPS]) {
            NSString *host = proxy[(NSString*)kCFProxyHostNameKey];
            NSNumber *port = proxy[(NSString*)kCFProxyPortNumberKey];
            DDLogNotice(@"Using HTTPS proxy %@:%@", host, port);
            GCDAsyncHTTPSProxySocket *proxySocket = [[GCDAsyncHTTPSProxySocket alloc] initWithDelegate:delegate delegateQueue:delegateQueue];
            [proxySocket setProxyHost:host port:port.intValue];
            return proxySocket;
        } else if ([proxy[(NSString*)kCFProxyTypeKey] isEqualToString:(NSString*)kCFProxyTypeAutoConfigurationURL]) {
            NSURL *autoConfigUrl = proxy[(NSString*)kCFProxyAutoConfigurationURLKey];
            DDLogNotice(@"Loading proxy auto config from %@", autoConfigUrl);
            struct AutoConfigLoadStatus status;
            status.finished = false;
            CFStreamClientContext ctxt = { 0, &status, NULL, NULL, NULL };
            CFRunLoopSourceRef rls = CFNetworkExecuteProxyAutoConfigurationURL((__bridge CFURLRef _Nonnull)autoConfigUrl, (__bridge CFURLRef _Nonnull)(targetUrl), _AutoConfigurationCallback, &ctxt);
            CFStringRef mode = CFSTR("__GCDProxyAutoConfigRunLoopMode");
            CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, mode);
            CFAbsoluteTime stopTime = CFAbsoluteTimeGetCurrent() + 10.0;
            do {
                (void) CFRunLoopRunInMode(mode, 0.1, TRUE);
            } while (!status.finished && CFAbsoluteTimeGetCurrent() < stopTime);
            
            if (status.finished && status.proxyList) {
                DDLogVerbose(@"Auto config proxy list: %@", status.proxyList);
                return [GCDAsyncSocketFactory proxyAwareAsyncSocketForProxyList:(__bridge NSArray *)(status.proxyList) targetUrl:targetUrl delegate:delegate delegateQueue:delegateQueue];
            }
            
            if (rls) {
                if (CFRunLoopSourceIsValid(rls)) {
                    CFRunLoopSourceInvalidate(rls);
                    CFRelease(rls);
                }
            }
        }
    }
    
    return [[GCDAsyncSocket alloc] initWithDelegate:delegate delegateQueue:delegateQueue];
}

static void _AutoConfigurationCallback(void *info, CFArrayRef proxyList, CFErrorRef error) {
    struct AutoConfigLoadStatus *status = info;
    status->proxyList = proxyList;
    status->finished = true;
}

@end