import e from '../lib/eltro.mjs'
import assert from '../lib/assert.mjs'
import { printError } from '../lib/cli.mjs'

let testsWereRun = false

function CreateT() {
  const t = new e.Eltro()
  t.reporter = ''
  return t
}

e.test('Eltro should fail if tests are not within a group', function() {
  assert.throws(function() {
    const t = CreateT()
    t.begin()
    t.test('should throw', function() {})
  }, function(e) {
    assert.match(e.message, /outside/)
    return true
  })
})

e.test('Eltro describe should group tests', async function() {
  testsWereRun = true
  const assertPrefix = 'something'
  const assertName = 'blabla'
  const t = CreateT()
  t.begin()
  t.describe(assertPrefix, function() {
    t.test(assertName, function() {})
  })

  assert.strictEqual(t.groups.length, 1)
  assert.strictEqual(t.groups[0].tests.length, 1)
  assert.strictEqual(t.groups[0].tests[0].name, assertPrefix + ' ' + assertName)
})

e.test('Eltro setFilename should activate a new for said file', async function() {
  testsWereRun = true
  const assertFilePrefix = 'testety'
  const assertPrefix = 'something'
  const assertName = 'blabla'
  const t = CreateT()
  t.begin()
  t.setFilename(assertFilePrefix)
  t.describe(assertPrefix, function() {
    t.test(assertName, function() {})
  })

  assert.strictEqual(t.groups.length, 1)
  assert.strictEqual(t.groups[0].tests.length, 0)
  assert.strictEqual(t.groups[0].groups.length, 1)
  assert.strictEqual(t.groups[0].groups[0].tests.length, 1)
  assert.strictEqual(t.groups[0].groups[0].tests[0].name, assertFilePrefix + ': ' + assertPrefix + ' ' + assertName)
})

e.test('Eltro describe should support nested describe', async function() {
  testsWereRun = true
  const assertPrefix = 'something'
  const assertPrefix2 = 'else'
  const assertName = 'blabla'
  const assertFile = 'asdf.js'
  const t = CreateT()
  t.begin()
  t.setFilename(assertFile)
  t.describe(assertPrefix, function() {
    t.describe(assertPrefix2, function() {
      t.test(assertName, function() {})
    })
  })
  t.resetFilename()

  assert.strictEqual(t.groups.length, 1)
  assert.strictEqual(t.groups[0].groups.length, 1)
  assert.strictEqual(t.groups[0].groups[0].groups.length, 1)
  assert.strictEqual(t.groups[0].groups[0].groups[0].tests[0].name, assertFile + ': ' + assertPrefix + ' ' + assertPrefix2 + ' ' + assertName)
})

e.test('Eltro should run test', async function() {
  testsWereRun = true
  let assertIsTrue = false
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function() {
      assertIsTrue = true
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertIsTrue, true)
})

e.test('Eltro should run tests in nested groups', async function() {
  testsWereRun = true
  let assertIsTrue = false
  const t = CreateT()
  t.begin()
  t.describe('1', function() {
    t.describe('2', function() {
      t.describe('3', function() {
        t.test('', function() {
          assertIsTrue = true
        })
      })
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertIsTrue, true)
})

e.test('Eltro should run promised test', async function() {
  testsWereRun = true
  let assertIsTrue = false
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function() {
      return new Promise(function(res) {
        assertIsTrue = true
        res()
      })
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertIsTrue, true)
})

e.test('Eltro should support callback', async function() {
  testsWereRun = true
  let assertIsTrue = false
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function(cb) {
      setTimeout(function() {
        assertIsTrue = true
        cb()
      }, 25)
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertIsTrue, true)
})

e.test('Eltro should support custom cb with finish wrap', async function() {
  let actualRan = 0
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('a', function(cb) {
      setImmediate(() => {
        setImmediate(cb.finish(() => { actualRan++; }))
      })
    })

    t.test('b', function(cb) {
      setImmediate(() => {
        setImmediate(cb.finish(() => { actualRan++; }))
      })
    })
    t.test('c', function(cb) {
      setImmediate(() => {
        setImmediate(cb.finish(() => { actualRan++; }))
      })
    })
    t.test('d', function(cb) {
      setImmediate(() => {
        setImmediate(cb.finish(() => { actualRan++; }))
      })
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(actualRan, 4)
})

e.test('Eltro should support directly thrown errors', async function() {
  testsWereRun = true
  const assertError = new Error()
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function() {
      throw assertError
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.strictEqual(t.failedTests[0].error, assertError)
})

e.test('Eltro should support promise rejected errors', async function() {
  testsWereRun = true
  const assertError = new Error()
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function() {
      return new Promise(function(res, rej) {
        rej(assertError)
      })
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.strictEqual(t.failedTests[0].error, assertError)
})

e.test('Eltro should support callback rejected errors', async function() {
  testsWereRun = true
  const assertError = new Error()
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function(cb) {
      cb(assertError)
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.strictEqual(t.failedTests[0].error, assertError)
})

e.test('Eltro should support capturing unknown errors outside scope', async function() {
  testsWereRun = true
  const assertError = new Error()
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function(cb) {
      process.nextTick(function() {
        throw assertError
      })
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.strictEqual(t.failedTests[0].error, assertError)
})


e.test('Eltro should log an error if test is missing', async function() {
  testsWereRun = true
  const assertError = new Error()
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.describe('herpderp', function() {
      t.test('blatest')
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.match(t.failedTests[0].error.message, /herpderp/)
  assert.match(t.failedTests[0].error.message, /blatest/)
  assert.match(t.failedTests[0].error.message, /missing/)
})

e.test('Eltro should log an error if text is missing', async function() {
  testsWereRun = true
  const assertError = new Error()
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.describe('herpderp', function() {
      t.test()
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.match(t.failedTests[0].error.message, /herpderp/)
  assert.match(t.failedTests[0].error.message, /empty/)
  assert.match(t.failedTests[0].error.message, /name/)
})

e.test('Eltro should support timing out tests', async function() {
  testsWereRun = true
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function(cb) { }).timeout(50)
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.ok(t.failedTests[0].error)
  assert.match(t.failedTests[0].error.message, /50ms/)
})

e.test('Eltro should support timed out tests on late tests', async function() {
  testsWereRun = true
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function(cb) {
      setTimeout(function() {
        cb()
      }, 100)
    }).timeout(50)
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.ok(t.failedTests[0].error)
  assert.match(t.failedTests[0].error.message, /50ms/)
})

e.test('Eltro should support timed out tests in front', async function() {
  testsWereRun = true
  const t = CreateT()
  t.begin()

  t.describe('', function() {
    t.timeout(25).test('', function(cb) { setTimeout(cb, 50) })
    t.test('', function(cb) { setTimeout(cb, 50) })
  })

  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.ok(t.failedTests[0].error)
  assert.match(t.failedTests[0].error.message, /25ms/)
})

e.test('Eltro should support skipped tests', async function() {
  testsWereRun = true
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('', function() {
      throw new Error('Should not be called')
    }).skip()
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
})

e.test('Eltro should support only tests', async function() {
  testsWereRun = true
  let assertIsTrue = false
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.test('a', function() { throw new Error('Should not be called') })
    t.test('b', function() { throw new Error('Should not be called') })
    t.test('c', function() { assertIsTrue = true }).only()
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertIsTrue, true)
})

e.test('Eltro should ignore only if ignoreOnly is specified', async function() {
  testsWereRun = true
  let assertIsRun = 0
  const t = CreateT()

  t.ignoreOnly = true
  
  t.begin()
  t.describe('', function() {
    t.test('a', function() { assertIsRun++ })
    t.test('b', function() { assertIsRun++ }).only()
    t.describe('sub', function() {
      t.test('d', function() { assertIsRun++ })
      t.only().test('c', function() { assertIsRun++ })
    })
    t.only().describe('sub2', function() {
      t.test('d', function() { assertIsRun++ })
      t.test('c', function() { assertIsRun++ })
    })
    t.describe('sub3', function() {
      t.test('d', function() { assertIsRun++ })
      t.test('c', function() { assertIsRun++ })
    })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertIsRun, 8)
})

e.test('Eltro should support skipped tests in front of the test', async function() {
  testsWereRun = true
  let assertIsTrue = false
  const t = CreateT()
  t.begin()
  
  t.describe('', function() {
    t.skip().test('', function() { throw new Error('Should not be called') })
    t.test('', function() { assertIsTrue = true })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertIsTrue, true)
})

e.test('Eltro should support only tests in front of the test', async function() {
  testsWereRun = true
  let assertIsTrue = false
  const t = CreateT()
  t.begin()
  
  t.describe('', function() {
    t.test('a', function() { throw new Error('Should not be called') })
    t.only().test('b', function() { assertIsTrue = true })
    t.test('c', function() { throw new Error('Should not be called') })
  })

  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertIsTrue, true)
})

e.test('Eltro should support timed out describes', async function() {
  testsWereRun = true
  const t = CreateT()
  t.begin()
  
  t.describe('', function() {
    t.timeout(10).describe('', function() {
      t.test('', function(cb) { setTimeout(cb, 25) })
      t.test('', function(cb) { setTimeout(cb, 25) })
    })
    t.describe('', function() {
      t.test('', function(cb) { setTimeout(cb, 25) })
    })
    t.test('', function(cb) { setTimeout(cb, 25) })
  })

  await t.run()
  assert.strictEqual(t.failedTests.length, 2)
  assert.ok(t.failedTests[0].error)
  assert.match(t.failedTests[0].error.message, /10ms/)
  assert.ok(t.failedTests[1].error)
  assert.match(t.failedTests[1].error.message, /10ms/)
})

e.test('Eltro should support skipped tests in describe', async function() {
  testsWereRun = true
  let assertRan = 0
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.skip().describe('', function() {
      t.test('', function() { throw new Error('Should not be called') })
      t.test('', function() { throw new Error('Should not be called') })
      t.test('', function() { throw new Error('Should not be called') })
    })
    t.describe('', function() {
      t.test('', function() { assertRan++ })
    })
    t.test('', function() { assertRan++ })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertRan, 2)
})

e.test('Eltro should have skip at higher importance than only', async function() {
  testsWereRun = true
  let assertRan = 0
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.skip().describe('', function() {
      t.only().test('', function() { throw new Error('Should not be called') })
      t.only().test('', function() { throw new Error('Should not be called') })
      t.only().test('', function() { throw new Error('Should not be called') })
    })
    t.describe('', function() {
      t.test('', function() { assertRan++ })
    })
    t.test('', function() { assertRan++ })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0, 'failed tests should be 0 but was ' + t.failedTests.length)
  assert.strictEqual(assertRan, 2, 'tests run should be two but was ' + assertRan)
})

e.test('Eltro should support nested skip in describe commands', async function() {
  testsWereRun = true
  let assertRan = 0
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.skip().describe('', function() {
      t.describe('', function() {
        t.only().test('', function() { throw new Error('Should not be called') })
        t.only().test('', function() { throw new Error('Should not be called') })
        t.only().test('', function() { throw new Error('Should not be called') })
      })
    })
    t.describe('', function() {
      t.test('', function() { assertRan++ })
    })
    t.test('', function() { assertRan++ })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0)
  assert.strictEqual(assertRan, 2)
})

e.test('Eltro should support only tests in front of the test', async function() {
  testsWereRun = true
  let assertRan = 0
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.only().describe('', function() {
      t.test('', function() { assertRan++ })
      t.test('', function() { assertRan++ })
    })
    t.describe('', function() {
      t.test('a', function() { throw new Error('Should not be called') })
    })
    t.test('c', function() { throw new Error('Should not be called') })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0, 'failed tests should be 0 but was ' + t.failedTests.length)
  assert.strictEqual(assertRan, 2)
})

e.test('Eltro should support nexted only tests in front of the test', async function() {
  testsWereRun = true
  let assertRan = 0
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.only().describe('', function() {
      t.describe('', function() {
        t.test('', function() { assertRan++ })
        t.test('', function() { assertRan++ })
      })
    })
    t.describe('', function() {
      t.test('a', function() { throw new Error('Should not be called') })
    })
    t.test('c', function() { throw new Error('Should not be called') })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 0, 'failed tests should be 0 but was ' + t.failedTests.length)
  assert.strictEqual(assertRan, 2)
})

e.test('Eltro should support nested timed out describes', async function() {
  testsWereRun = true
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.timeout(10).describe('', function() {
      t.describe('', function() {
        t.test('', function(cb) { setTimeout(cb, 25) })
        t.test('', function(cb) { setTimeout(cb, 25) })
      })
    })
    t.describe('', function() {
      t.test('', function(cb) { setTimeout(cb, 25) })
    })
    t.test('', function(cb) { setTimeout(cb, 25) })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 2)
  assert.ok(t.failedTests[0].error)
  assert.match(t.failedTests[0].error.message, /10ms/)
  assert.ok(t.failedTests[1].error)
  assert.match(t.failedTests[1].error.message, /10ms/)
})

e.test('Eltro nested timeout should work as expected', async function() {
  testsWereRun = true
  const t = CreateT()
  t.begin()
  t.describe('', function() {
    t.timeout(50).describe('', function() {
      t.timeout(10).describe('', function() {
        t.test('', function(cb) { setTimeout(cb, 25) })
      })
      t.test('', function(cb) { setTimeout(cb, 25) })
    })
    t.describe('', function() {
      t.test('', function(cb) { setTimeout(cb, 25) })
    })
    t.test('', function(cb) { setTimeout(cb, 25) })
  })
  await t.run()
  assert.strictEqual(t.failedTests.length, 1)
  assert.ok(t.failedTests[0].error)
  assert.match(t.failedTests[0].error.message, /10ms/)
})

// Extra testing to make sure tests were run at all
process.on('exit', function(e) {
  try {
    assert.strictEqual(testsWereRun, true, 'Not all tests were run, remove all .only() and try again.')
  } catch(err) {
    printError(err)
    process.exit(1)
  }
  process.exit(e)
})