// import assert from 'assert'
// import mapSeries from 'p-each-series'
// import rmrf from 'rimraf'
// import OrbitDB from '../src/OrbitDB.js'

// // Include test utilities
// import {
//   config,
//   startIpfs,
//   stopIpfs,
//   testAPIs,
//   connectPeers,
//   waitForPeers,
// } from 'orbit-db-test-utils'

// const orbitdbPath1 = './orbitdb/tests/replication/1'
// const orbitdbPath2 = './orbitdb/tests/replication/2'
// const dbPath1 = './orbitdb/tests/replication/1/db1'
// const dbPath2 = './orbitdb/tests/replication/2/db2'

// Object.keys(testAPIs).forEach(API => {
//   describe(`orbit-db - Replication (${API})`, function() {
//     this.timeout(config.timeout * 2)

//     let ipfsd1, ipfsd2, ipfs1, ipfs2
//     let orbitdb1, orbitdb2, db1, db2

//     let timer
//     let options

//     before(async () => {
//       ipfsd1 = await startIpfs(API, config.daemon1)
//       ipfsd2 = await startIpfs(API, config.daemon2)
//       ipfs1 = ipfsd1.api
//       ipfs2 = ipfsd2.api
//       // Connect the peers manually to speed up test times
//       const isLocalhostAddress = (addr) => addr.toString().includes('127.0.0.1')
//       await connectPeers(ipfs1, ipfs2, { filter: isLocalhostAddress })
//       console.log("Peers connected")
//     })

//     after(async () => {
//       if (ipfsd1)
//         await stopIpfs(ipfsd1)

//       if (ipfsd2)
//         await stopIpfs(ipfsd2)
//     })

//     beforeEach(async () => {
//       clearInterval(timer)

//       rmrf.sync(orbitdbPath1)
//       rmrf.sync(orbitdbPath2)
//       rmrf.sync(dbPath1)
//       rmrf.sync(dbPath2)

//       orbitdb1 = await OrbitDB.createInstance(ipfs1, { directory: orbitdbPath1 })
//       orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: orbitdbPath2 })

//       options = {
//         // Set write access for both clients
//         accessController: {
//           write: [
//             orbitdb1.identity.id,
//             orbitdb2.identity.id
//           ]
//         }
//       }

//       options = Object.assign({}, options, { directory: dbPath1 })
//       db1 = await orbitdb1.eventlog('replication-tests', options)
//     })

//     afterEach(async () => {
//       clearInterval(timer)
//       options = {}

//       if (db1)
//         await db1.drop()

//       if (db2)
//         await db2.drop()

//       if(orbitdb1)
//         await orbitdb1.stop()

//       if(orbitdb2)
//         await orbitdb2.stop()
//     })

//     it('replicates database of 1 entry', async () => {
//       console.log("Waiting for peers to connect")
//       await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
//       // Set 'sync' flag on. It'll prevent creating a new local database and rather
//       // fetch the database from the network
//       options = Object.assign({}, options, { directory: dbPath2, sync: true })
//       db2 = await orbitdb2.eventlog(db1.address.toString(), options)

//       let finished = false

//       await db1.add('hello')

//       return new Promise(resolve => {
//         let replicatedEventCount = 0
//         db2.events.on('replicated', (address, length) => {
//           replicatedEventCount++
//           // Once db2 has finished replication, make sure it has all elements
//           // and process to the asserts below
//           const all = db2.iterator({ limit: -1 }).collect().length
//           finished = (all === 1)
//         })

//         timer = setInterval(() => {
//           if (finished) {
//             clearInterval(timer)
//             const entries = db2.iterator({ limit: -1 }).collect()
//             assert.equal(entries.length, 1)
//             assert.equal(entries[0].payload.value, 'hello')
//             assert.equal(replicatedEventCount, 1)
//             resolve()
//           }
//         }, 100)
//       })
//     })

//     it('replicates database of 100 entries', async () => {
//       console.log("Waiting for peers to connect")
//       await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())

//       options = Object.assign({}, options, { directory: dbPath2, sync: true })
//       db2 = await orbitdb2.eventlog(db1.address.toString(), options)

//       let finished = false
//       const entryCount = 100
//       const entryArr = []

//       for (let i = 0; i < entryCount; i ++)
//         entryArr.push(i)

//       return new Promise(async (resolve, reject) => {
//         db2.events.on('replicated', () => {
//           // Once db2 has finished replication, make sure it has all elements
//           // and process to the asserts below
//           const all = db2.iterator({ limit: -1 }).collect().length
//           finished = (all === entryCount)
//         })

//         try {
//           const add = i => db1.add('hello' + i)
//           await mapSeries(entryArr, add)
//         } catch (e) {
//           reject(e)
//         }

//         timer = setInterval(() => {
//           if (finished) {
//             clearInterval(timer)
//             const entries = db2.iterator({ limit: -1 }).collect()
//             assert.equal(entries.length, entryCount)
//             assert.equal(entries[0].payload.value, 'hello0')
//             assert.equal(entries[entries.length - 1].payload.value, 'hello99')
//             resolve()
//           }
//         }, 100)
//       })
//     })

//     it('emits correct replication info', async () => {
//       console.log("Waiting for peers to connect")
//       await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())

//       options = Object.assign({}, options, { directory: dbPath2, sync: true })
//       db2 = await orbitdb2.eventlog(db1.address.toString(), options)

//       let finished = false
//       const entryCount = 99

//       return new Promise(async (resolve, reject) => {
//         // Test that none of the entries gets into the replication queue twice
//         const replicateSet = new Set()
//         db2.events.on('replicate', (address, entry) => {
//           if (!replicateSet.has(entry.hash)) {
//             replicateSet.add(entry.hash)
//           } else {
//             reject(new Error('Shouldn\'t have started replication twice for entry ' + entry.hash + '\n' + entry.payload.value))
//           }
//         })

//         // Verify that progress count increases monotonically by saving
//         // each event's current progress into an array
//         const progressEvents = []
//         db2.events.on('replicate.progress', () => {
//           progressEvents.push(db2.replicationStatus.progress)
//         })

//         db2.events.on('replicated', (address, length) => {
//           // Once db2 has finished replication, make sure it has all elements
//           // and process to the asserts below
//           const all = db2.iterator({ limit: -1 }).collect().length
//           finished = (all === entryCount)
//         })

//         try {
//           timer = setInterval(() => {
//             if (finished) {
//               clearInterval(timer)
//               // All entries should be in the database
//               assert.equal(db2.iterator({ limit: -1 }).collect().length, entryCount)
//               // progress events should increase monotonically
//               assert.equal(progressEvents.length, entryCount)
//               for (const [idx, e] of progressEvents.entries()) {
//                 assert.equal(e, idx + 1)
//               }
//               // Verify replication status
//               assert.equal(db2.replicationStatus.progress, entryCount)
//               assert.equal(db2.replicationStatus.max, entryCount)
//               // Verify replicator state
//               assert.equal(db2._replicator.tasksRunning, 0)
//               assert.equal(db2._replicator.tasksQueued, 0)
//               assert.equal(db2._replicator.unfinished.length, 0)
//               // Replicator's internal caches should be empty
//               assert.equal(db2._replicator._logs.length, 0)
//               assert.equal(Object.keys(db2._replicator._fetching).length, 0)

//               resolve()
//             }
//           }, 1000)
//         } catch (e) {
//           reject(e)
//         }

//         // Trigger replication
//         let adds = []
//         for (let i = 0; i < entryCount; i ++) {
//           adds.push(i)
//         }

//         await mapSeries(adds, i => db1.add('hello ' + i))
//       })
//     })

//     it('emits correct replication info on fresh replication', async () => {
//       return new Promise(async (resolve, reject) => {
//         let finished = false
//         const entryCount = 512

//         // Trigger replication
//         const adds = []
//         for (let i = 0; i < entryCount; i ++) {
//           adds.push(i)
//         }

//         const add = async (i) => {
//           process.stdout.write("\rWriting " + (i + 1) + " / " + entryCount + " ")
//           await db1.add('hello ' + i)
//         }

//         await mapSeries(adds, add)
//         console.log()

//         // Open second instance again
//         options = {
//           directory: dbPath2,
//           overwrite: true,
//           sync: true,
//         }

//         db2 = await orbitdb2.eventlog(db1.address.toString(), options)

//         // Test that none of the entries gets into the replication queue twice
//         const replicateSet = new Set()
//         db2.events.on('replicate', (address, entry) => {
//           if (!replicateSet.has(entry.hash)) {
//             replicateSet.add(entry.hash)
//           } else {
//             reject(new Error('Shouldn\'t have started replication twice for entry ' + entry.hash))
//           }
//         })

//         // Verify that progress count increases monotonically by saving
//         // each event's current progress into an array
//         const progressEvents = []
//         db2.events.on('replicate.progress', (address, hash, entry) => {
//           progressEvents.push(db2.replicationStatus.progress)
//         })

//         let replicatedEventCount = 0
//         db2.events.on('replicated', (address, length) => {
//           replicatedEventCount++
//           // Once db2 has finished replication, make sure it has all elements
//           // and process to the asserts below
//           const all = db2.iterator({ limit: -1 }).collect().length
//           finished = (all === entryCount)
//         })

//         timer = setInterval(async () => {
//           if (finished) {
//             clearInterval(timer)

//             try {
//               // All entries should be in the database
//               assert.equal(db2.iterator({ limit: -1 }).collect().length, entryCount)
//               // 'replicated' event should've been received only once
//               assert.equal(replicatedEventCount, 1)
//               // progress events should increase monotonically
//               assert.equal(progressEvents.length, entryCount)
//               for (const [idx, e] of progressEvents.entries()) {
//                 assert.equal(e, idx + 1)
//               }
//               // Verify replication status
//               assert.equal(db2.replicationStatus.progress, entryCount)
//               assert.equal(db2.replicationStatus.max, entryCount)
//               // Verify replicator state
//               assert.equal(db2._replicator.tasksRunning, 0)
//               assert.equal(db2._replicator.tasksQueued, 0)
//               assert.equal(db2._replicator.unfinished.length, 0)
//               // Replicator's internal caches should be empty
//               assert.equal(db2._replicator._logs.length, 0)
//               assert.equal(Object.keys(db2._replicator._fetching).length, 0)

//               resolve()
//             } catch (e) {
//               reject(e)
//             }
//           }
//         }, 100)
//       })
//     })

//     it('emits correct replication info in two-way replication', async () => {
//       return new Promise(async (resolve, reject) => {
//         console.log("Waiting for peers to connect")
//         await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())

//         let finished = false
//         const entryCount = 100

//         // Trigger replication
//         const adds = []
//         for (let i = 0; i < entryCount; i ++) {
//           adds.push(i)
//         }

//         const add = async (i) => {
//           process.stdout.write("\rWriting " + (i + 1) + " / " + entryCount + " ")
//           await Promise.all([db1.add('hello-1-' + i), db2.add('hello-2-' + i)])
//         }

//         // Open second instance again
//         let options = {
//           directory: dbPath2 + '2',
//           overwrite: true,
//           sync: true,
//         }

//         db2 = await orbitdb2.eventlog(db1.address.toString(), options)
//         assert.equal(db1.address.toString(), db2.address.toString())

//         // Test that none of the entries gets into the replication queue twice
//         const replicateSet = new Set()
//         db2.events.on('replicate', (address, entry) => {
//           if (!replicateSet.has(entry.hash)) {
//             replicateSet.add(entry.hash)
//           } else {
//             reject(new Error('Shouldn\'t have started replication twice for entry ' + entry.hash))
//           }
//         })

//         db2.events.on('replicated', (address, length) => {
//           // Once db2 has finished replication, make sure it has all elements
//           // and process to the asserts below
//           const all = db2.iterator({ limit: -1 }).collect().length
//           finished = (all === entryCount * 2)
//         })

//         try {
//           await mapSeries(adds, add)
//           console.log()

//           timer = setInterval(() => {
//             if (finished) {
//               clearInterval(timer)

//               // Database values should match
//               const values1 = db1.iterator({limit: -1}).collect()
//               const values2 = db2.iterator({limit: -1}).collect()
//               assert.equal(values1.length, values2.length)
//               assert.deepEqual(values1, values2)
//               // All entries should be in the database
//               assert.equal(values1.length, entryCount * 2)
//               assert.equal(values2.length, entryCount * 2)
//               // Verify replication status
//               assert.equal(db2.replicationStatus.progress, entryCount * 2)
//               assert.equal(db2.replicationStatus.max, entryCount * 2)
//               // Verify replicator state
//               assert.equal(db2._replicator.tasksRunning, 0)
//               assert.equal(db2._replicator.tasksQueued, 0)
//               assert.equal(db2._replicator.unfinished.length, 0)
//               // Replicator's internal caches should be empty
//               assert.equal(db2._replicator._logs.length, 0)
//               assert.equal(Object.keys(db2._replicator._fetching).length, 0)

//               resolve()
//             }
//           }, 500)
//         } catch (e) {
//           reject(e)
//         }
//       })
//     })
//   })
// })