import { expect as c_expect } from 'chai'

import Response from '../../src/API/Response.js'
import EventProcessor from '../../src/BaseEvent/EventProcessor.js'
import Globals from '../../src/Globals.js'
import { emptyQueueEvent, observableContext } from '../Test.utils.js'

const skipCleanTmp = {
  skipCleanTmp: true,
}

describe('EventProcessor success invocation path', () => {
  test('Simple success', async () => {
    const b = { name: '123' }
    const context = observableContext()
    const transaction = new EventProcessor(
      emptyQueueEvent({
        Records: [{ body: JSON.stringify(b) }, { body: JSON.stringify(b) }],
      }),
      context,
      { ...skipCleanTmp }
    )
    let count = 0
    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
      c_expect(eventRecord).to.be.deep.equal(b)
      count++
      return Response.SuccessResponse(null)
    })
    // check resp
    c_expect(count).to.be.equals(2)
    c_expect(handlerResp).to.be.an.instanceof(Response)
    if (handlerResp instanceof Response) {
      c_expect(handlerResp?.getBody()).to.be.deep.equal({
        transactionID: 'unknown',
      })
      c_expect(handlerResp.getCode()).to.be.equal(200)
    }
    // ctx
    expect(context.fail).not.toBeCalled()
    expect(context.done).not.toBeCalled()
    expect(context.succeed).not.toBeCalled()
  })

  test('Simple success - do not decode', async () => {
    const b = { name: '123' }
    const context = observableContext()
    const transaction = new EventProcessor(
      emptyQueueEvent({
        Records: [{ body: JSON.stringify(b) }, { body: JSON.stringify(b) }],
      }),
      context,
      { ...skipCleanTmp }
    )
    let count = 0
    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
      c_expect(eventRecord).to.be.deep.equal(JSON.stringify(b))
      count++
      return Response.SuccessResponse(null)
    }, true)
    // check resp
    c_expect(count).to.be.equals(2)
    c_expect(handlerResp).to.be.an.instanceof(Response)
    if (handlerResp instanceof Response) {
      c_expect(handlerResp?.getBody()).to.be.deep.equal({
        transactionID: 'unknown',
      })
      c_expect(handlerResp.getCode()).to.be.equal(200)
    }
    // ctx
    expect(context.fail).not.toBeCalled()
    expect(context.done).not.toBeCalled()
    expect(context.succeed).not.toBeCalled()
  })
})

describe('EventProcessor failure invocation path', () => {
  test('Simple failure', async () => {
    const b = { name: '123' }
    const context = observableContext()
    const transaction = new EventProcessor(
      emptyQueueEvent({
        Records: [
          { body: JSON.stringify(b) },
          { messageId: '123', body: JSON.stringify(b) },
          { body: JSON.stringify(b) },
        ],
      }),
      context,
      { ...skipCleanTmp }
    )
    let count = 0
    let handlerResp: any = null,
      err: any = null
    try {
      handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
        c_expect(eventRecord).to.be.deep.equal(b)
        count++
        return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
      })
    } catch (e) {
      err = e
    }
    // check resp
    c_expect(count).to.be.equals(2)
    c_expect(handlerResp).to.be.null
    c_expect(err).to.be.deep.equal(
      new Error(
        JSON.stringify({
          err: 'Failed!',
          transactionID: 'unknown',
        })
      )
    )
    // ctx
    expect(context.fail).not.toBeCalled()
    expect(context.done).not.toBeCalled()
    expect(context.succeed).not.toBeCalled()
  })

  test('Simple failure w/ null', async () => {
    const b = { name: '123' }
    const context = observableContext()
    const transaction = new EventProcessor(
      emptyQueueEvent({
        Records: [
          { body: JSON.stringify(b) },
          { messageId: '123', body: JSON.stringify(b) },
          { body: JSON.stringify(b) },
        ],
      }),
      context,
      { ...skipCleanTmp }
    )
    let count = 0
    let handlerResp: any = null,
      err: any = null
    try {
      handlerResp = await transaction.processEvent(
        // @ts-ignore
        async (transaction, eventRecord) => {
          c_expect(eventRecord).to.be.deep.equal(b)
          count++
          return null
        }
      )
    } catch (e) {
      err = e
    }
    // check resp
    c_expect(count).to.be.equals(1)
    c_expect(handlerResp).to.be.null
    c_expect(err).to.be.deep.equal(
      new Error(
        JSON.stringify({
          err: Globals.ErrorResponseInvalidServerResponse,
          rollback: true,
          errCode: Globals.ErrorCode_APIError,
          transactionID: 'unknown',
        })
      )
    )
    // ctx
    expect(context.fail).not.toBeCalled()
    expect(context.done).not.toBeCalled()
    expect(context.succeed).not.toBeCalled()
  })

  test('Simple failure - allow failures', async () => {
    const b = { name: '123' }
    const context = observableContext()
    const transaction = new EventProcessor(
      emptyQueueEvent({
        Records: [{ body: JSON.stringify(b) }, { messageId: '123', body: JSON.stringify(b) }],
      }),
      context,
      { ...skipCleanTmp },
      true
    )
    let count = 0
    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
      c_expect(eventRecord).to.be.deep.equal(b)
      count++
      return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
    })
    // check resp
    c_expect(count).to.be.equals(2)
    c_expect(handlerResp).to.be.deep.equal({
      batchItemFailures: [{ itemIdentifier: '123' }],
    })
    // ctx
    expect(context.fail).not.toBeCalled()
    expect(context.done).not.toBeCalled()
    expect(context.succeed).not.toBeCalled()
  })

  test('Simple failure w/ null response - allow failures', async () => {
    const b = { name: '123' }
    const context = observableContext()
    const transaction = new EventProcessor(
      emptyQueueEvent({
        Records: [
          { messageId: '456', body: JSON.stringify(b) },
          { messageId: '123', body: JSON.stringify(b) },
        ],
      }),
      context,
      { ...skipCleanTmp },
      true
    )
    let count = 0
    const handlerResp = await transaction.processEvent(
      // @ts-ignore
      async (transaction, eventRecord) => {
        c_expect(eventRecord).to.be.deep.equal(b)
        count++
        return null
      }
    )
    // check resp
    c_expect(count).to.be.equals(2)
    c_expect(handlerResp).to.be.deep.equal({
      batchItemFailures: [{ itemIdentifier: '456' }, { itemIdentifier: '123' }],
    })
    // ctx
    expect(context.fail).not.toBeCalled()
    expect(context.done).not.toBeCalled()
    expect(context.succeed).not.toBeCalled()
  })

  test('Simple failure no records', async () => {
    const context = observableContext()
    const transaction = new EventProcessor(emptyQueueEvent(), context, {})
    let count = 0
    let handlerResp: any = null,
      err: any = null
    try {
      handlerResp = await transaction.processEvent(
        // @ts-ignore
        async () => {
          count++
          return null
        }
      )
    } catch (e) {
      err = e
    }
    // check resp
    c_expect(count).to.be.equals(0)
    c_expect(handlerResp).to.be.null
    c_expect(err).to.be.deep.equal(
      new Error(
        JSON.stringify({
          err: Globals.ErrorResponseNoRecords,
          errCode: Globals.ErrorCode_NoRecords,
        })
      )
    )
    // ctx
    expect(context.fail).not.toBeCalled()
    expect(context.done).not.toBeCalled()
    expect(context.succeed).not.toBeCalled()
  })
})

export {}