import { Eltro as t, assert, stub } from 'eltro'
import { setTimeout } from 'timers/promises'
import { Flaska, JsonHandler } from '../flaska.mjs'
import Client from './client.mjs'

const port = 51024
const log = {
  fatal: stub(),
  error: stub(),
  warn: stub(),
  info: stub(),
  debug: stub(),
  trace: stub(),
  log: stub(),
}
const flaska = new Flaska({ log })
const client = new Client(port)

let reqBody = null

flaska.after(function(ctx) {
  if (ctx.aborted) return
  ctx.log.info(ctx.status)
})

flaska.post('/json', JsonHandler(), function(ctx) {
  ctx.body = { success: true }
  reqBody = ctx.req.body
})
flaska.post('/json/slow', JsonHandler(), async function(ctx) {
  await setTimeout(300)
  ctx.body = { success: true }
  ctx.status = 201
  reqBody = ctx.req.body
})

function reset() {
  log.fatal.reset()
  log.error.reset()
  log.warn.reset()
  log.info.reset()
  log.debug.reset()
  log.trace.reset()
  log.log.reset()
}

t.before(function() {
  return flaska.listenAsync(port)
})

t.describe('/json', function() {
  t.beforeEach(function() {
    log.info.reset()
  })
  t.test('should return success and store body', async function() {
    const assertBody = { a: '' }
    for (let i = 0; i < 1010; i++) {
      assertBody.a += 'aaaaaaaaaa'
    }
    reqBody = null
    let body = await client.post('/json', assertBody)
    assert.deepEqual(body, { success: true })
    assert.deepStrictEqual(reqBody, assertBody)
    assert.strictEqual(log.info.callCount, 1)
    assert.strictEqual(log.info.firstCall[0], 200)
  })
  
  t.test('should return and log correctly', async function() {
    const assertBody = { a: '' }
    for (let i = 0; i < 1010; i++) {
      assertBody.a += 'aaaaaaaaaa'
    }
    reqBody = null
    let body = await client.post('/json/slow', assertBody)
    assert.deepEqual(body, { success: true })
    assert.deepStrictEqual(reqBody, assertBody)
    assert.strictEqual(log.info.callCount, 1)
    assert.strictEqual(log.info.firstCall[0], 201)
  })

  t.test('should fail if body is too big', async function() {
    reset()

    const assertBody = { a: '' }
    for (let i = 0; i < 10300; i++) {
      assertBody.a += 'aaaaaaaaaa'
    }

    let err = await assert.isRejected(client.post('/json', assertBody))

    assert.strictEqual(err.body.status, 413)
    assert.ok(log.error.called)
    assert.match(log.error.firstCall[0].message, /10240/)
    assert.strictEqual(log.error.firstCall[0].status, 413)
  })

  t.test('should fail if not a valid json', async function() {
    reset()

    let err = await assert.isRejected(client.customRequest('POST', '/json', 'XXXXX'))

    assert.strictEqual(err.body.status, 400)
    assert.match(err.body.message, /invalid json/i)
    assert.match(err.body.message, /token[^X]+X/i)
    assert.strictEqual(err.body.request, 'XXXXX')
    assert.strictEqual(log.error.callCount, 1)
    assert.match(log.error.firstCall[0].message, /invalid json/i)
    assert.match(log.error.firstCall[0].message, /token[^X]+X/i)
  })

  t.test('should handle incomplete requests correctly', async function() {
    reset()

    let req = await client.customRequest('POST', '/json', 'aaaa', { returnRequest: true })

    req.write('part1')

    await setTimeout(20)

    req.destroy()

    await setTimeout(20)

    assert.strictEqual(log.error.callCount, 0)
    assert.strictEqual(log.info.callCount, 0)
    // assert.strictEqual(log.info.firstCall[0].message, 'aborted')
  })
})