//
//  AdvancedReOrgTests.swift
//  ZcashLightClientKit-Unit-Tests
//
//  Created by Francisco Gindre on 5/14/20.
//

import Combine
import XCTest
@testable import TestUtils
@testable import ZcashLightClientKit

class AdvancedReOrgTests: ZcashTestCase {
    let sendAmount = Zatoshi(1000)
    var birthday: BlockHeight = 663150
    let defaultLatestHeight: BlockHeight = 663175
    var coordinator: TestCoordinator!
    var syncedExpectation = XCTestExpectation(description: "synced")
    var sentTransactionExpectation = XCTestExpectation(description: "sent")
    var expectedReorgHeight: BlockHeight = 665188
    var expectedRewindHeight: BlockHeight = 665188
    var reorgExpectation = XCTestExpectation(description: "reorg")
    let branchID = "2bb40e60"
    let chainName = "main"
    let network = DarksideWalletDNetwork()
    var cancellables: [AnyCancellable] = []

    override func setUp() async throws {
        try await super.setUp()
        // don't use an exact birthday, users never do.
        self.coordinator = try await TestCoordinator(
            container: mockContainer,
            walletBirthday: birthday + 50,
            network: network
        )
        try coordinator.reset(saplingActivation: 663150, branchID: self.branchID, chainName: self.chainName)
    }

    override func tearDown() async throws {
        try await super.tearDown()
        let coordinator = self.coordinator!
        self.coordinator = nil
        cancellables = []

        try await coordinator.stop()
        try? FileManager.default.removeItem(at: coordinator.databases.fsCacheDbRoot)
        try? FileManager.default.removeItem(at: coordinator.databases.dataDB)
    }
    
    func handleReorg(event: CompactBlockProcessor.Event) {
        guard case let .handledReorg(reorgHeight, rewindHeight) = event else { return XCTFail("empty reorg event") }

        logger.debug("--- REORG DETECTED \(reorgHeight)--- RewindHeight: \(rewindHeight)", file: #file, function: #function, line: #line)

        XCTAssertEqual(reorgHeight, expectedReorgHeight)
        reorgExpectation.fulfill()
    }
    
    /// pre-condition: know balances before tx at received_Tx_height arrives
    /// 1. Setup w/ default dataset
    /// 2. applyStaged(received_Tx_height)
    /// 3. sync up to received_Tx_height
    /// 3a. verify that balance is previous balance + tx amount
    /// 4. get that transaction hex encoded data
    /// 5. stage 5 empty blocks w/heights received_Tx_height to received_Tx_height + 3
    /// 6. stage tx at received_Tx_height + 3
    /// 6a. applyheight(received_Tx_height + 1)
    /// 7. sync to received_Tx_height + 1
    /// 8. assert that reorg happened at received_Tx_height
    /// 9. verify that balance equals initial balance
    /// 10. sync up to received_Tx_height + 3
    /// 11. verify that balance equals initial balance + tx amount
    func testReOrgChangesInboundTxMinedHeight() async throws {
        await hookToReOrgNotification()
        try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
        var shouldContinue = false
        let receivedTxHeight: BlockHeight = 663188
        var initialTotalBalance = Zatoshi(-1)
        var initialVerifiedBalance = Zatoshi(-1)
        self.expectedReorgHeight = receivedTxHeight + 1
        
        /*
        precondition:know balances before tx at received_Tx_height arrives
        */
        try coordinator.applyStaged(blockheight: receivedTxHeight - 1)
        sleep(3)
        let preTxExpectation = XCTestExpectation(description: "pre receive")
        
        var synchronizer: SDKSynchronizer?
        
        do {
            try await coordinator.sync(
                completion: { synchro in
                    synchronizer = synchro
                    initialVerifiedBalance = try await synchro.getShieldedVerifiedBalance()
                    initialTotalBalance = try await synchro.getShieldedBalance()
                    preTxExpectation.fulfill()
                    shouldContinue = true
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }
        
        await fulfillment(of: [preTxExpectation], timeout: 10)
        
        guard shouldContinue else {
            XCTFail("pre receive sync failed")
            return
        }
        
        /*
        2. applyStaged(received_Tx_height)
        */
        try coordinator.applyStaged(blockheight: receivedTxHeight)
        sleep(2)
        
        /*
        3. sync up to received_Tx_height
        */
        let receivedTxExpectation = XCTestExpectation(description: "received tx")
        var receivedTxTotalBalance = Zatoshi(-1)
        var receivedTxVerifiedBalance = Zatoshi(-1)
        
        do {
            try await coordinator.sync(
                completion: { synchro in
                    synchronizer = synchro
                    receivedTxVerifiedBalance = try await synchro.getShieldedVerifiedBalance()
                    receivedTxTotalBalance = try await synchro.getShieldedBalance()
                    receivedTxExpectation.fulfill()
                }, error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        sleep(2)
        await fulfillment(of: [receivedTxExpectation], timeout: 10)
        
        guard let syncedSynchronizer = synchronizer else {
            XCTFail("nil synchronizer")
            return
        }
        sleep(5)
        guard let receivedTx = await syncedSynchronizer.receivedTransactions.first, receivedTx.minedHeight == receivedTxHeight else {
            XCTFail("did not receive transaction")
            return
        }
        
        /*
        3a. verify that balance is previous balance + tx amount
        */
        XCTAssertEqual(receivedTxTotalBalance, initialTotalBalance + receivedTx.value)
        XCTAssertEqual(receivedTxVerifiedBalance, initialVerifiedBalance)

        /*
        4. get that transaction hex encoded data
        */
        let receivedTxData = receivedTx.raw ?? Data()
        
        let receivedRawTx = RawTransaction.with { rawTx in
            rawTx.height = UInt64(receivedTxHeight)
            rawTx.data = receivedTxData
        }
        
        /*
        5. stage 5 empty blocks w/heights received_Tx_height to received_Tx_height + 4
        */
        try coordinator.stageBlockCreate(height: receivedTxHeight, count: 5)
        
        /*
        6. stage tx at received_Tx_height + 3
        */
        let reorgedTxheight = receivedTxHeight + 2
        try coordinator.stageTransaction(receivedRawTx, at: reorgedTxheight)
        
        /*
        6a. applyheight(received_Tx_height + 1)
        */
        try coordinator.applyStaged(blockheight: receivedTxHeight + 1)
        
        sleep(2)

        /*
        7. sync to received_Tx_height + 1
        */
        let reorgSyncexpectation = XCTestExpectation(description: "reorg expectation")
        
        var afterReorgTxTotalBalance = Zatoshi(-1)
        var afterReorgTxVerifiedBalance = Zatoshi(-1)
        
        do {
            try await coordinator.sync(
                completion: { synchronizer in
                    afterReorgTxTotalBalance = try await synchronizer.getShieldedBalance()
                    afterReorgTxVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
                    reorgSyncexpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        /*
        8. assert that reorg happened at received_Tx_height
        */
        sleep(2)
        await fulfillment(of: [reorgExpectation, reorgSyncexpectation], timeout: 5, enforceOrder: false)

        /*
        9. verify that balance equals initial balance
        */
        XCTAssertEqual(afterReorgTxVerifiedBalance, initialVerifiedBalance)
        XCTAssertEqual(afterReorgTxTotalBalance, initialTotalBalance)
        
        /*
        10. sync up to received_Tx_height + 3
        */
        let finalsyncExpectation = XCTestExpectation(description: "final sync")
        
        var finalReorgTxTotalBalance = Zatoshi(-1)
        var finalReorgTxVerifiedBalance = Zatoshi(-1)
        
        try coordinator.applyStaged(blockheight: reorgedTxheight + 1)
        sleep(3)
        
        do {
            try await coordinator.sync(
                completion: { synchronizer in
                    finalReorgTxTotalBalance = try await synchronizer.getShieldedBalance()
                    finalReorgTxVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
                    finalsyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [finalsyncExpectation], timeout: 5)
        sleep(3)
        
        guard let reorgedTx = await coordinator.synchronizer.receivedTransactions.first else {
            XCTFail("no transactions found")
            return
        }
        
        XCTAssertEqual(reorgedTx.minedHeight, reorgedTxheight)
        XCTAssertEqual(initialVerifiedBalance, finalReorgTxVerifiedBalance)
        XCTAssertEqual(initialTotalBalance + receivedTx.value, finalReorgTxTotalBalance)
    }
    
    /// An outbound, unconfirmed transaction in a specific block changes height in the event of a reorg
    ///
    ///
    /// The wallet handles this change, reflects it appropriately in local storage, and funds remain spendable post confirmation.
    ///
    /// Pre-conditions:
    /// - Wallet has spendable funds
    ///
    /// 1. Setup w/ default dataset
    /// 2. applyStaged(received_Tx_height)
    /// 3. sync up to received_Tx_height
    /// 4. create transaction
    /// 5. stage 10 empty blocks
    /// 6. submit tx at sentTxHeight
    ///   a. getIncomingTx
    ///   b. stageTransaction(sentTx, sentTxHeight)
    ///   c. applyheight(sentTxHeight + 1 )
    /// 7. sync to  sentTxHeight + 2
    /// 8. stage sentTx and otherTx at sentTxheight
    /// 9. applyStaged(sentTx + 2)
    /// 10. sync up to received_Tx_height + 2
    /// 11. verify that the sent tx is mined and balance is correct
    /// 12. applyStaged(sentTx + 10)
    /// 13. verify that there's no more pending transaction
    func testReorgChangesOutboundTxIndex() async throws {
        try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName)
        let receivedTxHeight: BlockHeight = 663188
        var initialTotalBalance = Zatoshi(-1)
        
        /*
        2. applyStaged(received_Tx_height)
        */
        try coordinator.applyStaged(blockheight: receivedTxHeight)
        
        sleep(2)
        let preTxExpectation = XCTestExpectation(description: "pre receive")

        /*
        3. sync up to received_Tx_height
        */
        do {
            try await coordinator.sync(
                completion: { synchronizer in
                    initialTotalBalance = try await synchronizer.getShieldedBalance()
                    preTxExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [preTxExpectation], timeout: 5)
        
        let sendExpectation = XCTestExpectation(description: "sendToAddress")
        var pendingEntity: ZcashTransaction.Overview?
        var testError: Error?
        let sendAmount = Zatoshi(10000)

        /*
        4. create transaction
        */
        do {
            let pendingTx = try await coordinator.synchronizer.sendToAddress(
                spendingKey: coordinator.spendingKey,
                zatoshi: sendAmount,
                toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
                memo: try Memo(string: "test transaction")
            )
            pendingEntity = pendingTx
            sendExpectation.fulfill()
        } catch {
            testError = error
            XCTFail("error sending to address. Error: \(String(describing: error))")
        }
        
        await fulfillment(of: [sendExpectation], timeout: 2)

        guard let pendingTx = pendingEntity else {
            XCTFail("error sending to address. Error: \(String(describing: testError))")
            return
        }
        
        /*
        5. stage 10 empty blocks
        */
        try coordinator.stageBlockCreate(height: receivedTxHeight + 1, count: 10)
        
        let sentTxHeight = receivedTxHeight + 1
        
        /*
        6. stage sent tx at sentTxHeight
        */
        guard let sentTx = try coordinator.getIncomingTransactions()?.first else {
            XCTFail("sent transaction not present on Darksidewalletd")
            return
        }
        try coordinator.stageTransaction(sentTx, at: sentTxHeight)
        
        /*
        6a. applyheight(sentTxHeight + 1 )
        */
        try coordinator.applyStaged(blockheight: sentTxHeight + 1)
        
        sleep(2)
        
        /*
        7. sync to  sentTxHeight + 1
        */
        let sentTxSyncExpectation = XCTestExpectation(description: "sent tx sync expectation")
        
        do {
            try await coordinator.sync(
                completion: { synchronizer in
                    let pMinedHeight = await synchronizer.pendingTransactions.first?.minedHeight
                    XCTAssertEqual(pMinedHeight, sentTxHeight)
                    sentTxSyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [sentTxSyncExpectation], timeout: 5)
        
        /*
        8. stage sentTx and otherTx at sentTxheight
        */
        try coordinator.stageBlockCreate(height: sentTxHeight, count: 20, nonce: 5)
        try coordinator.stageTransaction(url: FakeChainBuilder.someOtherTxUrl, at: sentTxHeight)
        try coordinator.stageTransaction(sentTx, at: sentTxHeight)
        
        /*
        9. applyStaged(sentTx + 1)
        */
        try coordinator.applyStaged(blockheight: sentTxHeight + 1)
        
        sleep(2)

        print("Starting after reorg sync")
        let afterReOrgExpectation = XCTestExpectation(description: "after ReOrg Expectation")
        do {
            try await coordinator.sync(
                completion: { synchronizer in
                    /*
                    11. verify that the sent tx is mined and balance is correct
                    */
                    let pMinedHeight = await synchronizer.pendingTransactions.first?.minedHeight
                    XCTAssertEqual(pMinedHeight, sentTxHeight)
                    // fee change on this branch
                    let expectedBalance = try await synchronizer.getShieldedBalance()
                    XCTAssertEqual(initialTotalBalance - sendAmount - Zatoshi(1000), expectedBalance)
                    afterReOrgExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [afterReOrgExpectation], timeout: 5)
        
        /*
        12. applyStaged(sentTx + 10)
        */
        try coordinator.applyStaged(blockheight: sentTxHeight + 12)
        sleep(2)

        /*
        13. verify that there's no more pending transaction
        */
        let lastSyncExpectation = XCTestExpectation(description: "sync to confirmation")
        do {
            try await coordinator.sync(
                completion: { _ in
                    lastSyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [lastSyncExpectation], timeout: 5)

        let expectedVerifiedBalance = initialTotalBalance + pendingTx.value
        let currentVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
        let expectedPendingTransactionsCount = await coordinator.synchronizer.pendingTransactions.count
        XCTAssertEqual(expectedPendingTransactionsCount, 0)
        XCTAssertEqual(expectedVerifiedBalance, currentVerifiedBalance)

        let resultingBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
        XCTAssertEqual(resultingBalance, currentVerifiedBalance)
    }
    
    func testIncomingTransactionIndexChange() async throws {
        await hookToReOrgNotification()
        self.expectedReorgHeight = 663196
        self.expectedRewindHeight = 663175
        try coordinator.reset(saplingActivation: birthday, branchID: "2bb40e60", chainName: "main")
        try coordinator.resetBlocks(dataset: .predefined(dataset: .txIndexChangeBefore))
        try coordinator.applyStaged(blockheight: 663195)
        sleep(1)
        let firstSyncExpectation = XCTestExpectation(description: "first sync expectation")

        var preReorgTotalBalance = Zatoshi.zero
        var preReorgVerifiedBalance = Zatoshi.zero
        try await coordinator.sync(
            completion: { synchronizer in
                preReorgTotalBalance = try await synchronizer.getShieldedBalance()
                preReorgVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
                firstSyncExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [firstSyncExpectation], timeout: 10)
        
        /*
        trigger reorg
        */
        try coordinator.resetBlocks(dataset: .predefined(dataset: .txIndexChangeAfter))
        try coordinator.applyStaged(blockheight: 663200)
        
        sleep(1)
        
        let afterReorgSync = XCTestExpectation(description: "after reorg sync")
        
        var postReorgTotalBalance = Zatoshi.zero
        var postReorgVerifiedBalance = Zatoshi.zero
        try await coordinator.sync(
            completion: { synchronizer in
                postReorgTotalBalance = try await synchronizer.getShieldedBalance()
                postReorgVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
                afterReorgSync.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [reorgExpectation, afterReorgSync], timeout: 30)
        
        XCTAssertEqual(postReorgVerifiedBalance, preReorgVerifiedBalance)
        XCTAssertEqual(postReorgTotalBalance, preReorgTotalBalance)
    }
    
    func testReOrgExpiresInboundTransaction() async throws {
        try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
        let receivedTxHeight = BlockHeight(663188)
        try coordinator.applyStaged(blockheight: receivedTxHeight - 1)
        sleep(2)
        let expectation = XCTestExpectation(description: "sync to \(receivedTxHeight - 1) expectation")
        var initialBalance = Zatoshi(-1)
        var initialVerifiedBalance = Zatoshi(-1)

        try await coordinator.sync(
            completion: { synchronizer in
                initialBalance = try await synchronizer.getShieldedBalance()
                initialVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
                expectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [expectation], timeout: 5)
        
        let afterTxHeight = receivedTxHeight + 1
        try coordinator.applyStaged(blockheight: afterTxHeight)
        sleep(2)
        let afterTxSyncExpectation = XCTestExpectation(description: "sync to \(afterTxHeight) expectation")
        
        var afterTxBalance = Zatoshi(-1)
        var afterTxVerifiedBalance = Zatoshi(-1)

        try await coordinator.sync(
            completion: { synchronizer in
                afterTxBalance = try await synchronizer.getShieldedBalance()
                afterTxVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
                let receivedTransactions = await synchronizer.receivedTransactions
                XCTAssertNotNil(
                    receivedTransactions.first { $0.minedHeight == receivedTxHeight },
                    "Transaction not found at \(receivedTxHeight)"
                )
                afterTxSyncExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [afterTxSyncExpectation], timeout: 10.0)
        
        XCTAssertEqual(initialVerifiedBalance, afterTxVerifiedBalance)
        XCTAssertNotEqual(initialBalance, afterTxBalance)
        
        let reorgSize: Int = 3
        let newBlocksCount: Int = 11 + reorgSize
        try coordinator.stageBlockCreate(height: receivedTxHeight - reorgSize, count: newBlocksCount + reorgSize)
        try coordinator.applyStaged(blockheight: receivedTxHeight + newBlocksCount - 1)
        
        sleep(2)
        let afterReorgExpectation = XCTestExpectation(description: "after reorg expectation")
        
        var afterReOrgBalance = Zatoshi(-1)
        var afterReOrgVerifiedBalance = Zatoshi(-1)

        try await coordinator.sync(
            completion: { synchronizer in
                afterReOrgBalance = try await synchronizer.getShieldedBalance()
                afterReOrgVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
                let receivedTransactions = await synchronizer.receivedTransactions
                XCTAssertNil(
                    receivedTransactions.first { $0.minedHeight == receivedTxHeight },
                    "Transaction found at \(receivedTxHeight) after reorg"
                )
                afterReorgExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [afterReorgExpectation], timeout: 5)
        
        XCTAssertEqual(afterReOrgBalance, initialBalance)
        XCTAssertEqual(afterReOrgVerifiedBalance, initialVerifiedBalance)

        guard
            let receivedTransaction = try await coordinator.synchronizer.allTransactions().first
        else {
            XCTFail("expected to have a received transaction, but found none")
            return
        }

        let transactionOutputs = await coordinator.synchronizer.getTransactionOutputs(
            for: receivedTransaction
        )
        
        guard transactionOutputs.count == 1 else {
            XCTFail("expected output count to be 1")
            return
        }

        let output = transactionOutputs[0]

        XCTAssertEqual(output.recipient, .internalAccount(0))
        XCTAssertEqual(output.value, Zatoshi(100000))
    }
    
    /// Steps:
    /// 1.  sync up to an incoming transaction (incomingTxHeight + 1)
    /// 1a. save balances
    /// 2. stage 4 blocks from incomingTxHeight - 1 with different nonce
    /// 3. stage otherTx at incomingTxHeight
    /// 4. stage incomingTx at incomingTxHeight
    /// 5. applyHeight(incomingHeight + 3)
    /// 6. sync to latest height
    /// 7. check that balances still match
    func testReOrgChangesInboundTxIndexInBlock() async throws {
        try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
        
        let incomingTxHeight = BlockHeight(663188)
        
        try coordinator.applyStaged(blockheight: incomingTxHeight + 1)

        sleep(1)
        
        /*
        1.  sync up to an incoming transaction (incomingTxHeight + 1)
        */
        let firstSyncExpectation = XCTestExpectation(description: "first sync test expectation")
        
        var initialBalance = Zatoshi(-1)
        var initialVerifiedBalance = Zatoshi(-1)
        var incomingTx: ZcashTransaction.Overview!

        try await coordinator.sync(
            completion: { _ in
                firstSyncExpectation.fulfill()
            }, error: self.handleError
        )
        
        await fulfillment(of: [firstSyncExpectation], timeout: 5)
        
        /*
        1a. save balances
        */
        initialBalance = try await coordinator.synchronizer.getShieldedBalance()
        initialVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
        incomingTx = await coordinator.synchronizer.receivedTransactions.first(where: { $0.minedHeight == incomingTxHeight })

        let txRawData = incomingTx.raw ?? Data()
        
        let rawTransaction = RawTransaction.with({ rawTx in
            rawTx.data = txRawData
        })
        
        /*
        2. stage 10 blocks from incomingTxHeight - 1 with different nonce
        */
        let blockCount = 10
        try coordinator.stageBlockCreate(height: incomingTxHeight - 1, count: blockCount, nonce: 1)
        
        /*
        3. stage otherTx at incomingTxHeight
        */
        try coordinator.stageTransaction(url: FakeChainBuilder.someOtherTxUrl, at: incomingTxHeight)
        
        /*
        4. stage incomingTx at incomingTxHeight
        */
        try coordinator.stageTransaction(rawTransaction, at: incomingTxHeight)
        
        /*
        5. applyHeight(incomingHeight + 3)
        */
        try coordinator.applyStaged(blockheight: incomingTxHeight + 3)

        sleep(1)
        
        let lastSyncExpectation = XCTestExpectation(description: "last sync expectation")

        /*
        6. sync to latest height
        */
        try await coordinator.sync(
            completion: { _ in
                lastSyncExpectation.fulfill()
            }, error: self.handleError
        )
        await fulfillment(of: [lastSyncExpectation], timeout: 5)

        /*
        7. check that balances still match
        */
        let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
        let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
        XCTAssertEqual(expectedVerifiedBalance, initialVerifiedBalance)
        XCTAssertEqual(expectedBalance, initialBalance)
    }
    
    func testTxIndexReorg() async throws {
        try coordinator.resetBlocks(dataset: .predefined(dataset: .txIndexChangeBefore))
        
        let txReorgHeight = BlockHeight(663195)
        let finalHeight = BlockHeight(663200)
        try coordinator.applyStaged(blockheight: txReorgHeight)
        sleep(1)

        let firstSyncExpectation = XCTestExpectation(description: "first sync test expectation")
        var initialBalance = Zatoshi(-1)
        var initialVerifiedBalance = Zatoshi(-1)

        try await coordinator.sync(
            completion: { synchronizer in
                initialBalance = try await synchronizer.getShieldedBalance()
                initialVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
                firstSyncExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [firstSyncExpectation], timeout: 5)
        
        try coordinator.resetBlocks(dataset: .predefined(dataset: .txIndexChangeAfter))
        
        try coordinator.applyStaged(blockheight: finalHeight)
        sleep(1)
        
        let lastSyncExpectation = XCTestExpectation(description: "last sync expectation")
        
        try await coordinator.sync(
            completion: { _ in
                lastSyncExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [lastSyncExpectation], timeout: 5)

        let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
        let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
        XCTAssertEqual(expectedBalance, initialBalance)
        XCTAssertEqual(expectedVerifiedBalance, initialVerifiedBalance)
    }

    /// A Re Org occurs and changes the height of an outbound transaction
    /// Pre-condition: Wallet has funds
    ///
    /// Steps:
    /// 1. create fake chain
    /// 1a. sync to latest height
    /// 2. send transaction to recipient address
    /// 3. getIncomingTransaction
    /// 4. stage transaction at sentTxHeight
    /// 5. applyHeight(sentTxHeight)
    /// 6. sync to latest height
    /// 6a. verify that there's a pending transaction with a mined height of sentTxHeight
    /// 7. stage 15  blocks from sentTxHeight
    /// 7. a stage sent tx to sentTxHeight + 2
    /// 8. applyHeight(sentTxHeight + 1) to cause a 1 block reorg
    /// 9. sync to latest height
    /// 10. verify that there's a pending transaction with -1 mined height
    /// 11. applyHeight(sentTxHeight + 2)
    /// 11a. sync to latest height
    /// 12. verify that there's a pending transaction with a mined height of sentTxHeight + 2
    /// 13. apply height(sentTxHeight + 15)
    /// 14. sync to latest height
    /// 15. verify that there's no pending transaction and that the tx is displayed on the sentTransactions collection
    func testReOrgChangesOutboundTxMinedHeight() async throws {
        await hookToReOrgNotification()

        /*
        1. create fake chain
        */
        try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
        
        try coordinator.applyStaged(blockheight: 663188)
        sleep(2)
        
        let firstSyncExpectation = XCTestExpectation(description: "first sync")
        /*
        1a. sync to latest height
        */
        do {
            try await coordinator.sync(
                completion: { _ in
                    firstSyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [firstSyncExpectation], timeout: 5)
        
        sleep(1)
        let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
        
        let sendExpectation = XCTestExpectation(description: "send expectation")
        var pendingEntity: ZcashTransaction.Overview?
        
        /*
        2. send transaction to recipient address
        */
        let recipient = try Recipient(Environment.testRecipientAddress, network: self.network.networkType)

        do {
            let pendingTx = try await coordinator.synchronizer.sendToAddress(
                spendingKey: self.coordinator.spendingKey,
                zatoshi: Zatoshi(20000),
                toAddress: recipient,
                memo: try Memo(string: "this is a test")
            )
            pendingEntity = pendingTx
            sendExpectation.fulfill()
        } catch {
            await handleError(error)
        }
        
        await fulfillment(of: [sendExpectation], timeout: 11)
        
        guard pendingEntity != nil else {
            XCTFail("no pending transaction after sending")
            try await coordinator.stop()
            return
        }

        /**
        3. getIncomingTransaction
        */
        guard let incomingTx = try coordinator.getIncomingTransactions()?.first else {
            XCTFail("no incoming transaction")
            try await coordinator.stop()
            return
        }
        
        let sentTxHeight: BlockHeight = 663189
        
        /*
        4. stage transaction at sentTxHeight
        */
        try coordinator.stageBlockCreate(height: sentTxHeight)
        
        try coordinator.stageTransaction(incomingTx, at: sentTxHeight)

        /*
        5. applyHeight(sentTxHeight)
        */
        try coordinator.applyStaged(blockheight: sentTxHeight)
        
        sleep(2)
        
        /*
        6. sync to latest height
        */
        let secondSyncExpectation = XCTestExpectation(description: "after send expectation")
        
        do {
            try await coordinator.sync(
                completion: { _ in
                    secondSyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [secondSyncExpectation], timeout: 5)

        var pendingTransactionsCount = await coordinator.synchronizer.pendingTransactions.count
        XCTAssertEqual(pendingTransactionsCount, 1)
        guard let afterStagePendingTx = await coordinator.synchronizer.pendingTransactions.first else {
            return
        }
        
        /*
        6a. verify that there's a pending transaction with a mined height of sentTxHeight
        */
        XCTAssertEqual(afterStagePendingTx.minedHeight, sentTxHeight)
        
        /*
        7. stage 20  blocks from sentTxHeight
        */
        try coordinator.stageBlockCreate(height: sentTxHeight, count: 25)
        
        /*
        7a. stage sent tx to sentTxHeight + 2
        */
        try coordinator.stageTransaction(incomingTx, at: sentTxHeight + 2)
        
        /*
        8. applyHeight(sentTxHeight + 1) to cause a 1 block reorg
        */
        try coordinator.applyStaged(blockheight: sentTxHeight + 1)
        sleep(2)
        
        /*
        9. sync to latest height
        */
        self.expectedReorgHeight = sentTxHeight + 1
        let afterReorgExpectation = XCTestExpectation(description: "after reorg sync")
        
        do {
            try await coordinator.sync(
                completion: { _ in
                    afterReorgExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [reorgExpectation, afterReorgExpectation], timeout: 5)
        
        /*
        10. verify that there's a pending transaction with -1 mined height
        */
        guard let newPendingTx = await coordinator.synchronizer.pendingTransactions.first else {
            XCTFail("No pending transaction")
            try await coordinator.stop()
            return
        }
        
        XCTAssertNil(newPendingTx.minedHeight)
        
        /*
        11. applyHeight(sentTxHeight + 2)
        */
        try coordinator.applyStaged(blockheight: sentTxHeight + 2)
        sleep(2)
        
        let yetAnotherExpectation = XCTestExpectation(description: "after staging expectation")
        
        /*
        11a. sync to latest height
        */
        do {
            try await coordinator.sync(
                completion: { _ in
                    yetAnotherExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [yetAnotherExpectation], timeout: 5)
        
        /*
        12. verify that there's a pending transaction with a mined height of sentTxHeight + 2
        */
        pendingTransactionsCount = await coordinator.synchronizer.pendingTransactions.count
        XCTAssertEqual(pendingTransactionsCount, 1)
        guard let newlyPendingTx = try await coordinator.synchronizer.allPendingTransactions().first(where: { $0.isSentTransaction }) else {
            XCTFail("no pending transaction")
            try await coordinator.stop()
            return
        }
        
        XCTAssertEqual(newlyPendingTx.minedHeight, sentTxHeight + 2)
        
        /*
        13. apply height(sentTxHeight + 25)
        */
        try coordinator.applyStaged(blockheight: sentTxHeight + 25)
        
        sleep(2)
        
        let thisIsTheLastExpectationIPromess = XCTestExpectation(description: "last sync")

        /*
        14. sync to latest height
        */
        do {
            try await coordinator.sync(
                completion: { _ in
                    thisIsTheLastExpectationIPromess.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [thisIsTheLastExpectationIPromess], timeout: 5)
        
        /*
        15. verify that there's no pending transaction and that the tx is displayed on the sentTransactions collection
        */
        let pendingTranscationsCount = await coordinator.synchronizer.pendingTransactions.count
        XCTAssertEqual(pendingTranscationsCount, 0)

        let sentTransactions = await coordinator.synchronizer.sentTransactions
            .first(
                where: { transaction in
                    return transaction.rawID == newlyPendingTx.rawID
                }
            )

        XCTAssertNotNil(
            sentTransactions,
            "Sent Tx is not on sent transactions"
        )

        let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
        let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()

        XCTAssertEqual(
            initialTotalBalance + newlyPendingTx.value, // Note: sent transactions have negative values
            expectedBalance
        )

        XCTAssertEqual(
            initialTotalBalance + newlyPendingTx.value, // Note: sent transactions have negative values
            expectedVerifiedBalance
        )

        let txRecipients = await coordinator.synchronizer.getRecipients(for: newPendingTx)
        XCTAssertEqual(txRecipients.count, 2)
        XCTAssertNotNil(txRecipients.first(where: { $0 == .internalAccount(0) }))
        XCTAssertNotNil(txRecipients.first(where: { $0 == .address(recipient) }))
    }

    /// Uses the zcash-hackworks data set.

    /// A Re Org occurs at 663195, and sweeps an Inbound Tx that appears later on the chain.
    /// Steps:
    /// 1. reset dlwd
    /// 2. load blocks from txHeightReOrgBefore
    /// 3. applyStaged(663195)
    /// 4. sync to latest height
    /// 5. get balances
    /// 6. load blocks from dataset txHeightReOrgBefore
    /// 7. apply stage 663200
    /// 8. sync to latest height
    /// 9. verify that the balance is equal to the one before the reorg
    func testReOrgChangesInboundMinedHeight() async throws {
        try coordinator.reset(saplingActivation: 663150, branchID: branchID, chainName: chainName)
        sleep(2)
        try coordinator.resetBlocks(dataset: .predefined(dataset: .txHeightReOrgBefore))
        sleep(2)
        try coordinator.applyStaged(blockheight: 663195)
        sleep(2)
        let firstSyncExpectation = XCTestExpectation(description: "first sync")
        
        try await coordinator.sync(
            completion: { _ in
                firstSyncExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [firstSyncExpectation], timeout: 5)
        
        let initialBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
        let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
        guard let initialTxHeight = try await coordinator.synchronizer.allReceivedTransactions().first?.minedHeight else {
            XCTFail("no incoming transaction found!")
            return
        }
        
        try coordinator.resetBlocks(dataset: .predefined(dataset: .txHeightReOrgAfter))
        
        sleep(5)
        
        try coordinator.applyStaged(blockheight: 663200)
        
        sleep(6)
        
        let afterReOrgExpectation = XCTestExpectation(description: "after reorg")
        try await coordinator.sync(
            completion: { _ in
                afterReOrgExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [afterReOrgExpectation], timeout: 5)
        
        guard let afterReOrgTxHeight = await coordinator.synchronizer.receivedTransactions.first?.minedHeight else {
            XCTFail("no incoming transaction found after re org!")
            return
        }

        let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
        let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
        XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
        XCTAssertEqual(initialBalance, expectedBalance)
        XCTAssert(afterReOrgTxHeight > initialTxHeight)
    }

    /// Re Org removes incoming transaction and is never mined
    /// Steps:
    /// 1. sync prior to incomingTxHeight - 1 to get balances there
    /// 2. sync to latest height
    /// 3. cause reorg
    /// 4. sync to latest height
    /// 5. verify that reorg Happened at reorgHeight
    /// 6. verify that balances match initial balances
    // FIXME [#644]: Test works with lightwalletd v0.4.13 but is broken when using newer lightwalletd. More info is in #644.
    func testReOrgRemovesIncomingTxForever() async throws {
        await hookToReOrgNotification()
        try coordinator.reset(saplingActivation: 663150, branchID: branchID, chainName: chainName)
        
        try coordinator.resetBlocks(dataset: .predefined(dataset: .txReOrgRemovesInboundTxBefore))
        
        let reorgHeight: BlockHeight = 663195
        self.expectedReorgHeight = reorgHeight
        self.expectedRewindHeight = reorgHeight - 10
        
        try coordinator.applyStaged(blockheight: reorgHeight - 1)
        
        sleep(2)
        let firstSyncExpectation = XCTestExpectation(description: "first sync")
        
        /**
        1. sync prior to incomingTxHeight - 1 to get balances there
        */
        try await coordinator.sync(
            completion: { _ in
                firstSyncExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [firstSyncExpectation], timeout: 5)
        
        let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
        let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
        
        try coordinator.applyStaged(blockheight: reorgHeight - 1)
        sleep(1)
        
        let secondSyncExpectation = XCTestExpectation(description: "second sync expectation")
        
        /**
        2. sync to latest height
        */
        try await coordinator.sync(
            completion: { _ in
                secondSyncExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [secondSyncExpectation], timeout: 10)
        
        /**
        3. cause reorg
        */
        try coordinator.resetBlocks(dataset: .predefined(dataset: .txReOrgRemovesInboundTxAfter))
        
        try coordinator.applyStaged(blockheight: 663200)
        sleep(2)
        
        let afterReorgSyncExpectation = XCTestExpectation(description: "after reorg expectation")
        try await coordinator.sync(
            completion: { _ in
                afterReorgSyncExpectation.fulfill()
            },
            error: self.handleError
        )
        
        await fulfillment(of: [afterReorgSyncExpectation], timeout: 5)

        let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
        let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
        XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
        XCTAssertEqual(initialTotalBalance, expectedBalance)
    }
    
    /// Transaction was included in a block, and then is not included in a block after a reorg, and expires.
    /// Steps:
    /// 1. create fake chain
    /// 1a. sync to latest height
    /// 2. send transaction to recipient address
    /// 3. getIncomingTransaction
    /// 4. stage transaction at sentTxHeight
    /// 5. applyHeight(sentTxHeight)
    /// 6. sync to latest height
    /// 6a. verify that there's a pending transaction with a mined height of sentTxHeight
    /// 7. stage 15 blocks from sentTxHeigth to cause a reorg
    /// 8. sync to latest height
    /// 9. verify that there's an expired transaction as a pending transaction
    func testReOrgRemovesOutboundTxAndIsNeverMined() async throws {
        await hookToReOrgNotification()
        
        /*
        1. create fake chain
        */
        try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
        let sentTxHeight: BlockHeight = 663195
        try coordinator.applyStaged(blockheight: sentTxHeight - 1)
        
        sleep(2)
        
        let firstSyncExpectation = XCTestExpectation(description: "first sync")

        /*
        1a. sync to latest height
        */
        do {
            try await coordinator.sync(
                completion: { _ in
                    firstSyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [firstSyncExpectation], timeout: 10)
        
        sleep(1)
        let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
        
        let sendExpectation = XCTestExpectation(description: "send expectation")
        var pendingEntity: ZcashTransaction.Overview?
        
        /*
        2. send transaction to recipient address
        */
        do {
            let pendingTx = try await coordinator.synchronizer.sendToAddress(
                spendingKey: self.coordinator.spendingKey,
                zatoshi: Zatoshi(20000),
                toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
                memo: try! Memo(string: "this is a test")
        )
            pendingEntity = pendingTx
            sendExpectation.fulfill()
        } catch {
            await handleError(error)
        }
        
        await fulfillment(of: [sendExpectation], timeout: 11)
        
        guard pendingEntity != nil else {
            XCTFail("no pending transaction after sending")
            try await coordinator.stop()
            return
        }

        /**
        3. getIncomingTransaction
        */
        guard let incomingTx = try coordinator.getIncomingTransactions()?.first else {
            XCTFail("no incoming transaction")
            try await coordinator.stop()
            return
        }
        
        self.expectedReorgHeight = sentTxHeight + 1

        /*
        4. stage transaction at sentTxHeight
        */
        try coordinator.stageBlockCreate(height: sentTxHeight)
        
        try coordinator.stageTransaction(incomingTx, at: sentTxHeight)

        /*
        5. applyHeight(sentTxHeight)
        */
        try coordinator.applyStaged(blockheight: sentTxHeight)
        
        sleep(2)

        /*
        6. sync to latest height
        */
        let secondSyncExpectation = XCTestExpectation(description: "after send expectation")
        
        do {
            try await coordinator.sync(
                completion: { _ in
                    secondSyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [secondSyncExpectation], timeout: 5)
        let extraBlocks = 25
        try coordinator.stageBlockCreate(height: sentTxHeight, count: extraBlocks, nonce: 5)
        
        try coordinator.applyStaged(blockheight: sentTxHeight + 5)
        
        sleep(2)
        let reorgSyncExpectation = XCTestExpectation(description: "reorg sync expectation")
        
        do {
            try await coordinator.sync(
                completion: { _ in
                    reorgSyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [reorgExpectation, reorgSyncExpectation], timeout: 5)
        
        guard let pendingTx = await coordinator.synchronizer.pendingTransactions.first else {
            XCTFail("no pending transaction after reorg sync")
            return
        }
        
        XCTAssertNil(pendingTx.minedHeight)
        
        LoggerProxy.info("applyStaged(blockheight: \(sentTxHeight + extraBlocks - 1))")
        try coordinator.applyStaged(blockheight: sentTxHeight + extraBlocks - 1)
        
        sleep(2)
        
        let lastSyncExpectation = XCTestExpectation(description: "last sync expectation")
        
        do {
            try await coordinator.sync(
                completion: { _ in
                    lastSyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [lastSyncExpectation], timeout: 5)

        let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
        XCTAssertEqual(expectedBalance, initialTotalBalance)
    }
    
    func testLongSync() async throws {
        await hookToReOrgNotification()
        
        /*
        1. create fake chain
        */
        let fullSyncLength = 100_000
    
        try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName, length: fullSyncLength)
        
        try coordinator.applyStaged(blockheight: birthday + fullSyncLength)
        
        sleep(20)
        
        let firstSyncExpectation = XCTestExpectation(description: "first sync")

        /*
        sync to latest height
        */
        do {
            try await coordinator.sync(
                completion: { _ in
                    firstSyncExpectation.fulfill()
                },
                error: self.handleError
            )
        } catch {
            await handleError(error)
        }

        await fulfillment(of: [firstSyncExpectation], timeout: 600)
        
        let latestScannedHeight = await coordinator.synchronizer.latestBlocksDataProvider.latestScannedHeight
        XCTAssertEqual(latestScannedHeight, birthday + fullSyncLength)
    }
    
    func handleError(_ error: Error?) async {
        _ = try? await coordinator.stop()
        guard let testError = error else {
            XCTFail("failed with nil error")
            return
        }
        XCTFail("Failed with error: \(testError)")
    }
    
    func hookToReOrgNotification() async {
        let eventClosure: CompactBlockProcessor.EventClosure = { [weak self] event in
            switch event {
            case .handledReorg: self?.handleReorg(event: event)
            default: break
            }
        }

        await coordinator.synchronizer.blockProcessor.updateEventClosure(identifier: "tests", closure: eventClosure)
    }
}