// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//

#if DEPLOYMENT_RUNTIME_OBJC || os(Linux)
    import Foundation
    import XCTest
#else
    import SwiftFoundation
    import SwiftXCTest
#endif


class TestNSNotificationQueue : XCTestCase {
    static var allTests : [(String, TestNSNotificationQueue -> () throws -> Void)] {
        return [
            ("test_defaultQueue", test_defaultQueue),
            ("test_postNowToDefaultQueueWithoutCoalescing", test_postNowToDefaultQueueWithoutCoalescing),
            ("test_postNowToDefaultQueueWithCoalescing", test_postNowToDefaultQueueWithCoalescing),
            ("test_postNowToCustomQueue", test_postNowToCustomQueue),
            ("test_postNowForDefaultRunLoopMode", test_postNowForDefaultRunLoopMode),
            // ("test_notificationQueueLifecycle", test_notificationQueueLifecycle),
            ("test_postAsapToDefaultQueue", test_postAsapToDefaultQueue),
            ("test_postAsapToDefaultQueueWithCoalescingOnNameAndSender", test_postAsapToDefaultQueueWithCoalescingOnNameAndSender),
            ("test_postAsapToDefaultQueueWithCoalescingOnNameOrSender", test_postAsapToDefaultQueueWithCoalescingOnNameOrSender),
            ("test_postIdleToDefaultQueue", test_postIdleToDefaultQueue),
        ]
    }

    func test_defaultQueue() {
        let defaultQueue1 = NSNotificationQueue.defaultQueue()
        XCTAssertNotNil(defaultQueue1)
        let defaultQueue2 = NSNotificationQueue.defaultQueue()
        XCTAssertEqual(defaultQueue1, defaultQueue2)

        executeInBackgroundThread() {
            let defaultQueueForBackgroundThread = NSNotificationQueue.defaultQueue()
            XCTAssertNotNil(defaultQueueForBackgroundThread)
            XCTAssertEqual(defaultQueueForBackgroundThread, NSNotificationQueue.defaultQueue())
            XCTAssertNotEqual(defaultQueueForBackgroundThread, defaultQueue1)
        }
    }

    func test_postNowToDefaultQueueWithoutCoalescing() {
        let notificationName = "test_postNowWithoutCoalescing"
        let dummyObject = NSObject()
        let notification = NSNotification(name: notificationName, object: dummyObject)
        var numberOfCalls = 0
        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
            numberOfCalls += 1
        }
        let queue = NSNotificationQueue.defaultQueue()
        queue.enqueueNotification(notification, postingStyle: .PostNow)
        XCTAssertEqual(numberOfCalls, 1)
    }

    func test_postNowToDefaultQueueWithCoalescing() {
        let notificationName = "test_postNowToDefaultQueueWithCoalescingOnName"
        let dummyObject = NSObject()
        let notification = NSNotification(name: notificationName, object: dummyObject)
        var numberOfCalls = 0
        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
            numberOfCalls += 1
        }
        let queue = NSNotificationQueue.defaultQueue()
        queue.enqueueNotification(notification, postingStyle: .PostNow)
        queue.enqueueNotification(notification, postingStyle: .PostNow)
        queue.enqueueNotification(notification, postingStyle: .PostNow)
        // Coalescing doesn't work for the NSPostingStyle.PostNow. That is why we expect 3 calls here
        XCTAssertEqual(numberOfCalls, 3)
    }

    func test_postNowToCustomQueue() {
        let notificationName = "test_postNowToCustomQueue"
        let dummyObject = NSObject()
        let notification = NSNotification(name: notificationName, object: dummyObject)
        var numberOfCalls = 0
        let notificationCenter = NSNotificationCenter()
        notificationCenter.addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
            numberOfCalls += 1
        }
        let notificationQueue = NSNotificationQueue(notificationCenter: notificationCenter)
        notificationQueue.enqueueNotification(notification, postingStyle: .PostNow)
        XCTAssertEqual(numberOfCalls, 1)
    }

    func test_postNowForDefaultRunLoopMode() {
        let notificationName = "test_postNowToDefaultQueueWithCoalescingOnName"
        let dummyObject = NSObject()
        let notification = NSNotification(name: notificationName, object: dummyObject)
        var numberOfCalls = 0
        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
            numberOfCalls += 1
        }
        let queue = NSNotificationQueue.defaultQueue()

        let runLoop = NSRunLoop.currentRunLoop()
        let endDate = NSDate(timeInterval: NSTimeInterval(0.05), sinceDate: NSDate())

        let dummyTimer = NSTimer.scheduledTimer(0.01, repeats: false) { _ in
            guard let runLoopMode = runLoop.currentMode else {
                return
            }

            // post 2 notifications for the NSDefaultRunLoopMode mode
            queue.enqueueNotification(notification, postingStyle: .PostNow, coalesceMask: [], forModes: [runLoopMode])
            queue.enqueueNotification(notification, postingStyle: .PostNow)
            // here we post notification for the NSRunLoopCommonModes. It shouldn't have any affect, because the timer is scheduled in NSDefaultRunLoopMode.
            // The notification queue will only post the notification to its notification center if the run loop is in one of the modes provided in the array.
            queue.enqueueNotification(notification, postingStyle: .PostNow, coalesceMask: [], forModes: [NSRunLoopCommonModes])
        }
        runLoop.addTimer(dummyTimer, forMode: NSDefaultRunLoopMode)
        runLoop.runMode(NSDefaultRunLoopMode, beforeDate: endDate)
        XCTAssertEqual(numberOfCalls, 2)
    }

    func test_postAsapToDefaultQueue() {
        let notificationName = "test_postAsapToDefaultQueue"
        let dummyObject = NSObject()
        let notification = NSNotification(name: notificationName, object: dummyObject)
        var numberOfCalls = 0
        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
            numberOfCalls += 1
        }
        let queue = NSNotificationQueue.defaultQueue()
        queue.enqueueNotification(notification, postingStyle: .PostASAP)

        scheduleTimer(withInterval: 0.001); // run timer trigger the notifications
        XCTAssertEqual(numberOfCalls, 1)
    }

    func test_postAsapToDefaultQueueWithCoalescingOnNameAndSender() {
        // Check coalescing on name and object
        let notificationName = "test_postAsapToDefaultQueueWithCoalescingOnNameAndSender"
        let notification = NSNotification(name: notificationName, object: NSObject())
        var numberOfCalls = 0
        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: notification.object, queue: nil) { notification in
            numberOfCalls += 1
        }
        let queue = NSNotificationQueue.defaultQueue()
        queue.enqueueNotification(notification, postingStyle: .PostASAP)
        queue.enqueueNotification(notification, postingStyle: .PostASAP)
        queue.enqueueNotification(notification, postingStyle: .PostASAP)

        scheduleTimer(withInterval: 0.001);
        XCTAssertEqual(numberOfCalls, 1)
    }

    func test_postAsapToDefaultQueueWithCoalescingOnNameOrSender() {
        // Check coalescing on name or sender
        let notificationName = "test_postAsapToDefaultQueueWithCoalescingOnNameOrSender"
        let notification1 = NSNotification(name: notificationName, object: NSObject())
        var numberOfNameCoalescingCalls = 0
        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: notification1.object, queue: nil) { notification in
            numberOfNameCoalescingCalls += 1
        }
        let notification2 = NSNotification(name: notificationName, object: NSObject())
        var numberOfObjectCoalescingCalls = 0
        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: notification2.object, queue: nil) { notification in
            numberOfObjectCoalescingCalls += 1
        }

        let queue = NSNotificationQueue.defaultQueue()
        // #1
        queue.enqueueNotification(notification1, postingStyle: .PostASAP,  coalesceMask: .CoalescingOnName, forModes: nil)
        // #2
        queue.enqueueNotification(notification2, postingStyle: .PostASAP,  coalesceMask: .CoalescingOnSender, forModes: nil)
        // #3, coalesce with 1 & 2
        queue.enqueueNotification(notification1, postingStyle: .PostASAP,  coalesceMask: .CoalescingOnName, forModes: nil)
        // #4, coalesce with #3
        queue.enqueueNotification(notification2, postingStyle: .PostASAP,  coalesceMask: .CoalescingOnName, forModes: nil)
        // #5
        queue.enqueueNotification(notification1, postingStyle: .PostASAP,  coalesceMask: .CoalescingOnSender, forModes: nil)
        scheduleTimer(withInterval: 0.001);
        // check that we received notifications #4 and #5
        XCTAssertEqual(numberOfNameCoalescingCalls, 1)
        XCTAssertEqual(numberOfObjectCoalescingCalls, 1)
    }


    func test_postIdleToDefaultQueue() {
        let notificationName = "test_postIdleToDefaultQueue"
        let dummyObject = NSObject()
        let notification = NSNotification(name: notificationName, object: dummyObject)
        var numberOfCalls = 0

        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
            numberOfCalls += 1
        }
        NSNotificationQueue.defaultQueue().enqueueNotification(notification, postingStyle: .PostWhenIdle)
        // add a timer to wakeup the runloop, process the timer and call the observer awaiting for any input sources/timers
        scheduleTimer(withInterval: 0.001);
        XCTAssertEqual(numberOfCalls, 1)
    }

    func test_notificationQueueLifecycle() {
        // check that notificationqueue is associated with current thread. when the thread is destroyed, the queue should be deallocated as well
        weak var notificationQueue: NSNotificationQueue?

        self.executeInBackgroundThread() {
            notificationQueue = NSNotificationQueue(notificationCenter: NSNotificationCenter())
            XCTAssertNotNil(notificationQueue)
        }
        
        XCTAssertNil(notificationQueue)
    }

    // MARK: Private

    private func scheduleTimer(withInterval interval: NSTimeInterval) {
        var isInvoked = false
        let dummyTimer = NSTimer.scheduledTimer(interval, repeats: false) { _ in
            isInvoked = true
        }
        NSRunLoop.currentRunLoop().addTimer(dummyTimer, forMode: NSDefaultRunLoopMode)
        self.waitForExpectation({
            return isInvoked
        }, withTimeout: 0.1)
    }

    private func executeInBackgroundThread(operation: () -> ()) -> Bool {
        var isFinished = false
        let lock = NSLock()
        let bgThread = NSThread() {
            operation()
            lock.lock()
            isFinished = true
            lock.unlock()
        }
        bgThread.start()

        return self.waitForExpectation({
            lock.lock()
            let finished = isFinished
            lock.unlock()
            return finished
        }, withTimeout: 0.2)
    }

    private func waitForExpectation(expectation: () -> Bool, withTimeout timeout: NSTimeInterval) -> Bool {
        let timeoutDate = NSDate(timeIntervalSinceNow: timeout)
        while !expectation() && timeoutDate.timeIntervalSinceNow > 0.0 {
            NSRunLoop.currentRunLoop().runUntilDate(NSDate(timeIntervalSinceNow: 0.01))
        }
        return expectation()
    }

}