iOS/Pods/CocoaLumberjack/Lumberjack/DDLog.m
#import "DDLog.h"

#import <pthread.h>
#import <objc/runtime.h>
#import <mach/mach_host.h>
#import <mach/host_info.h>
#import <libkern/OSAtomic.h>
#import <Availability.h>
#if TARGET_OS_IPHONE
    #import <UIKit/UIDevice.h>
#endif

/**
 * Welcome to Cocoa Lumberjack!
 * 
 * The project page has a wealth of documentation if you have any questions.
 * https://github.com/CocoaLumberjack/CocoaLumberjack
 * 
 * If you're new to the project you may wish to read the "Getting Started" wiki.
 * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/GettingStarted
 * 
**/

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

// We probably shouldn't be using DDLog() statements within the DDLog implementation.
// But we still want to leave our log statements for any future debugging,
// and to allow other developers to trace the implementation (which is a great learning tool).
// 
// So we use a primitive logging macro around NSLog.
// We maintain the NS prefix on the macros to be explicit about the fact that we're using NSLog.

#define DD_DEBUG NO

#define NSLogDebug(frmt, ...) do{ if(DD_DEBUG) NSLog((frmt), ##__VA_ARGS__); } while(0)

// Specifies the maximum queue size of the logging thread.
// 
// Since most logging is asynchronous, its possible for rogue threads to flood the logging queue.
// That is, to issue an abundance of log statements faster than the logging thread can keepup.
// Typically such a scenario occurs when log statements are added haphazardly within large loops,
// but may also be possible if relatively slow loggers are being used.
// 
// This property caps the queue size at a given number of outstanding log statements.
// If a thread attempts to issue a log statement when the queue is already maxed out,
// the issuing thread will block until the queue size drops below the max again.

#define LOG_MAX_QUEUE_SIZE 1000 // Should not exceed INT32_MAX

// The "global logging queue" refers to [DDLog loggingQueue].
// It is the queue that all log statements go through.
//
// The logging queue sets a flag via dispatch_queue_set_specific using this key.
// We can check for this key via dispatch_get_specific() to see if we're on the "global logging queue".

static void *const GlobalLoggingQueueIdentityKey = (void *)&GlobalLoggingQueueIdentityKey;


@interface DDLoggerNode : NSObject {
@public 
    id <DDLogger> logger;   
    dispatch_queue_t loggerQueue;
    int logLevel;
}

@property (nonatomic, assign, readonly) int logLevel;

+ (DDLoggerNode *)nodeWithLogger:(id <DDLogger>)logger loggerQueue:(dispatch_queue_t)loggerQueue logLevel:(int)logLevel;

@end


@interface DDLog (PrivateAPI)

+ (void)lt_addLogger:(id <DDLogger>)logger logLevel:(int)logLevel;
+ (void)lt_removeLogger:(id <DDLogger>)logger;
+ (void)lt_removeAllLoggers;
+ (NSArray *)lt_allLoggers;
+ (void)lt_log:(DDLogMessage *)logMessage;
+ (void)lt_flush;

@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark -
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@implementation DDLog

// An array used to manage all the individual loggers.
// The array is only modified on the loggingQueue/loggingThread.
static NSMutableArray *loggers;

// All logging statements are added to the same queue to ensure FIFO operation.
static dispatch_queue_t loggingQueue;

// Individual loggers are executed concurrently per log statement.
// Each logger has it's own associated queue, and a dispatch group is used for synchrnoization.
static dispatch_group_t loggingGroup;

// In order to prevent to queue from growing infinitely large,
// a maximum size is enforced (LOG_MAX_QUEUE_SIZE).
static dispatch_semaphore_t queueSemaphore;

// Minor optimization for uniprocessor machines
static unsigned int numProcessors;

/**
 * The runtime sends initialize to each class in a program exactly one time just before the class,
 * or any class that inherits from it, is sent its first message from within the program. (Thus the
 * method may never be invoked if the class is not used.) The runtime sends the initialize message to
 * classes in a thread-safe manner. Superclasses receive this message before their subclasses.
 *
 * This method may also be called directly (assumably by accident), hence the safety mechanism.
**/
+ (void)initialize
{
    static BOOL initialized = NO;
    if (!initialized)
    {
        initialized = YES;
        
        loggers = [[NSMutableArray alloc] initWithCapacity:4];
        
        NSLogDebug(@"DDLog: Using grand central dispatch");
        
        loggingQueue = dispatch_queue_create("cocoa.lumberjack", NULL);
        loggingGroup = dispatch_group_create();
        
        void *nonNullValue = GlobalLoggingQueueIdentityKey; // Whatever, just not null
        dispatch_queue_set_specific(loggingQueue, GlobalLoggingQueueIdentityKey, nonNullValue, NULL);
        
        queueSemaphore = dispatch_semaphore_create(LOG_MAX_QUEUE_SIZE);
        
        // Figure out how many processors are available.
        // This may be used later for an optimization on uniprocessor machines.
        
        host_basic_info_data_t hostInfo;
        mach_msg_type_number_t infoCount;
        
        infoCount = HOST_BASIC_INFO_COUNT;
        host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo, &infoCount);
        
        unsigned int result = (unsigned int)(hostInfo.max_cpus);
        unsigned int one    = (unsigned int)(1);
        
        numProcessors = MAX(result, one);
        
        NSLogDebug(@"DDLog: numProcessors = %u", numProcessors);
            
        
    #if TARGET_OS_IPHONE
        NSString *notificationName = @"UIApplicationWillTerminateNotification";
    #else
        NSString *notificationName = nil;

        if (NSClassFromString(@"NSApplication"))
        {
            notificationName = @"NSApplicationWillTerminateNotification";
        }
        else
        {
            // If there is no NSApp -> we are running Command Line Tool app.
            // In this case terminate notification wouldn't be fired, so we use workaround.
            atexit_b(^{
                [self applicationWillTerminate:nil];
            });
        }
    #endif
        
        if (notificationName) {
            [[NSNotificationCenter defaultCenter] addObserver:self
                                                     selector:@selector(applicationWillTerminate:)
                                                         name:notificationName
                                                       object:nil];
        }
    }
}

/**
 * Provides access to the logging queue.
**/
+ (dispatch_queue_t)loggingQueue
{
    return loggingQueue;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Notifications
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+ (void)applicationWillTerminate:(NSNotification *)notification
{
    [self flushLog];
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Logger Management
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+ (void)addLogger:(id <DDLogger>)logger
{
    [self addLogger:logger withLogLevel:LOG_LEVEL_VERBOSE];
}

+ (void)addLogger:(id <DDLogger>)logger withLogLevel:(int)logLevel
{
    if (logger == nil) return;
    
    dispatch_async(loggingQueue, ^{ @autoreleasepool {
        
        [self lt_addLogger:logger logLevel:logLevel];
    }});
}

+ (void)removeLogger:(id <DDLogger>)logger
{
    if (logger == nil) return;
    
    dispatch_async(loggingQueue, ^{ @autoreleasepool {
        
        [self lt_removeLogger:logger];
    }});
}

+ (void)removeAllLoggers
{
    dispatch_async(loggingQueue, ^{ @autoreleasepool {
        
        [self lt_removeAllLoggers];
    }});
}

+ (NSArray *)allLoggers
{
    __block NSArray *theLoggers;

    dispatch_sync(loggingQueue, ^{ @autoreleasepool {
        theLoggers = [self lt_allLoggers];
    }});

    return theLoggers;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Master Logging
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+ (void)queueLogMessage:(DDLogMessage *)logMessage asynchronously:(BOOL)asyncFlag
{
    // We have a tricky situation here...
    // 
    // In the common case, when the queueSize is below the maximumQueueSize,
    // we want to simply enqueue the logMessage. And we want to do this as fast as possible,
    // which means we don't want to block and we don't want to use any locks.
    // 
    // However, if the queueSize gets too big, we want to block.
    // But we have very strict requirements as to when we block, and how long we block.
    // 
    // The following example should help illustrate our requirements:
    // 
    // Imagine that the maximum queue size is configured to be 5,
    // and that there are already 5 log messages queued.
    // Let us call these 5 queued log messages A, B, C, D, and E. (A is next to be executed)
    // 
    // Now if our thread issues a log statement (let us call the log message F),
    // it should block before the message is added to the queue.
    // Furthermore, it should be unblocked immediately after A has been unqueued.
    // 
    // The requirements are strict in this manner so that we block only as long as necessary,
    // and so that blocked threads are unblocked in the order in which they were blocked.
    // 
    // Returning to our previous example, let us assume that log messages A through E are still queued.
    // Our aforementioned thread is blocked attempting to queue log message F.
    // Now assume we have another separate thread that attempts to issue log message G.
    // It should block until log messages A and B have been unqueued.
    
    
    // We are using a counting semaphore provided by GCD.
    // The semaphore is initialized with our LOG_MAX_QUEUE_SIZE value.
    // Everytime we want to queue a log message we decrement this value.
    // If the resulting value is less than zero,
    // the semaphore function waits in FIFO order for a signal to occur before returning.
    // 
    // A dispatch semaphore is an efficient implementation of a traditional counting semaphore.
    // Dispatch semaphores call down to the kernel only when the calling thread needs to be blocked.
    // If the calling semaphore does not need to block, no kernel call is made.
    
    dispatch_semaphore_wait(queueSemaphore, DISPATCH_TIME_FOREVER);
    
    // We've now sure we won't overflow the queue.
    // It is time to queue our log message.
    
    dispatch_block_t logBlock = ^{ @autoreleasepool {
        
        [self lt_log:logMessage];
    }};
    
    if (asyncFlag)
        dispatch_async(loggingQueue, logBlock);
    else
        dispatch_sync(loggingQueue, logBlock);
}

+ (void)log:(BOOL)asynchronous
      level:(int)level
       flag:(int)flag
    context:(int)context
       file:(const char *)file
   function:(const char *)function
       line:(int)line
        tag:(id)tag
     format:(NSString *)format, ...
{
    va_list args;
    if (format)
    {
        va_start(args, format);
        
        NSString *logMsg = [[NSString alloc] initWithFormat:format arguments:args];
        DDLogMessage *logMessage = [[DDLogMessage alloc] initWithLogMsg:logMsg
                                                                  level:level
                                                                   flag:flag
                                                                context:context
                                                                   file:file
                                                               function:function
                                                                   line:line
                                                                    tag:tag
                                                                options:0];
        
        [self queueLogMessage:logMessage asynchronously:asynchronous];
        
        va_end(args);
    }
}

+ (void)log:(BOOL)asynchronous
      level:(int)level
       flag:(int)flag
    context:(int)context
       file:(const char *)file
   function:(const char *)function
       line:(int)line
        tag:(id)tag
     format:(NSString *)format
       args:(va_list)args
{
    if (format)
    {
        NSString *logMsg = [[NSString alloc] initWithFormat:format arguments:args];
        DDLogMessage *logMessage = [[DDLogMessage alloc] initWithLogMsg:logMsg
                                                                  level:level
                                                                   flag:flag
                                                                context:context
                                                                   file:file
                                                               function:function
                                                                   line:line
                                                                    tag:tag
                                                                options:0];
        
        [self queueLogMessage:logMessage asynchronously:asynchronous];
    }
}

+ (void)flushLog
{
    dispatch_sync(loggingQueue, ^{ @autoreleasepool {
        
        [self lt_flush];
    }});
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Registered Dynamic Logging
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+ (BOOL)isRegisteredClass:(Class)class
{
    SEL getterSel = @selector(ddLogLevel);
    SEL setterSel = @selector(ddSetLogLevel:);
    
#if TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR
    
    // Issue #6 (GoogleCode) - Crashes on iOS 4.2.1 and iPhone 4
    // 
    // Crash caused by class_getClassMethod(2).
    // 
    //     "It's a bug with UIAccessibilitySafeCategory__NSObject so it didn't pop up until
    //      users had VoiceOver enabled [...]. I was able to work around it by searching the
    //      result of class_copyMethodList() instead of calling class_getClassMethod()"
    
    BOOL result = NO;
    
    unsigned int methodCount, i;
    Method *methodList = class_copyMethodList(object_getClass(class), &methodCount);
    
    if (methodList != NULL)
    {
        BOOL getterFound = NO;
        BOOL setterFound = NO;
        
        for (i = 0; i < methodCount; ++i)
        {
            SEL currentSel = method_getName(methodList[i]);
            
            if (currentSel == getterSel)
            {
                getterFound = YES;
            }
            else if (currentSel == setterSel)
            {
                setterFound = YES;
            }
            
            if (getterFound && setterFound)
            {
                result = YES;
                break;
            }
        }
        
        free(methodList);
    }
    
    return result;
    
#else
    
    // Issue #24 (GitHub) - Crashing in in ARC+Simulator
    // 
    // The method +[DDLog isRegisteredClass] will crash a project when using it with ARC + Simulator.
    // For running in the Simulator, it needs to execute the non-iOS code.
    
    Method getter = class_getClassMethod(class, getterSel);
    Method setter = class_getClassMethod(class, setterSel);
    
    if ((getter != NULL) && (setter != NULL))
    {
        return YES;
    }
    
    return NO;
    
#endif
}

+ (NSArray *)registeredClasses
{
    int numClasses, i;
    
    // We're going to get the list of all registered classes.
    // The Objective-C runtime library automatically registers all the classes defined in your source code.
    // 
    // To do this we use the following method (documented in the Objective-C Runtime Reference):
    // 
    // int objc_getClassList(Class *buffer, int bufferLen)
    // 
    // We can pass (NULL, 0) to obtain the total number of
    // registered class definitions without actually retrieving any class definitions.
    // This allows us to allocate the minimum amount of memory needed for the application.
    
    numClasses = objc_getClassList(NULL, 0);
    
    // The numClasses method now tells us how many classes we have.
    // So we can allocate our buffer, and get pointers to all the class definitions.
    
    Class *classes = (Class *)malloc(sizeof(Class) * numClasses);
    if (classes == NULL) return nil;
    
    numClasses = objc_getClassList(classes, numClasses);
    
    // We can now loop through the classes, and test each one to see if it is a DDLogging class.
    
    NSMutableArray *result = [NSMutableArray arrayWithCapacity:numClasses];
    
    for (i = 0; i < numClasses; i++)
    {
        Class class = classes[i];
        
        if ([self isRegisteredClass:class])
        {
            [result addObject:class];
        }
    }
    
    free(classes);
    
    return result;
}

+ (NSArray *)registeredClassNames
{
    NSArray *registeredClasses = [self registeredClasses];
    NSMutableArray *result = [NSMutableArray arrayWithCapacity:[registeredClasses count]];
    
    for (Class class in registeredClasses)
    {
        [result addObject:NSStringFromClass(class)];
    }
    
    return result;
}

+ (int)logLevelForClass:(Class)aClass
{
    if ([self isRegisteredClass:aClass])
    {
        return [aClass ddLogLevel];
    }
    
    return -1;
}

+ (int)logLevelForClassWithName:(NSString *)aClassName
{
    Class aClass = NSClassFromString(aClassName);
    
    return [self logLevelForClass:aClass];
}

+ (void)setLogLevel:(int)logLevel forClass:(Class)aClass
{
    if ([self isRegisteredClass:aClass])
    {
        [aClass ddSetLogLevel:logLevel];
    }
}

+ (void)setLogLevel:(int)logLevel forClassWithName:(NSString *)aClassName
{
    Class aClass = NSClassFromString(aClassName);
    
    [self setLogLevel:logLevel forClass:aClass];
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Logging Thread
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+ (void)lt_addLogger:(id <DDLogger>)logger logLevel:(int)logLevel
{
    // Add to loggers array.
    // Need to create loggerQueue if loggerNode doesn't provide one.

    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
            @"This method should only be run on the logging thread/queue");
    
    dispatch_queue_t loggerQueue = NULL;
    
    if ([logger respondsToSelector:@selector(loggerQueue)])
    {
        // Logger may be providing its own queue
        
        loggerQueue = [logger loggerQueue];
    }
    
    if (loggerQueue == nil)
    {
        // Automatically create queue for the logger.
        // Use the logger name as the queue name if possible.
        
        const char *loggerQueueName = NULL;
        if ([logger respondsToSelector:@selector(loggerName)])
        {
            loggerQueueName = [[logger loggerName] UTF8String];
        }
        
        loggerQueue = dispatch_queue_create(loggerQueueName, NULL);
    }
    
    DDLoggerNode *loggerNode = [DDLoggerNode nodeWithLogger:logger loggerQueue:loggerQueue logLevel:logLevel];
    [loggers addObject:loggerNode];
    
    if ([logger respondsToSelector:@selector(didAddLogger)])
    {
        dispatch_async(loggerNode->loggerQueue, ^{ @autoreleasepool {
            
            [logger didAddLogger];
        }});
    }
}

+ (void)lt_removeLogger:(id <DDLogger>)logger
{
    // Find associated loggerNode in list of added loggers

    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
            @"This method should only be run on the logging thread/queue");
    
    DDLoggerNode *loggerNode = nil;
    
    for (DDLoggerNode *node in loggers)
    {
        if (node->logger == logger)
        {
            loggerNode = node;
            break;
        }
    }
    
    if (loggerNode == nil)
    {
        NSLogDebug(@"DDLog: Request to remove logger which wasn't added");
        return;
    }
    
    // Notify logger
    
    if ([logger respondsToSelector:@selector(willRemoveLogger)])
    {
        dispatch_async(loggerNode->loggerQueue, ^{ @autoreleasepool {
            
            [logger willRemoveLogger];
        }});
    }
    
    // Remove from loggers array
    
    [loggers removeObject:loggerNode];
}

+ (void)lt_removeAllLoggers
{
    // Notify all loggers
    
    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
            @"This method should only be run on the logging thread/queue");

    for (DDLoggerNode *loggerNode in loggers)
    {
        if ([loggerNode->logger respondsToSelector:@selector(willRemoveLogger)])
        {
            dispatch_async(loggerNode->loggerQueue, ^{ @autoreleasepool {
                
                [loggerNode->logger willRemoveLogger];
            }});
        }
    }
    
    // Remove all loggers from array
    
    [loggers removeAllObjects];
}

+ (NSArray *)lt_allLoggers
{
    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
            @"This method should only be run on the logging thread/queue");

    NSMutableArray *theLoggers = [NSMutableArray new];

    for (DDLoggerNode *loggerNode in loggers)
    {
        [theLoggers addObject:loggerNode->logger];
    }

    return [theLoggers copy];
}

+ (void)lt_log:(DDLogMessage *)logMessage
{
    // Execute the given log message on each of our loggers.

    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
            @"This method should only be run on the logging thread/queue");
    
    if (numProcessors > 1)
    {
        // Execute each logger concurrently, each within its own queue.
        // All blocks are added to same group.
        // After each block has been queued, wait on group.
        // 
        // The waiting ensures that a slow logger doesn't end up with a large queue of pending log messages.
        // This would defeat the purpose of the efforts we made earlier to restrict the max queue size.
        
        for (DDLoggerNode *loggerNode in loggers)
        {
            // skip the loggers that shouldn't write this message based on the logLevel

            if (!(logMessage->logFlag & loggerNode.logLevel))
                continue;

            dispatch_group_async(loggingGroup, loggerNode->loggerQueue, ^{ @autoreleasepool {
                
                [loggerNode->logger logMessage:logMessage];
            
            }});
        }
        
        dispatch_group_wait(loggingGroup, DISPATCH_TIME_FOREVER);
    }
    else
    {
        // Execute each logger serialy, each within its own queue.
        
        for (DDLoggerNode *loggerNode in loggers)
        {
            // skip the loggers that shouldn't write this message based on the logLevel
            
            if (!(logMessage->logFlag & loggerNode.logLevel))
                continue;

            dispatch_sync(loggerNode->loggerQueue, ^{ @autoreleasepool {
                
                [loggerNode->logger logMessage:logMessage];
                
            }});
        }
    }
    
    // If our queue got too big, there may be blocked threads waiting to add log messages to the queue.
    // Since we've now dequeued an item from the log, we may need to unblock the next thread.
    
    // We are using a counting semaphore provided by GCD.
    // The semaphore is initialized with our LOG_MAX_QUEUE_SIZE value.
    // When a log message is queued this value is decremented.
    // When a log message is dequeued this value is incremented.
    // If the value ever drops below zero,
    // the queueing thread blocks and waits in FIFO order for us to signal it.
    // 
    // A dispatch semaphore is an efficient implementation of a traditional counting semaphore.
    // Dispatch semaphores call down to the kernel only when the calling thread needs to be blocked.
    // If the calling semaphore does not need to block, no kernel call is made.
    
    dispatch_semaphore_signal(queueSemaphore);
}

+ (void)lt_flush
{
    // All log statements issued before the flush method was invoked have now been executed.
    // 
    // Now we need to propogate the flush request to any loggers that implement the flush method.
    // This is designed for loggers that buffer IO.

    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
            @"This method should only be run on the logging thread/queue");
        
    for (DDLoggerNode *loggerNode in loggers)
    {
        if ([loggerNode->logger respondsToSelector:@selector(flush)])
        {
            dispatch_group_async(loggingGroup, loggerNode->loggerQueue, ^{ @autoreleasepool {
                
                [loggerNode->logger flush];
                
            }});
        }
    }
    
    dispatch_group_wait(loggingGroup, DISPATCH_TIME_FOREVER);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Utilities
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

NSString *DDExtractFileNameWithoutExtension(const char *filePath, BOOL copy)
{
    if (filePath == NULL) return nil;
    
    char *lastSlash = NULL;
    char *lastDot = NULL;
    
    char *p = (char *)filePath;
    
    while (*p != '\0')
    {
        if (*p == '/')
            lastSlash = p;
        else if (*p == '.')
            lastDot = p;
        
        p++;
    }
    
    char *subStr;
    NSUInteger subLen;
    
    if (lastSlash)
    {
        if (lastDot)
        {
            // lastSlash -> lastDot
            subStr = lastSlash + 1;
            subLen = lastDot - subStr;
        }
        else
        {
            // lastSlash -> endOfString
            subStr = lastSlash + 1;
            subLen = p - subStr;
        }
    }
    else
    {
        if (lastDot)
        {
            // startOfString -> lastDot
            subStr = (char *)filePath;
            subLen = lastDot - subStr;
        }
        else
        {
            // startOfString -> endOfString
            subStr = (char *)filePath;
            subLen = p - subStr;
        }
    }
    
    if (copy)
    {
        return [[NSString alloc] initWithBytes:subStr
                                        length:subLen
                                      encoding:NSUTF8StringEncoding];
    }
    else
    {
        // We can take advantage of the fact that __FILE__ is a string literal.
        // Specifically, we don't need to waste time copying the string.
        // We can just tell NSString to point to a range within the string literal.
        
        return [[NSString alloc] initWithBytesNoCopy:subStr
                                              length:subLen
                                            encoding:NSUTF8StringEncoding
                                        freeWhenDone:NO];
    }
}

@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark -
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@implementation DDLoggerNode

@synthesize logLevel;

- (instancetype)initWithLogger:(id <DDLogger>)aLogger loggerQueue:(dispatch_queue_t)aLoggerQueue logLevel:(int)aLogLevel
{
    if ((self = [super init]))
    {
        logger = aLogger;
        
        if (aLoggerQueue) {
            loggerQueue = aLoggerQueue;
            #if !OS_OBJECT_USE_OBJC
            dispatch_retain(loggerQueue);
            #endif
        }
        logLevel = aLogLevel;
    }
    return self;
}

+ (DDLoggerNode *)nodeWithLogger:(id <DDLogger>)logger loggerQueue:(dispatch_queue_t)loggerQueue logLevel:(int)logLevel
{
    return [[DDLoggerNode alloc] initWithLogger:logger loggerQueue:loggerQueue logLevel:logLevel];
}

- (void)dealloc
{
    #if !OS_OBJECT_USE_OBJC
    if (loggerQueue) dispatch_release(loggerQueue);
    #endif
}

@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark -
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@implementation DDLogMessage

static char *dd_str_copy(const char *str)
{
    if (str == NULL) return NULL;
    
    size_t length = strlen(str);
    char * result = malloc(length + 1);
    if (result == NULL) return NULL;
    strncpy(result, str, length);
    result[length] = 0;
    
    return result;
}

- (instancetype)initWithLogMsg:(NSString *)msg
                         level:(int)level
                          flag:(int)flag
                       context:(int)context
                          file:(const char *)aFile
                      function:(const char *)aFunction
                          line:(int)line
                           tag:(id)aTag
                       options:(DDLogMessageOptions)optionsMask
{
    if ((self = [super init]))
    {
        logMsg     = msg;
        logLevel   = level;
        logFlag    = flag;
        logContext = context;
        lineNumber = line;
        tag        = aTag;
        options    = optionsMask;
        
        if (options & DDLogMessageCopyFile)
            file = dd_str_copy(aFile);
        else
            file = (char *)aFile;
        
        if (options & DDLogMessageCopyFunction)
            function = dd_str_copy(aFunction);
        else
            function = (char *)aFunction;
        
        timestamp = [[NSDate alloc] init];
        
        machThreadID = pthread_mach_thread_np(pthread_self());

        // Try to get the current queue's label
        
        // a) Compiling against newer SDK's (iOS 7+/OS X 10.9+) where DISPATCH_CURRENT_QUEUE_LABEL is defined
        //    on a (iOS 7.0+/OS X 10.9+) runtime version
        BOOL gotLabel = NO;
        #ifdef DISPATCH_CURRENT_QUEUE_LABEL
        if (
            #if TARGET_OS_IPHONE
                #ifndef NSFoundationVersionNumber_iOS_6_1
                #define NSFoundationVersionNumber_iOS_6_1 993.00
                #endif
                floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_6_1 // iOS 7+ (> iOS 6.1)
            #else
                [NSTimer instancesRespondToSelector:@selector(tolerance)] // OS X 10.9+
            #endif
            ) {
            queueLabel = dd_str_copy(dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL));
            gotLabel = YES;
        }
        #endif
        
        // b) Systems where dispatch_get_current_queue is not yet deprecated and won't crash (< iOS 6.0/OS X 10.9)
        //    dispatch_get_current_queue(void); __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_6,__MAC_10_9,__IPHONE_4_0,__IPHONE_6_0)
        if (!gotLabel &&
        #if TARGET_OS_IPHONE
            #ifndef NSFoundationVersionNumber_iOS_6_0
            #define NSFoundationVersionNumber_iOS_6_0 993.00
            #endif
            floor(NSFoundationVersionNumber) < NSFoundationVersionNumber_iOS_6_0 // < iOS 6.0
        #else
            ![NSTimer instancesRespondToSelector:@selector(tolerance)] // < OS X 10.9
        #endif
            ) {
            #pragma clang diagnostic push
            #pragma clang diagnostic ignored "-Wdeprecated-declarations"
            dispatch_queue_t currentQueue = dispatch_get_current_queue();
            #pragma clang diagnostic pop
            
            queueLabel = dd_str_copy(dispatch_queue_get_label(currentQueue));
            gotLabel = YES;
        }
        
        // c) Give up
        if (!gotLabel) {
            queueLabel = dd_str_copy(""); // iOS 6.x only
        }
        
        threadName = [[NSThread currentThread] name];
    }
    return self;
}

- (NSString *)threadID
{
    return [[NSString alloc] initWithFormat:@"%x", machThreadID];
}

- (NSString *)fileName
{
    return DDExtractFileNameWithoutExtension(file, NO);
}

- (NSString *)methodName
{
    if (function == NULL)
        return nil;
    else
        return [[NSString alloc] initWithUTF8String:function];
}

- (void)dealloc
{
    if (file && (options & DDLogMessageCopyFile))
        free(file);
    
    if (function && (options & DDLogMessageCopyFunction))
        free(function);
    
    if (queueLabel)
        free(queueLabel);
}


- (id)copyWithZone:(NSZone *)zone {
    DDLogMessage *newMessage = [[DDLogMessage alloc] init];
    
    newMessage->logLevel = self->logLevel;
    newMessage->logFlag = self->logFlag;
    newMessage->logContext = self->logContext;
    newMessage->logMsg = self->logMsg;
    newMessage->timestamp = self->timestamp;
    
    if (self->options & DDLogMessageCopyFile) {
        newMessage->file = dd_str_copy(self->file);
        newMessage->function = dd_str_copy(self->function);
    } else {
        newMessage->file = self->file;
        newMessage->function = self->function;
    }
    
    newMessage->lineNumber = self->lineNumber;
    
    newMessage->machThreadID = self->machThreadID;
    newMessage->queueLabel = dd_str_copy(self->queueLabel);
    newMessage->threadName = self->threadName;
    newMessage->tag = self->tag;
    newMessage->options = self->options;
    
    return newMessage;
}

@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark -
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@implementation DDAbstractLogger

- (id)init
{
    if ((self = [super init]))
    {
        const char *loggerQueueName = NULL;
        if ([self respondsToSelector:@selector(loggerName)])
        {
            loggerQueueName = [[self loggerName] UTF8String];
        }
        
        loggerQueue = dispatch_queue_create(loggerQueueName, NULL);
        
        // We're going to use dispatch_queue_set_specific() to "mark" our loggerQueue.
        // Later we can use dispatch_get_specific() to determine if we're executing on our loggerQueue.
        // The documentation states:
        //
        // > Keys are only compared as pointers and are never dereferenced.
        // > Thus, you can use a pointer to a static variable for a specific subsystem or
        // > any other value that allows you to identify the value uniquely.
        // > Specifying a pointer to a string constant is not recommended.
        //
        // So we're going to use the very convenient key of "self",
        // which also works when multiple logger classes extend this class, as each will have a different "self" key.
        //
        // This is used primarily for thread-safety assertions (via the isOnInternalLoggerQueue method below).
        
        void *key = (__bridge void *)self;
        void *nonNullValue = (__bridge void *)self;
        
        dispatch_queue_set_specific(loggerQueue, key, nonNullValue, NULL);
    }
    return self;
}

- (void)dealloc
{
    #if !OS_OBJECT_USE_OBJC
    if (loggerQueue) dispatch_release(loggerQueue);
    #endif
}

- (void)logMessage:(DDLogMessage *)logMessage
{
    // Override me
}

- (id <DDLogFormatter>)logFormatter
{
    // This method must be thread safe and intuitive.
    // Therefore if somebody executes the following code:
    // 
    // [logger setLogFormatter:myFormatter];
    // formatter = [logger logFormatter];
    // 
    // They would expect formatter to equal myFormatter.
    // This functionality must be ensured by the getter and setter method.
    //
    // The thread safety must not come at a cost to the performance of the logMessage method.
    // This method is likely called sporadically, while the logMessage method is called repeatedly.
    // This means, the implementation of this method:
    // - Must NOT require the logMessage method to acquire a lock.
    // - Must NOT require the logMessage method to access an atomic property (also a lock of sorts).
    //
    // Thread safety is ensured by executing access to the formatter variable on the loggerQueue.
    // This is the same queue that the logMessage method operates on.
    //
    // Note: The last time I benchmarked the performance of direct access vs atomic property access,
    // direct access was over twice as fast on the desktop and over 6 times as fast on the iPhone.
    // 
    // Furthermore, consider the following code:
    //
    // DDLogVerbose(@"log msg 1");
    // DDLogVerbose(@"log msg 2");
    // [logger setFormatter:myFormatter];
    // DDLogVerbose(@"log msg 3");
    //
    // Our intuitive requirement means that the new formatter will only apply to the 3rd log message.
    // This must remain true even when using asynchronous logging.
    // We must keep in mind the various queue's that are in play here:
    // 
    // loggerQueue : Our own private internal queue that the logMessage method runs on.
    //               Operations are added to this queue from the global loggingQueue.
    // 
    // globalLoggingQueue : The queue that all log messages go through before they arrive in our loggerQueue.
    // 
    // All log statements go through the serial gloabalLoggingQueue before they arrive at our loggerQueue.
    // Thus this method also goes through the serial globalLoggingQueue to ensure intuitive operation.
    
    // IMPORTANT NOTE:
    // 
    // Methods within the DDLogger implementation MUST access the formatter ivar directly.
    // This method is designed explicitly for external access.
    //
    // Using "self." syntax to go through this method will cause immediate deadlock.
    // This is the intended result. Fix it by accessing the ivar directly.
    // Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
    
    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
    
    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
    
    __block id <DDLogFormatter> result;
    
    dispatch_sync(globalLoggingQueue, ^{
        dispatch_sync(loggerQueue, ^{
            result = formatter;
        });
    });
    
    return result;
}

- (void)setLogFormatter:(id <DDLogFormatter>)logFormatter
{
    // The design of this method is documented extensively in the logFormatter message (above in code).
    
    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
    
    dispatch_block_t block = ^{ @autoreleasepool {
        
        if (formatter != logFormatter)
        {
            if ([formatter respondsToSelector:@selector(willRemoveFromLogger:)]) {
                [formatter willRemoveFromLogger:self];
            }
            
            formatter = logFormatter;
            
            if ([formatter respondsToSelector:@selector(didAddToLogger:)]) {
                [formatter didAddToLogger:self];
            }
        }
    }};
    
    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
    
    dispatch_async(globalLoggingQueue, ^{
        dispatch_async(loggerQueue, block);
    });
}

- (dispatch_queue_t)loggerQueue
{
    return loggerQueue;
}

- (NSString *)loggerName
{
    return NSStringFromClass([self class]);
}

- (BOOL)isOnGlobalLoggingQueue
{
    return (dispatch_get_specific(GlobalLoggingQueueIdentityKey) != NULL);
}

- (BOOL)isOnInternalLoggerQueue
{
    void *key = (__bridge void *)self;
    return (dispatch_get_specific(key) != NULL);
}

@end
