import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
import Employee from 'App/Models/Employee'
import UpdateEmployeeValidator from 'App/Validators/UpdateEmployeeValidator'
import CreateEmployeeValidator from 'App/Validators/CreateEmployeeValidator'

import Database from '@ioc:Adonis/Lucid/Database'
import Logger from '@ioc:Adonis/Core/Logger'

// TODO: #1 Implement paginator for Employee-Index
export default class EmployeesController {
  public async index ({bouncer, request}: HttpContextContract) {
    await bouncer.authorize('employees.index')

    const limit: number = request.qs().limit ?? 10
    const page: number = request.qs().page ?? 1
    const sort_by = await this.sort_by(request.qs().sort_by)

    const employees = await Database.from('employees').orderBy(sort_by).paginate(page, limit)

    return employees
  }

  public async store ({request}: HttpContextContract) {
    try {
      const payload = await request.validate(CreateEmployeeValidator)

      return await Employee.create({
        firstName: payload.firstName,
        lastName: payload.lastName,
        shorthand: payload.shorthand,
        email: payload.email,
        phone: payload.phone,
        mobile: payload.mobile,
        contractHours: payload.contractHours,
      })

    } catch (error) {
      return error
    }

  }

  public async show ({params, bouncer}: HttpContextContract) { 
    const emp = await Employee.findOrFail(params.id)

    await bouncer.authorize('employees.show', emp)

    return emp
  }

  public async update ({params, bouncer, response, request}: HttpContextContract) {

    const employee : Employee = await Employee.findOrFail(params.id)
    const editContractHours : boolean = employee.contractHours !== request.input('contractHours')

    await bouncer.authorize('employees.update', editContractHours, employee)

    const payload = await request.validate(UpdateEmployeeValidator)
   
    if (editContractHours){
      employee.contractHours = payload.contractHours ?? 0
    }

    employee.firstName = payload.firstName
    employee.lastName = payload.lastName ?? ''      
    employee.shorthand = payload.shorthand
    employee.email = payload.email ?? ''
    employee.phone = payload.phone ?? ''
    employee.mobile = payload.mobile ?? ''

    await employee.save()
      
    return response.ok({
      status: 200,
      message: "Employee updated successfully"
    })
  }

  public async destroy ({params, bouncer}: HttpContextContract) {
    await bouncer.authorize('employees.destroy')

    return await Database.from('employees').where('id', params.id).delete()
  }

  private async sort_by(qs: string): Promise<{column : string, order?: 'asc' | 'desc' | undefined}[]> {
    const regex : RegExp = /(asc|desc)\((\w+)\)/gi
    const client = Database.connection()
    let result: {
      column: string, 
      order?: 'asc' | 'desc' | undefined
    }[] = []

    const columns = await client.columnsInfo('employees')
    const match = qs?.matchAll(regex) ?? []
    
    for (const item of match) {
      if( columns.hasOwnProperty(item[2]) && (item[1] === 'asc' || item[1] === 'desc')) result.push({column: item[2], order: item[1]})
    }

    if(result.length === 0) result.push({column: 'last_name'})

    return result
  }
}