// Copyright 2016 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

import Foundation
import XCTest
@testable import SyncbaseCore

struct EmptyCredentials: OAuthCredentials {
  let provider: OAuthProvider = OAuthProvider.Google
  let token: String = ""
}

let testQueue = dispatch_queue_create("SyncbaseQueue", DISPATCH_QUEUE_SERIAL)

class BasicDatabaseTests: XCTestCase {
  override class func setUp() {
    Syncbase.isUnitTest = true
    let rootDir = NSFileManager.defaultManager()
      .URLsForDirectory(.ApplicationSupportDirectory, inDomains: .UserDomainMask)[0]
      .URLByAppendingPathComponent("SyncbaseUnitTest")
      .path!
    try! Syncbase.configure(rootDir: rootDir, queue: testQueue)
    let semaphore = dispatch_semaphore_create(0)
    Syncbase.login(EmptyCredentials(), callback: { err in
      XCTAssertNil(err)
      dispatch_semaphore_signal(semaphore)
    })
    if dispatch_semaphore_wait(semaphore, secondsGCD(5)) != 0 {
      XCTFail("Timed out performing login")
    }
  }

  override class func tearDown() {
    Syncbase.shutdown()
  }

  // MARK: Database & collection creation / destroying / listing

  func testDbCreateExistsDestroy() {
    withTestDb { db in }
  }

  func testListDatabases() {
    withTestDb { db in
      let databases = try Syncbase.listDatabases()
      XCTAssertFalse(databases.isEmpty)
      if !databases.isEmpty {
        XCTAssertTrue(databases.first! == db.databaseId)
      }
    }
  }

  func testCollectionCreateExistsDestroy() {
    withTestCollection { db, collection in }
  }

  func testListCollections() {
    withTestCollection { db, collection in
      let collections = try db.listCollections()
      XCTAssertEqual(collections.count, 1)
      XCTAssertTrue(collections.first! == collection.collectionId)
    }
  }

  // MARK: Test getting/putting/deleting data

  class func testGetPutRow<T: SyncbaseConvertible where T: Equatable>(collection: Collection, key: String, targetValue: T, equals: ((T, T) -> Bool)? = nil) throws {
    var value: T? = try collection.get(key)
    XCTAssertNil(value, "Row shouldn't exist yet; yet it has value \(value)")
    try collection.put(key, value: targetValue)
    value = try collection.get(key)
    if let eq = equals {
      XCTAssertTrue(eq(value!, targetValue), "Value should be defined and \(targetValue)")
    } else {
      XCTAssertEqual(value!, targetValue, "Value should be defined and \(targetValue)")
    }
    XCTAssertTrue(try collection.exists(key))
    try collection.delete(key)
    value = try collection.get(key)
    XCTAssertNil(value, "Deleted row shouldn't exist")
  }

  func testRawBytesGetPut() {
    withTestCollection { db, collection in
      let key = "testrow"
      try collection.delete(key)
      XCTAssertFalse(try collection.exists(key))
      try BasicDatabaseTests.testGetPutRow(collection, key: key, targetValue: NSData())
      try BasicDatabaseTests.testGetPutRow(collection, key: key, targetValue: NSJSONSerialization.hackSerializeAnyObject(false))
      try BasicDatabaseTests.testGetPutRow(collection, key: key, targetValue: NSJSONSerialization.hackSerializeAnyObject(M_PI))
      try BasicDatabaseTests.testGetPutRow(collection, key: key, targetValue: NSJSONSerialization.hackSerializeAnyObject("你好，世界 👠💪🏿"))
      try BasicDatabaseTests.testGetPutRow(collection, key: key, targetValue: "\0\0\0".dataUsingEncoding(NSUTF8StringEncoding)!)
      if let p = NSBundle.mainBundle().executablePath,
        data = NSFileManager.defaultManager().contentsAtPath(p) {
          try BasicDatabaseTests.testGetPutRow(collection, key: key, targetValue: data)
      }
    }
  }

  func testDeleteRange() {
    withTestCollection { db, collection in
      // Generate some test data (1 to 4096 in hex).
      var data = [String: NSData]()
      for i in 1...4096 {
        let key = NSString(format: "%x", i) as String
        let value = key.dataUsingEncoding(NSUTF8StringEncoding)!
        data[key] = value
        try collection.put(key, value: value)
      }

      // Delete single row.
      try collection.deleteRange(RowRangeSingleRow(row: "9"))
      let value: NSData? = try collection.get("9")
      XCTAssertNil(value)

      // Delete a*.
      try collection.deleteRange(RowRangePrefix(prefix: "a"))
      var stream = try collection.scan(RowRangePrefix(prefix: "a"))
      XCTAssertNil(stream.next())

      // Delete b-bc.
      try collection.deleteRange(RowRangeStandard(start: "b", limit: "bc"))
      // Get all the keys including bc and after.
      var keys = Array(data.keys.filter { $0.hasPrefix("b") }).sort()
      let bcIdx = keys.indexOf("bc")!
      keys = Array(keys.dropFirst(bcIdx))
      // Verify that's what's in the db.
      stream = try collection.scan(RowRangePrefix(prefix: "b"))
      for (key, _) in stream {
        let targetKey = keys[0]
        XCTAssertEqual(key, targetKey)
        keys.removeFirst()
      }
      XCTAssertTrue(keys.isEmpty)
      XCTAssertNil(stream.next())
    }
  }

  func testScan() {
    withTestCollection { db, collection in
      // Generate some test data (1 to 200 in hex).
      var data = [String: NSData]()
      for i in 1...200 {
        let key = NSString(format: "%x", i) as String
        let value = key.dataUsingEncoding(NSUTF8StringEncoding)!
        data[key] = value
        try collection.put(key, value: value)
      }

      // Test all rows scan.
      var stream = try collection.scan(RowRangeAll())
      var keys = Array(data.keys).sort() // Lexographic sort
      for (key, getValue) in stream {
        let value = try getValue() as! NSData
        let valueStr = NSString(data: value, encoding: NSUTF8StringEncoding)!
        XCTAssertEqual(key, valueStr)

        let targetKey = keys[0]
        XCTAssertEqual(key, targetKey)
        keys.removeFirst()
      }
      XCTAssertTrue(keys.isEmpty)
      XCTAssertNil(stream.next())

      // Test single row scan.
      stream = try collection.scan(RowRangeSingleRow(row: "a"))
      guard let (key, getValue) = stream.next() else {
        XCTFail()
        return
      }
      XCTAssertEqual(key, "a")
      let value = try getValue() as! NSData
      let valueStr = NSString(data: value, encoding: NSUTF8StringEncoding)!
      XCTAssertEqual(key, valueStr)
      XCTAssertNil(stream.next())
      // Doing it again should be ok.
      XCTAssertNil(stream.next())

      // Test prefix scan.
      stream = try collection.scan(RowRangePrefix(prefix: "8"))
      keys = Array(data.keys.filter { $0.hasPrefix("8") }).sort() // lexographic sort
      for (key, _) in stream {
        let targetKey = keys[0]
        XCTAssertEqual(key, targetKey)
        keys.removeFirst()
      }
      XCTAssertTrue(keys.isEmpty)
      XCTAssertNil(stream.next())
    }
  }

  // MARK: Test batches

  func testBatchCommit() {
    withTestDb { db in
      let batchDb = try db.beginBatch(nil)
      let collection = try batchDb.collection(Identifier(name: "collection2", blessing: anyPermissions))
      try collection.create(anyCollectionPermissions)
      try collection.put("a", value: NSData())
      try collection.put("1", value: NSData())
      try collection.put("2", value: NSData())
      try batchDb.commit()
      do {
        let _: NSData? = try collection.get("a")
        XCTFail("Should have thrown an UnknownBatch exception")
      } catch SyncbaseError.UnknownBatch {
        // Expect this to fail since the batch is already commited -- the collection reference
        // is now invalid.
      } catch {
        XCTFail("Should have thrown an UnknownBatch exception")
      }
      let valueA: NSData? = try db.collection(Identifier(name: "collection2", blessing: anyPermissions)).get("a")
      let value1: NSData? = try db.collection(Identifier(name: "collection2", blessing: anyPermissions)).get("1")
      let value2: NSData? = try db.collection(Identifier(name: "collection2", blessing: anyPermissions)).get("2")
      XCTAssertNotNil(valueA)
      XCTAssertNotNil(value1)
      XCTAssertNotNil(value2)
    }
  }

  func testBatchAbort() {
    withTestDb { db in
      let batchDb = try db.beginBatch(nil)
      let collection = try batchDb.collection(Identifier(name: "collection2", blessing: anyPermissions))
      try collection.create(anyCollectionPermissions)
      try collection.put("b", value: NSData())
      try collection.put("c", value: NSData())
      try batchDb.abort()
      do {
        let _: NSData? = try collection.get("a")
        XCTFail("Should have thrown an UnknownBatch exception")
      } catch SyncbaseError.UnknownBatch {
        // Expect this to fail since the batch is already commited -- the collection reference
        // is now invalid.
      } catch {
        XCTFail("Should have thrown an UnknownBatch exception")
      }
      let valueB: NSData? = try db.collection(Identifier(name: "collection2", blessing: anyPermissions)).get("b")
      let valueC: NSData? = try db.collection(Identifier(name: "collection2", blessing: anyPermissions)).get("c")
      XCTAssertNil(valueB)
      XCTAssertNil(valueC)
    }
  }

  func testRunInBatchAutoCommit() {
    let completed = expectationWithDescription("Completed runInBatch for auto commit")
    withTestDbAsync { (db, cleanup) in
      Batch.runInBatch(
        db: db,
        opts: nil,
        op: { batchDb in
          let collection = try batchDb.collection(Identifier(name: "collection3", blessing: anyPermissions))
          try collection.create(anyCollectionPermissions)
          try collection.put("a", value: NSData())
        },
        completionHandler: { err in
          XCTAssertNil(err)
          do {
            let collection = try db.collection(Identifier(name: "collection3", blessing: anyPermissions))
            let value: NSData? = try collection.get("a")
            XCTAssertNotNil(value)
          } catch let e {
            XCTFail("Unexpected error: \(e)")
          }
          cleanup()
          completed.fulfill()
      })
    }
    waitForExpectationsWithTimeout(2) { XCTAssertNil($0) }

    // Test sync version
    withTestDb { db in
      try Batch.runInBatchSync(db: db, opts: nil) { batchDb in
        let collection = try batchDb.collection(Identifier(name: "collection3", blessing: anyPermissions))
        try collection.create(anyCollectionPermissions)
        try collection.put("b", value: NSData())
      }
      do {
        let collection = try db.collection(Identifier(name: "collection3", blessing: anyPermissions))
        let value: NSData? = try collection.get("b")
        XCTAssertNotNil(value)
      } catch let e {
        XCTFail("Unexpected error: \(e)")
      }
    }
  }

  func testRunInBatchAbort() {
    let completed = expectationWithDescription("Completed runInBatch for abort")
    withTestDbAsync { (db, cleanup) in
      Batch.runInBatch(
        db: db,
        opts: nil,
        op: { batchDb in
          let collection = try batchDb.collection(Identifier(name: "collection4", blessing: anyPermissions))
          try collection.create(anyCollectionPermissions)
          try collection.put("a", value: NSData())
          try batchDb.abort()
        },
        completionHandler: { err in
          XCTAssertNil(err)
          do {
            let collection = try db.collection(Identifier(name: "collection4", blessing: anyPermissions))
            let value: NSData? = try collection.get("a")
            XCTAssertNil(value)
          } catch let e {
            XCTFail("Unexpected error: \(e)")
          }
          cleanup()
          completed.fulfill()
      })
    }
    waitForExpectationsWithTimeout(2) { XCTAssertNil($0) }

    withTestDb { db in
      try Batch.runInBatchSync(db: db, opts: nil) { batchDb in
        let collection = try batchDb.collection(Identifier(name: "collection4", blessing: anyPermissions))
        try collection.create(anyCollectionPermissions)
        try collection.put("a", value: NSData())
        try batchDb.abort()
      }

      do {
        let collection = try db.collection(Identifier(name: "collection4", blessing: anyPermissions))
        let value: NSData? = try collection.get("a")
        XCTAssertNil(value)
      } catch let e {
        XCTFail("Unexpected error: \(e)")
      }
    }
  }

  // MARK: Test watch

  func testWatchTimeout() {
    withTestCollection { (db, collection) in
      try collection.put("a", value: NSData())
      let stream = try db.watch([CollectionRowPattern(
        collectionName: collection.collectionId.name,
        collectionBlessing: collection.collectionId.blessing,
        rowKey: nil)])
      if !self.consumeInitialState(stream) {
        XCTFail("Initial stream died")
      } else {
        XCTAssertNil(stream.next(timeout: 0.1))
        XCTAssertNil(stream.err())
      }
    }
  }

  func testWatchPut() {
    let completed = expectationWithDescription("Completed watch put")
    // Test zero-value and non-zero-valued data. Base64 is just an easy way to pass raw bytes.
    let data = [("a", NSData()),
      ("b", NSData(base64EncodedString: "YXNka2psa2FzamQgZmxrYXNqIGRmbGthag==", options: [])!)]

    withTestDbAsync { (db, cleanup) in
      let collection = try db.collection(Identifier(name: "collectionWatchPut", blessing: anyPermissions))
      try collection.create(anyCollectionPermissions)
      let stream = try db.watch([CollectionRowPattern(
        collectionName: collection.collectionId.name,
        collectionBlessing: collection.collectionId.blessing,
        rowKey: "%")])
      // Skip all the initial changes
      if !self.consumeInitialState(stream) {
        cleanup()
        XCTFail("Initial stream died")
        completed.fulfill()
        return
      }
      dispatch_async(dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0)) {
        // Watch for changes in bg thread.
        for (key, value) in data {
          guard let change = stream.next(timeout: 1) else {
            cleanup()
            XCTFail("Missing put change")
            completed.fulfill()
            return
          }
          XCTAssertNil(stream.err())
          XCTAssertEqual(change.changeType, WatchChange.ChangeType.Put)
          XCTAssertEqual(change.collectionId!.blessing, collection.collectionId.blessing)
          XCTAssertEqual(change.collectionId!.name, collection.collectionId.name)
          XCTAssertFalse(change.isContinued)
          XCTAssertFalse(change.isFromSync)
          XCTAssertGreaterThan(change.resumeMarker!.length, 0)
          XCTAssertEqual(change.row, key)
          XCTAssertEqual(change.value!, value)
        }
        cleanup()
        completed.fulfill()
      }
      // Add data.
      do {
        for (key, value) in data {
          try collection.put(key, value: value)
          XCTAssertTrue(try! collection.exists(key))
        }
      } catch let e {
        XCTFail("Unexpected error: \(e)")
      }
    }
    waitForExpectationsWithTimeout(2) { XCTAssertNil($0) }
  }

  func testWatchDelete() {
    let completed = expectationWithDescription("Completed watch delete")
    // Test zero-value and non-zero-valued data. Base64 is just an easy way to pass raw bytes.
    let data = [("a", NSData()),
      ("b", NSData(base64EncodedString: "YXNka2psa2FzamQgZmxrYXNqIGRmbGthag==", options: [])!)]

    withTestDbAsync { (db, cleanup) in
      let collection = try db.collection(Identifier(name: "collectionWatchDelete", blessing: anyPermissions))
      try collection.create(anyCollectionPermissions)
      for (key, value) in data {
        try collection.put(key, value: value)
      }
      let stream = try db.watch([CollectionRowPattern(
        collectionName: collection.collectionId.name,
        collectionBlessing: collection.collectionId.blessing,
        rowKey: "%")])
      // Skip all the initial changes.
      if !self.consumeInitialState(stream) {
        cleanup()
        XCTFail("Initial stream died")
        completed.fulfill()
        return
      }
      dispatch_async(dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0)) {
        // Watch for put changes.
        for (key, _) in data {
          guard let change = stream.next(timeout: 2) else {
            cleanup()
            if stream.err() == nil {
              XCTFail("Timed out")
            } else {
              XCTFail("Missing delete change before end of stream: \(stream.err())")
            }
            completed.fulfill()
            return
          }
          XCTAssertNil(stream.err())
          XCTAssertEqual(change.changeType, WatchChange.ChangeType.Delete)
          XCTAssertEqual(change.collectionId!.blessing, collection.collectionId.blessing)
          XCTAssertEqual(change.collectionId!.name, collection.collectionId.name)
          XCTAssertFalse(change.isContinued)
          XCTAssertFalse(change.isFromSync)
          XCTAssertGreaterThan(change.resumeMarker!.length, 0)
          XCTAssertEqual(change.row, key)
          XCTAssertNil(change.value)
        }
        cleanup()
        completed.fulfill()
      }

      do {
        // Delete rows.
        for (key, _) in data {
          try collection.delete(key)
        }
      } catch let e {
        XCTFail("Unexpected error: \(e)")
      }
    }
    waitForExpectationsWithTimeout(2) { XCTAssertNil($0) }
  }

  func consumeInitialState(stream: WatchStream) -> Bool {
    // Get all the initial changes.
    while true {
      guard let change = stream.next(timeout: 1) else {
        return false
      }
      if !change.isContinued {
        return true
      }
    }
  }

  func testWatchError() {
    var stream: WatchStream? = nil
    withTestDb { db in
      let collection = try db.collection(Identifier(name: "collectionWatchError", blessing: anyPermissions))
      XCTAssertFalse(try collection.exists())
      try collection.create(anyCollectionPermissions)
      stream = try db.watch([CollectionRowPattern(
        collectionName: collection.collectionId.name,
        collectionBlessing: collection.collectionId.blessing,
        rowKey: nil)])
      // Skip all the initial changes.
      if !self.consumeInitialState(stream!) {
        XCTFail("Initial stream died")
        return
      }
      try collection.destroy()
      let change = stream!.next(timeout: 1)
      XCTAssertNotNil(change)
      XCTAssert(change?.changeType == .Delete)
      XCTAssert(change?.entityType == .Collection)
    }
    let change = stream!.next(timeout: 1)
    XCTAssertNil(change)
    guard let err = stream!.err() else {
      XCTFail("Missing error: \(stream!.err())")
      return
    }
    switch err {
    case SyncbaseError.UnknownVError(let verr):
      XCTAssertTrue(verr.id.hasPrefix("v.io/v23/verror"))
    default:
      XCTFail("Wrong kind of error: \(err)")
    }
  }
}