//
//  Copyright (c) 2019 Open Whisper Systems. All rights reserved.
//

import Foundation
import GRDBCipher

@objc
public class SDSDatabaseStorage: SDSTransactable {

    @objc
    public static var shared: SDSDatabaseStorage {
        return SSKEnvironment.shared.databaseStorage
    }

    static public var shouldLogDBQueries: Bool = true

    private var hasPendingCrossProcessWrite = false

    private let crossProcess = SDSCrossProcess()

    // MARK: - Initialization / Setup

    @objc
    public var yapPrimaryStorage: OWSPrimaryStorage {
        return yapStorage.storage
    }

    lazy var yapStorage = type(of: self).createYapStorage()

    private var _grdbStorage: GRDBDatabaseStorageAdapter?

    @objc
    public var grdbStorage: GRDBDatabaseStorageAdapter {
        if let storage = _grdbStorage {
            return storage
        } else {
            let storage = createGrdbStorage()
            _grdbStorage = storage
            return storage
        }
    }

    @objc
    internal func clearGRDBStorageForTests() {
        _grdbStorage = nil
    }

    @objc
    override init() {
        super.init()

        addObservers()
    }

    private func addObservers() {
        // Cross process writes
        if useGRDB {
            crossProcess.callback = { [weak self] in
                DispatchQueue.main.async {
                    self?.handleCrossProcessWrite()
                }
            }

            NotificationCenter.default.addObserver(self,
                                                   selector: #selector(didBecomeActive),
                                                   name: UIApplication.didBecomeActiveNotification,
                                                   object: nil)
        }
    }

    deinit {
        Logger.verbose("")

        NotificationCenter.default.removeObserver(self)
    }

    func createGrdbStorage() -> GRDBDatabaseStorageAdapter {
        assert(self.useGRDB)

        let baseDir: URL

        if FeatureFlags.grdbMigratesFreshDBEveryLaunch {
            baseDir = URL(fileURLWithPath: OWSFileSystem.appSharedDataDirectoryPath(), isDirectory: true).appendingPathComponent(UUID().uuidString, isDirectory: true)
        } else {
            baseDir = URL(fileURLWithPath: OWSFileSystem.appSharedDataDirectoryPath(), isDirectory: true)
        }
        let dbDir: URL = baseDir.appendingPathComponent("grdb_database", isDirectory: true)

        // crash if we can't read the DB.
        return try! GRDBDatabaseStorageAdapter(dbDir: dbDir)
    }

    class func createYapStorage() -> YAPDBStorageAdapter {
        let yapPrimaryStorage = OWSPrimaryStorage.init(storage: ())
        return YAPDBStorageAdapter(storage: yapPrimaryStorage)
    }

    // MARK: -

    var useGRDB: Bool = FeatureFlags.useGRDB

    @objc
    public func newDatabaseQueue() -> SDSAnyDatabaseQueue {
        if useGRDB {
            return grdbStorage.newDatabaseQueue().asAnyQueue(crossProcess: crossProcess)
        } else {
            return yapStorage.newDatabaseQueue().asAnyQueue(crossProcess: crossProcess)
        }
    }

    // GRDB TODO: add read/write flavors
    public func uiReadThrows(block: @escaping (SDSAnyReadTransaction) throws -> Void) throws {
        if useGRDB {
            try grdbStorage.uiReadThrows { transaction in
                try autoreleasepool {
                    try block(transaction.asAnyRead)
                }
            }
        } else {
            try yapStorage.uiReadThrows { transaction in
                try block(transaction.asAnyRead)
            }
        }
    }

    @objc
    public func uiRead(block: @escaping (SDSAnyReadTransaction) -> Void) {
        if useGRDB {
            do {
                try grdbStorage.uiRead { transaction in
                    block(transaction.asAnyRead)
                }
            } catch {
                owsFail("error: \(error)")
            }
        } else {
            yapStorage.uiRead { transaction in
                block(transaction.asAnyRead)
            }
        }
    }

    @objc
    public override func read(block: @escaping (SDSAnyReadTransaction) -> Void) {
        if useGRDB {
            do {
                try grdbStorage.read { transaction in
                    block(transaction.asAnyRead)
                }
            } catch {
                owsFail("error: \(error)")
            }
        } else {
            yapStorage.read { transaction in
                block(transaction.asAnyRead)
            }
        }
    }

    @objc
    public override func write(block: @escaping (SDSAnyWriteTransaction) -> Void) {
        if useGRDB {
            do {
                try grdbStorage.write { transaction in
                    Bench(title: "Slow Write Transaction", logIfLongerThan: 0.1) {
                        block(transaction.asAnyWrite)
                    }
                }
            } catch {
                owsFail("error: \(error)")
            }
        } else {
            yapStorage.write { transaction in
                Bench(title: "Slow Write Transaction", logIfLongerThan: 0.1) {
                    block(transaction.asAnyWrite)
                }
            }
        }
        crossProcess.notifyChangedAsync()
    }

    // MARK: - Value Methods

    public func uiReadReturningResult<T>(block: @escaping (SDSAnyReadTransaction) -> T) -> T {
        var value: T!
        uiRead { (transaction) in
            value = block(transaction)
        }
        return value
    }

    public func readReturningResult<T>(block: @escaping (SDSAnyReadTransaction) -> T) -> T {
        var value: T!
        read { (transaction) in
            value = block(transaction)
        }
        return value
    }

    public func writeReturningResult<T>(block: @escaping (SDSAnyWriteTransaction) -> T) -> T {
        var value: T!
        write { (transaction) in
            value = block(transaction)
        }
        return value
    }

    // MARK: - Touch

    @objc(touchInteraction:transaction:)
    public func touch(interaction: TSInteraction, transaction: SDSAnyWriteTransaction) {
        switch transaction.writeTransaction {
        case .yapWrite(let yap):
            let uniqueId = interaction.uniqueId
            yap.touchObject(forKey: uniqueId, inCollection: TSInteraction.collection())
        case .grdbWrite(let grdb):
            guard let conversationViewDatabaseObserver = grdbStorage.conversationViewDatabaseObserver else {
                if AppReadiness.isAppReady() {
                    owsFailDebug("conversationViewDatabaseObserver was unexpectedly nil")
                }
                return
            }
            conversationViewDatabaseObserver.touch(interaction: interaction, transaction: grdb)
        }
    }

    @objc(touchThread:transaction:)
    public func touch(thread: TSThread, transaction: SDSAnyWriteTransaction) {
        switch transaction.writeTransaction {
        case .yapWrite(let yap):
            let uniqueId = thread.uniqueId
            yap.touchObject(forKey: uniqueId, inCollection: TSThread.collection())
        case .grdbWrite(let grdb):
            guard let homeViewDatabaseObserver = grdbStorage.homeViewDatabaseObserver else {
                if AppReadiness.isAppReady() {
                    owsFailDebug("homeViewDatabaseObserver was unexpectedly nil")
                }
                return
            }
            homeViewDatabaseObserver.touch(thread: thread, transaction: grdb)
        }
    }

    @objc(touchThreadId:transaction:)
    public func touch(threadId: String, transaction: SDSAnyWriteTransaction) {
        switch transaction.writeTransaction {
        case .yapWrite(let yap):
            yap.touchObject(forKey: threadId, inCollection: TSThread.collection())
        case .grdbWrite(let grdb):
            guard let homeViewDatabaseObserver = grdbStorage.homeViewDatabaseObserver else {
                if AppReadiness.isAppReady() {
                    owsFailDebug("homeViewDatabaseObserver was unexpectedly nil")
                }
                return
            }
            homeViewDatabaseObserver.touch(threadId: threadId, transaction: grdb)
        }
    }

    // MARK: - Cross Process Notifications

    private func handleCrossProcessWrite() {
        AssertIsOnMainThread()

        Logger.info("")

        guard CurrentAppContext().isMainApp else {
            return
        }

        //
        if CurrentAppContext().isMainAppAndActive {
            // If already active, update immediately.
            postCrossProcessNotification()
        } else {
            // If not active, set flag to update when we become active.
            hasPendingCrossProcessWrite = true
        }
    }

    @objc func didBecomeActive() {
        AssertIsOnMainThread()

        guard hasPendingCrossProcessWrite else {
            return
        }
        hasPendingCrossProcessWrite = false

        postCrossProcessNotification()
    }

    @objc
    public static let didReceiveCrossProcessNotification = Notification.Name("didReceiveCrossProcessNotification")

    private func postCrossProcessNotification() {
        Logger.info("")

        // TODO: The observers of this notification will inevitably do
        //       expensive work.  It'd be nice to only fire this event
        //       if this had any effect, if the state of the database
        //       has changed.
        //
        //       In the meantime, most (all?) cross process write notifications
        //       will be delivered to the main app while it is inactive. By
        //       de-bouncing notifications while inactive and only updating
        //       once when we become active, we should be able to effectively
        //       skip most of the perf cost.
        NotificationCenter.default.postNotificationNameAsync(SDSDatabaseStorage.didReceiveCrossProcessNotification, object: nil)
    }

    // MARK: - Misc.

    @objc
    public func logFileSizes() {
        Logger.info("Database : \(databaseFileSize)")
        Logger.info("\t WAL file size: \(databaseWALFileSize)")
        Logger.info("\t SHM file size: \(databaseSHMFileSize)")
    }
}

// MARK: -

protocol SDSDatabaseStorageAdapter {
    associatedtype ReadTransaction
    associatedtype WriteTransaction
    func uiRead(block: @escaping (ReadTransaction) -> Void) throws
    func read(block: @escaping (ReadTransaction) -> Void) throws
    func write(block: @escaping (WriteTransaction) -> Void) throws
}

// MARK: -

struct YAPDBStorageAdapter {
    let storage: OWSPrimaryStorage
}

// MARK: -

extension YAPDBStorageAdapter: SDSDatabaseStorageAdapter {
    func uiReadThrows(block: @escaping (YapDatabaseReadTransaction) throws -> Void) throws {
        var errorToRaise: Error?
        storage.uiDatabaseConnection.read { yapTransaction in
            do {
                try block(yapTransaction)
            } catch {
                errorToRaise = error
            }
        }
        if let error = errorToRaise {
            throw error
        }
    }

    func uiRead(block: @escaping (YapDatabaseReadTransaction) -> Void) {
        storage.uiDatabaseConnection.read { yapTransaction in
            block(yapTransaction)
        }
    }

    func read(block: @escaping (YapDatabaseReadTransaction) -> Void) {
        storage.dbReadConnection.read { yapTransaction in
            block(yapTransaction)
        }
    }

    func write(block: @escaping (YapDatabaseReadWriteTransaction) -> Void) {
        storage.dbReadWriteConnection.readWrite { yapTransaction in
            block(yapTransaction)
        }
    }

    func newDatabaseQueue() -> YAPDBDatabaseQueue {
        return YAPDBDatabaseQueue(databaseConnection: storage.newDatabaseConnection())
    }
}

// MARK: -

@objc
public class GRDBDatabaseStorageAdapter: NSObject {

    private let dbURL: URL

    private let keyServiceName: String = "TSKeyChainService"
    private let keyName: String = "OWSDatabaseCipherKeySpec"

    private let storage: GRDBStorage

    public var pool: DatabasePool {
        return storage.pool
    }

    init(dbDir: URL) throws {
        OWSFileSystem.ensureDirectoryExists(dbDir.path)

        dbURL = dbDir.appendingPathComponent("signal.sqlite", isDirectory: false)
        storage = try GRDBStorage(dbURL: dbURL, keyServiceName: keyServiceName, keyName: keyName)

        super.init()

        // Schema migrations are currently simple and fast. If they grow to become long-running,
        // we'll want to ensure that it doesn't block app launch to avoid 0x8badfood.
        try migrator.migrate(pool)

        AppReadiness.runNowOrWhenAppWillBecomeReady {
            BenchEventStart(title: "GRDB Setup", eventId: "GRDB Setup")
            defer { BenchEventComplete(eventId: "GRDB Setup") }
            do {
                try self.setup()
                try self.setupUIDatabase()
            } catch {
                owsFail("unable to setup database: \(error)")
            }
        }
    }

    func newDatabaseQueue() -> GRDBDatabaseQueue {
        return GRDBDatabaseQueue(storageAdapter: self)
    }

    public func add(function: DatabaseFunction) {
        pool.add(function: function)
    }

    lazy var migrator: DatabaseMigrator = {
        var migrator = DatabaseMigrator()
        migrator.registerMigration("create initial schema") { db in
            try SDSKeyValueStore.table.createTable(database: db)

            try TSThreadSerializer.table.createTable(database: db)
            try TSInteractionSerializer.table.createTable(database: db)
            try StickerPackSerializer.table.createTable(database: db)
            try InstalledStickerSerializer.table.createTable(database: db)
            try KnownStickerPackSerializer.table.createTable(database: db)
            try TSAttachmentSerializer.table.createTable(database: db)
            try SSKJobRecordSerializer.table.createTable(database: db)
            try OWSMessageContentJobSerializer.table.createTable(database: db)
            try OWSRecipientIdentitySerializer.table.createTable(database: db)
            try ExperienceUpgradeSerializer.table.createTable(database: db)
            try OWSDisappearingMessagesConfigurationSerializer.table.createTable(database: db)
            try SignalRecipientSerializer.table.createTable(database: db)
            try SignalAccountSerializer.table.createTable(database: db)
            try OWSUserProfileSerializer.table.createTable(database: db)
            try TSRecipientReadReceiptSerializer.table.createTable(database: db)
            try OWSLinkedDeviceReadReceiptSerializer.table.createTable(database: db)
            try OWSDeviceSerializer.table.createTable(database: db)
            try OWSContactQuerySerializer.table.createTable(database: db)

            try db.create(index: "index_interactions_on_id_and_threadUniqueId",
                          on: InteractionRecord.databaseTableName,
                          columns: [
                            InteractionRecord.columnName(.id),
                            InteractionRecord.columnName(.threadUniqueId)
                ])
            try db.create(index: "index_interactions_on_id_and_timestamp",
                          on: InteractionRecord.databaseTableName,
                          columns: [
                            InteractionRecord.columnName(.id),
                            InteractionRecord.columnName(.timestamp)
                ])
            try db.create(index: "index_jobs_on_label",
                          on: JobRecordRecord.databaseTableName,
                          columns: [JobRecordRecord.columnName(.label)])
            try db.create(index: "index_interactions_on_view_once",
                          on: InteractionRecord.databaseTableName,
                          columns: [
                            InteractionRecord.columnName(.isViewOnceMessage),
                            InteractionRecord.columnName(.isViewOnceComplete)
                ])
            try db.create(index: "index_key_value_store_on_collection_and_key",
                          on: SDSKeyValueStore.table.tableName,
                          columns: [
                            SDSKeyValueStore.collectionColumn.columnName,
                            SDSKeyValueStore.keyColumn.columnName
                ])

            // Media Gallery Indices
            try db.create(index: "index_attachments_on_albumMessageId",
                          on: AttachmentRecord.databaseTableName,
                          columns: [AttachmentRecord.columnName(.albumMessageId),
                                    AttachmentRecord.columnName(.recordType)])

            try db.create(index: "index_interactions_on_uniqueId_and_threadUniqueId",
                          on: InteractionRecord.databaseTableName,
                          columns: [
                            InteractionRecord.columnName(.uniqueId),
                            InteractionRecord.columnName(.threadUniqueId)
                ])

            // Signal Account Indices
            try db.create(
                index: "index_signal_accounts_on_recipientPhoneNumber",
                on: SignalAccountRecord.databaseTableName,
                columns: [SignalAccountRecord.columnName(.recipientPhoneNumber)]
            )

            try db.create(
                index: "index_signal_accounts_on_recipientUUID",
                on: SignalAccountRecord.databaseTableName,
                columns: [SignalAccountRecord.columnName(.recipientUUID)]
            )

            // Signal Recipient Indices
            try db.create(
                index: "index_signal_recipients_on_recipientPhoneNumber",
                on: SignalRecipientRecord.databaseTableName,
                columns: [SignalRecipientRecord.columnName(.recipientPhoneNumber)]
            )

            try db.create(
                index: "index_signal_recipients_on_recipientUUID",
                on: SignalRecipientRecord.databaseTableName,
                columns: [SignalRecipientRecord.columnName(.recipientUUID)]
            )

            // Thread Indices
            try db.create(
                index: "index_thread_on_contactPhoneNumber",
                on: ThreadRecord.databaseTableName,
                columns: [ThreadRecord.columnName(.contactPhoneNumber)]
            )

            try db.create(
                index: "index_tsthread_on_contactUUID",
                on: ThreadRecord.databaseTableName,
                columns: [ThreadRecord.columnName(.contactUUID)]
            )

            // User Profile
            try db.create(
                index: "index_user_profiles_on_recipientPhoneNumber",
                on: UserProfileRecord.databaseTableName,
                columns: [UserProfileRecord.columnName(.recipientPhoneNumber)]
            )

            try db.create(
                index: "index_user_profiles_on_recipientUUID",
                on: UserProfileRecord.databaseTableName,
                columns: [UserProfileRecord.columnName(.recipientUUID)]
            )

            // Linked Device Read Receipts
            try db.create(
                index: "index_linkedDeviceReadReceipt_on_senderPhoneNumberAndTimestamp",
                on: LinkedDeviceReadReceiptRecord.databaseTableName,
                columns: [LinkedDeviceReadReceiptRecord.columnName(.senderPhoneNumber), LinkedDeviceReadReceiptRecord.columnName(.messageIdTimestamp)]
            )

            try db.create(
                index: "index_linkedDeviceReadReceipt_on_senderUUIDAndTimestamp",
                on: LinkedDeviceReadReceiptRecord.databaseTableName,
                columns: [LinkedDeviceReadReceiptRecord.columnName(.senderUUID), LinkedDeviceReadReceiptRecord.columnName(.messageIdTimestamp)]
            )

            // Interaction Finder
            try db.create(index: "index_interactions_on_timestamp_sourceDeviceId_and_authorUUID",
                          on: InteractionRecord.databaseTableName,
                          columns: [
                            InteractionRecord.columnName(.timestamp),
                            InteractionRecord.columnName(.sourceDeviceId),
                            InteractionRecord.columnName(.authorUUID)
                ])

            try db.create(index: "index_interactions_on_timestamp_sourceDeviceId_and_authorPhoneNumber",
                          on: InteractionRecord.databaseTableName,
                          columns: [
                            InteractionRecord.columnName(.timestamp),
                            InteractionRecord.columnName(.sourceDeviceId),
                            InteractionRecord.columnName(.authorPhoneNumber)
                ])
            try db.create(index: "index_interactions_on_threadUniqueId_and_read",
                          on: InteractionRecord.databaseTableName,
                          columns: [
                            InteractionRecord.columnName(.threadUniqueId),
                            InteractionRecord.columnName(.read)
                ])

            // ContactQuery
            try db.create(index: "index_contact_queries_on_lastQueried",
                          on: ContactQueryRecord.databaseTableName,
                          columns: [
                            ContactQueryRecord.columnName(.lastQueried)
                ])

            try GRDBFullTextSearchFinder.createTables(database: db)
        }
        return migrator
    }()

    // MARK: - Database Snapshot

    private var latestSnapshot: DatabaseSnapshot! {
        return uiDatabaseObserver!.latestSnapshot
    }

    @objc
    public private(set) var uiDatabaseObserver: UIDatabaseObserver?

    @objc
    public private(set) var homeViewDatabaseObserver: HomeViewDatabaseObserver?

    @objc
    public private(set) var conversationViewDatabaseObserver: ConversationViewDatabaseObserver?

    @objc
    public private(set) var mediaGalleryDatabaseObserver: MediaGalleryDatabaseObserver?

    @objc
    public func setupUIDatabase() throws {
        // UIDatabaseObserver is a general purpose observer, whose delegates
        // are notified when things change, but are not given any specific details
        // about the changes.
        let uiDatabaseObserver = try UIDatabaseObserver(pool: pool)
        self.uiDatabaseObserver = uiDatabaseObserver

        // HomeViewDatabaseObserver is built on top of UIDatabaseObserver
        // but includes the details necessary for rendering collection view
        // batch updates.
        let homeViewDatabaseObserver = HomeViewDatabaseObserver()
        self.homeViewDatabaseObserver = homeViewDatabaseObserver
        uiDatabaseObserver.appendSnapshotDelegate(homeViewDatabaseObserver)

        // ConversationViewDatabaseObserver is built on top of UIDatabaseObserver
        // but includes the details necessary for rendering collection view
        // batch updates.
        let conversationViewDatabaseObserver = ConversationViewDatabaseObserver()
        self.conversationViewDatabaseObserver = conversationViewDatabaseObserver
        uiDatabaseObserver.appendSnapshotDelegate(conversationViewDatabaseObserver)

        // MediaGalleryDatabaseObserver is built on top of UIDatabaseObserver
        // but includes the details necessary for rendering collection view
        // batch updates.
        let mediaGalleryDatabaseObserver = MediaGalleryDatabaseObserver()
        self.mediaGalleryDatabaseObserver = mediaGalleryDatabaseObserver
        uiDatabaseObserver.appendSnapshotDelegate(mediaGalleryDatabaseObserver)

        return try pool.write { db in
            db.add(transactionObserver: homeViewDatabaseObserver, extent: Database.TransactionObservationExtent.observerLifetime)
            db.add(transactionObserver: conversationViewDatabaseObserver, extent: Database.TransactionObservationExtent.observerLifetime)
            db.add(transactionObserver: mediaGalleryDatabaseObserver, extent: Database.TransactionObservationExtent.observerLifetime)
        }
    }

    func testing_tearDownUIDatabase() {
        // UIDatabaseObserver is a general purpose observer, whose delegates
        // are notified when things change, but are not given any specific details
        // about the changes.
        self.uiDatabaseObserver = nil
        self.homeViewDatabaseObserver = nil
        self.conversationViewDatabaseObserver = nil
        self.mediaGalleryDatabaseObserver = nil
    }

    func setup() throws {
        GRDBMediaGalleryFinder.setup(storage: self)
    }
}

// MARK: -

extension GRDBDatabaseStorageAdapter: SDSDatabaseStorageAdapter {

    // TODO readThrows/writeThrows flavors
    public func uiReadThrows(block: @escaping (GRDBReadTransaction) throws -> Void) rethrows {
        AssertIsOnMainThread()
        try latestSnapshot.read { database in
            try autoreleasepool {
                try block(GRDBReadTransaction(database: database))
            }
        }
    }

    public func readReturningResultThrows<T>(block: @escaping (GRDBReadTransaction) throws -> T) throws -> T {
        AssertIsOnMainThread()
        return try pool.read { database in
            try autoreleasepool {
                return try block(GRDBReadTransaction(database: database))
            }
        }
    }

    @objc
    public func uiRead(block: @escaping (GRDBReadTransaction) -> Void) throws {
        AssertIsOnMainThread()
        latestSnapshot.read { database in
            autoreleasepool {
                block(GRDBReadTransaction(database: database))
            }
        }
    }

    @objc
    public func read(block: @escaping (GRDBReadTransaction) -> Void) throws {
        try pool.read { database in
            autoreleasepool {
                block(GRDBReadTransaction(database: database))
            }
        }
    }

    @objc
    public func write(block: @escaping (GRDBWriteTransaction) -> Void) throws {
        var transaction: GRDBWriteTransaction!
        try pool.write { database in
            autoreleasepool {
                transaction = GRDBWriteTransaction(database: database)
                block(transaction)
            }
        }
        for (queue, block) in transaction.completions {
            queue.async(execute: block)
        }
    }
}

// MARK: -

@objc
public extension SDSDatabaseStorage {

    func asyncUIRead(block: @escaping (SDSAnyReadTransaction) -> Void) {
        asyncUIRead(block: block, completion: { })
    }

    func asyncUIRead(block: @escaping (SDSAnyReadTransaction) -> Void, completion: @escaping () -> Void) {
        asyncUIRead(block: block, completionQueue: .main, completion: completion)
    }

    func asyncUIRead(block: @escaping (SDSAnyReadTransaction) -> Void, completionQueue: DispatchQueue, completion: @escaping () -> Void) {
        DispatchQueue.global().async {
            self.uiRead(block: block)

            completionQueue.async(execute: completion)
        }
    }
}

// MARK: -

private struct GRDBStorage {

    let pool: DatabasePool

    private let dbURL: URL
    private let configuration: Configuration

    init(dbURL: URL, keyServiceName: String, keyName: String) throws {
        self.dbURL = dbURL
        let keyspec = GRDBKeySpecSource(keyServiceName: keyServiceName, keyName: keyName)

        var configuration = Configuration()
        configuration.readonly = false
        configuration.foreignKeysEnabled = true // Default is already true
        configuration.trace = {
            if SDSDatabaseStorage.shouldLogDBQueries {
                print($0)  // Prints all SQL statements
            }
        }
        configuration.label = "Modern (GRDB) Storage"      // Useful when your app opens multiple databases
        configuration.maximumReaderCount = 10   // The default is 5
        configuration.busyMode = .callback({ (retryCount: Int) -> Bool in
            // sleep 50 milliseconds
            let millis = 50
            usleep(useconds_t(millis * 1000))

            Logger.verbose("retryCount: \(retryCount)")
            let accumulatedWait = millis * (retryCount + 1)
            if accumulatedWait > 0, (accumulatedWait % 250) == 0 {
                Logger.warn("Database busy for \(accumulatedWait)ms")
            }

            return true
        })
        configuration.passphraseBlock = { try keyspec.fetchString() }
        configuration.prepareDatabase = { (db: Database) in
            try db.execute(sql: "PRAGMA cipher_plaintext_header_size = 32")
        }
        self.configuration = configuration

        pool = try DatabasePool(path: dbURL.path, configuration: configuration)
        Logger.debug("dbURL: \(dbURL)")

        OWSFileSystem.protectFileOrFolder(atPath: dbURL.path)
    }
}

// MARK: -

private struct GRDBKeySpecSource {
    let keyServiceName: String
    let keyName: String

    func fetchString() throws -> String {
        // Use a raw key spec, where the 96 hexadecimal digits are provided
        // (i.e. 64 hex for the 256 bit key, followed by 32 hex for the 128 bit salt)
        // using explicit BLOB syntax, e.g.:
        //
        // x'98483C6EB40B6C31A448C22A66DED3B5E5E8D5119CAC8327B655C8B5C483648101010101010101010101010101010101'
        let data = try fetchData()

        // 256 bit key + 128 bit salt
        guard data.count == 48 else {
            // crash
            owsFail("unexpected keyspec length")
        }

        let passphrase = "x'\(data.hexadecimalString)'"
        return passphrase
    }

    func fetchData() throws -> Data {
        return try CurrentAppContext().keychainStorage().data(forService: keyServiceName, key: keyName)
    }
}

// MARK: -

@objc
public extension SDSDatabaseStorage {
    var databaseFileSize: UInt64 {
        if useGRDB {
            return grdbStorage.databaseFileSize
        } else {
            return OWSPrimaryStorage.shared().databaseFileSize()
        }
    }

    var databaseWALFileSize: UInt64 {
        if useGRDB {
            return grdbStorage.databaseWALFileSize
        } else {
            return OWSPrimaryStorage.shared().databaseWALFileSize()
        }
    }

    var databaseSHMFileSize: UInt64 {
        if useGRDB {
            return grdbStorage.databaseSHMFileSize
        } else {
            return OWSPrimaryStorage.shared().databaseSHMFileSize()
        }
    }
}

// MARK: -

extension GRDBDatabaseStorageAdapter {
    var databaseFileSize: UInt64 {
        guard let fileSize = OWSFileSystem.fileSize(of: dbURL) else {
            owsFailDebug("Could not determine file size.")
            return 0
        }
        return fileSize.uint64Value
    }

    var databaseWALFileSize: UInt64 {
        guard let fileSize = OWSFileSystem.fileSize(ofPath: dbURL.path + "-shm") else {
            owsFailDebug("Could not determine file size.")
            return 0
        }
        return fileSize.uint64Value
    }

    var databaseSHMFileSize: UInt64 {
        guard let fileSize = OWSFileSystem.fileSize(ofPath: dbURL.path + "-wal") else {
            owsFailDebug("Could not determine file size.")
            return 0
        }
        return fileSize.uint64Value
    }
}