import { expect } from 'chai'
import { z } from 'zod'

import Response from '../../src/API/Response.js'
import Globals from '../../src/Globals.js'
import Validator from '../../src/Validation/Validator.js'
import { ViewSchema } from '../Test.utils.js'

function expectFullFailure(validationResult, c = 4) {
  expect(validationResult).to.be.an.instanceof(Response)
  if (validationResult instanceof Response) {
    expect(validationResult.getBody()).is.not.null
    expect(validationResult.getBody()).to.have.property('err', Globals.ErrorResponseValidationFail)
    expect(validationResult.getBody()).to.have.property('errCode', Globals.ErrorCode_InvalidInput)
    expect(validationResult.getBody()).to.have.property('validationFailure')
    expect(validationResult.getBody()['validationFailure']).to.have.lengthOf(c)
    expect(validationResult.getCode()).is.equals(400)
  }
}

describe('Validates unsuccessfully', () => {
  test('Fails to validate async', () => {
    const validationResult = Validator.validateSchema(async () => {}, ViewSchema)
    expectFullFailure(validationResult, 1)
  })

  test('Fails to validate null', () => {
    const validationResult = Validator.validateSchema(null, ViewSchema)
    expectFullFailure(validationResult, 1)
  })

  test('Fails to validate empty string', () => {
    const validationResult = Validator.validateSchema('', ViewSchema)
    expectFullFailure(validationResult, 1)
  })

  test('Fails to validate empty object', () => {
    const validationResult = Validator.validateSchema({}, ViewSchema)
    expectFullFailure(validationResult)
  })

  test('Fails to validate object with wrong keys', () => {
    const validationResult = Validator.validateSchema({ name: 'Joe' }, ViewSchema)
    expectFullFailure(validationResult)
  })

  test('Fails to validate object with wrong key types', () => {
    const validationResult = Validator.validateSchema({ id: 123 }, ViewSchema)
    expectFullFailure(validationResult)
    if (validationResult instanceof Response) {
      console.log(validationResult.getBody()['validationFailure'])
      expect(
        validationResult.getBody()['validationFailure'].filter(f => {
          return f.message == 'Expected string, received number'
        })
      ).to.have.lengthOf(1)
    }
  })
})

describe('Validates successfully', () => {
  test('Succeeds to validate', () => {
    const validationResult = Validator.validateSchema(
      {
        id: '123',
        content: '123',
        createdAt: new Date(),
        updatedAt: new Date(),
      },
      ViewSchema
    )
    expect(validationResult).to.not.be.an.instanceof(Response)
    expect(validationResult).to.be.true
  })
  test('Succeeds to validate null schema', () => {
    const validationResult = Validator.validateSchema(null, ViewSchema.or(z.null()))
    expect(validationResult).to.not.be.an.instanceof(Response)
    expect(validationResult).to.be.true
  })
})

export {}