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/replicate-and-load/1'
const orbitdbPath2 = './orbitdb/tests/replicate-and-load/2'
const dbPath1 = './orbitdb/tests/replicate-and-load/1/db1'
const dbPath2 = './orbitdb/tests/replicate-and-load/2/db2'

Object.keys(testAPIs).forEach(API => {
  describe(`orbit-db - Replicate and Load (${API})`, function() {
    this.timeout(config.timeout)

    let ipfsd1, ipfsd2, ipfs1, ipfs2
    let orbitdb1, orbitdb2

    before(async () => {
      rmrf.sync(orbitdbPath1)
      rmrf.sync(orbitdbPath2)
      rmrf.sync(dbPath1)
      rmrf.sync(dbPath2)
      ipfsd1 = await startIpfs(API, config.daemon1)
      ipfsd2 = await startIpfs(API, config.daemon2)
      ipfs1 = ipfsd1.api
      ipfs2 = ipfsd2.api
      orbitdb1 = await OrbitDB.createInstance(ipfs1, { directory: orbitdbPath1 })
      orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: orbitdbPath2 })
      // 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(orbitdb1)
        await orbitdb1.stop()

      if(orbitdb2)
        await orbitdb2.stop()

      if (ipfsd1)
        await stopIpfs(ipfsd1)

      if (ipfsd2)
        await stopIpfs(ipfsd2)

      rmrf.sync(dbPath1)
      rmrf.sync(dbPath2)
    })

    describe('two peers', function() {
      let db1, db2

      const openDatabases = async (options = {}) => {
        // Set write access for both clients
        options.write = [
          orbitdb1.identity.publicKey,
          orbitdb2.identity.publicKey
        ]

        options = Object.assign({}, options, { path: dbPath1, create: true })
        db1 = await orbitdb1.eventlog('tests', options)
        // Set 'localOnly' flag on and it'll error if the database doesn't exist locally
        options = Object.assign({}, options, { path: dbPath2 })
        db2 = await orbitdb2.eventlog(db1.address.toString(), options)
      }

      before(async () => {
        await openDatabases()

        assert.equal(db1.address.toString(), db2.address.toString())

        console.log("Waiting for peers...")
        await waitForPeers(ipfs1, [orbitdb2.id], db1.address.toString())
        await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
      })

      after(async () => {
        if (db1) {
          await db1.drop()
        }

        if (db2) {
          await db2.drop()
        }
      })

      it.skip('replicates database of 100 entries and loads it from the disk', async () => {
        const entryCount = 100
        const entryArr = []
        let timer

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

        console.log("Writing to database...")
        await mapSeries(entryArr, (i) => db1.add('hello' + i))
        console.log("Done")

        return new Promise((resolve, reject) => {
          timer = setInterval(async () => {
            if (db2._oplog.length === entryCount) {
              clearInterval(timer)

              const items = db2.iterator({ limit: -1 }).collect()
              assert.equal(items.length, entryCount)
              assert.equal(items[0].payload.value, 'hello0')
              assert.equal(items[items.length - 1].payload.value, 'hello99')

              try {

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

                // Get the previous address to make sure nothing mutates it
                const addr = db1.address.toString()

                // Open the database again (this time from the disk)
                options = Object.assign({}, options, { path: dbPath1, create: false })
                const db3 = await orbitdb1.eventlog(addr, options)
                // Set 'localOnly' flag on and it'll error if the database doesn't exist locally
                options = Object.assign({}, options, { path: dbPath2, localOnly: true })
                const db4 = await orbitdb2.eventlog(addr, options)

                await db3.load()
                await db4.load()

                // Make sure we have all the entries in the databases
                const result1 = db3.iterator({ limit: -1 }).collect()
                const result2 = db4.iterator({ limit: -1 }).collect()
                assert.equal(result1.length, entryCount)
                assert.equal(result2.length, entryCount)

                await db3.drop()
                await db4.drop()
              } catch (e) {
                reject(e)
              }
              resolve()
            }
          }, 1000)
        })
      })
    })
  })
})