import { HttpContext } from '@adonisjs/core/http'
import { createAdminValidator } from '#base_modules/Admin/validators/admin_create_validator'
import { updateAdminValidator } from '#base_modules/Admin/validators/admin_update_validator'
import { addSearchFilter, searchableColumns } from '#services/database_inspector'
import Admins from '#base_modules/Admin/model/admin'
import AdminsPolicy from '#base_modules/Admin/policy/admin_policy'
import { updateProfileAdminValidator } from '#base_modules/Admin/validators/admin_update_profile_validator'
import db from '@adonisjs/lucid/services/db'

export default class AdminsController {
  public async index({ request, response, bouncer }: HttpContext) {
    await bouncer.with(AdminsPolicy).authorize('viewList')
    const {
      page = 1,
      perPage = 10,
      search = null,
      sortBy = 'id',
      sortOrder = 'desc',
    } = request.all()
    const query = Admins.query()
    if (search) {
      const columns = Admins.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(AdminsPolicy).authorize('create')
    const data = await createAdminValidator.validate(request.all())
    const record = await Admins.create(data)
    if (record) {
      await record.related('roles').sync(data.roles)
      return response.created({ message: 'Successfully created.' })
    }
    return response.badRequest({ message: 'Cannot create.' })
  }

  public async show({ request, response, bouncer }: HttpContext) {
    await bouncer.with(AdminsPolicy).authorize('view')
    const { id } = request.params()
    if (!id) return response.notFound({ message: 'Not found.' })
    const record = await Admins.find(id)
    if (!record) return response.notFound({ message: 'Not found.' })
    await record.load('roles')
    return response.ok(record)
  }

  public async update({ request, response, bouncer }: HttpContext) {
    await bouncer.with(AdminsPolicy).authorize('update')
    const { id } = request.params()
    if (!id) return response.notFound({ message: 'Not found.' })
    const data = await updateAdminValidator.validate(request.all())
    const record = await Admins.find(id)
    if (!record) return response.notFound({ message: 'Not found.' })
    record.merge(data)
    await record.save()
    await record.related('roles').sync(data.roles)
    return response.ok({ message: 'Updated.' })
  }

  public async destroy({ request, response, bouncer }: HttpContext) {
    await bouncer.with(AdminsPolicy).authorize('delete')
    const { id } = request.params()
    if (!id) return response.notFound({ message: 'Not found.' })
    const admins = await Admins.all()
    if (admins.length === 1) {
      return response.badRequest({ message: "Last Admin can't be deleted!" })
    }
    const record = await Admins.find(id)
    if (!record) return response.notFound({ message: 'Not found.' })
    await Admins.query().where('id', id).delete()
    return response.ok({ message: 'Deleted.' })
  }

  public async updateProfile({ request, response, auth }: HttpContext) {
    const user = auth.use('api').user
    if (!user) return response.unauthorized()
    const data = await updateProfileAdminValidator.validate(request.all())
    user.merge(data)
    user.save()
    await user.load('roles')
    const roles = user.roles.map((role) => role.id)
    const permissions = await db
      .from('role_permissions')
      .whereIn('role_id', roles)
      .select('permission_slug')
    return response.ok({ user, permissions: permissions.map((perm) => perm.permission_slug) })
  }
}