import { HttpContext } from '@adonisjs/core/http'
import { addSearchFilter, searchableColumns } from '#services/database_inspector'
import Role from '#base_modules/Role/model/role'
import RolePolicy from '#base_modules/Role/policy/role_policy'
import { createRoleValidator } from '#base_modules/Role/validator/role_create_validator'
import { updateRoleValidator } from '#base_modules/Role/validator/role_update_validator'
import db from '@adonisjs/lucid/services/db'

export default class RoleController {
  public async index({ request, response, bouncer }: HttpContext) {
    await bouncer.with(RolePolicy).authorize('roleList')
    const {
      page = 1,
      perPage = 10,
      search = null,
      sortBy = 'id',
      sortOrder = 'desc',
    } = request.all()
    const query = Role.query()
    if (search) {
      const columns = Role.searchable || (await searchableColumns('admins'))
      addSearchFilter(query, columns, search)
    }
    const result = await query.orderBy(sortBy, sortOrder).paginate(page, perPage)
    return response.ok(result)
  }

  public async store({ request, response, bouncer }: HttpContext) {
    await bouncer.with(RolePolicy).authorize('createRole')
    const { permissions, ...data } = await createRoleValidator.validate(request.all())
    const record = await Role.create(data)
    if (record) {
      // await record.related('permissions').sync(data.permissions)
      await this.updatePermissions(record, permissions)
      return response.created({ message: 'Successfully created.' })
    }
    return response.badRequest({ message: 'Cannot create.' })
  }

  public async show({ request, response, bouncer }: HttpContext) {
    await bouncer.with(RolePolicy).authorize('viewRole')
    const { id } = request.params()
    if (!id) return response.notFound({ message: 'Not found.' })
    const record = await Role.find(id)
    if (!record) return response.notFound({ message: 'Not found.' })
    const permissions = await db
      .from('role_permissions')
      .where('role_id', id)
      .select(['permission_slug as slug', 'role_id'])
    return response.ok({ ...record.serialize(), permissions })
  }

  public async update({ request, response, bouncer }: HttpContext) {
    await bouncer.with(RolePolicy).authorize('updateRole')
    const { id } = request.params()
    if (!id) return response.notFound({ message: 'Not found.' })
    const data = await updateRoleValidator.validate(request.all())
    const record = await Role.find(id)
    if (!record) return response.notFound({ message: 'Not found.' })
    record.name = data.name
    await record.save()
    await this.updatePermissions(record, data.permissions)
    return response.ok({ message: 'Updated.' })
  }

  public async destroy({ request, response, bouncer }: HttpContext) {
    await bouncer.with(RolePolicy).authorize('deleteRole')
    const { id } = request.params()
    if (!id) return response.notFound({ message: 'Not found.' })
    const record = await Role.find(id)
    if (!record) return response.notFound({ message: 'Not found.' })
    await Role.query().where('id', id).delete()
    return response.ok({ message: 'Deleted.' })
  }

  private async updatePermissions(record: Role, permissions?: string[]) {
    await db.from('role_permissions').where('role_id', record.id).delete()
    if (!permissions || permissions.length === 0) {
      console.log('no permissions to insert')
      return
    }
    const newPermissions = permissions.map((perm) => ({
      role_id: record.id,
      permission_slug: perm,
    }))
    await db.table('role_permissions').insert(newPermissions)
    console.log('inserted permissions:', newPermissions.length)
  }
}