import type { HttpContext } from '@adonisjs/core/http'
import Keyword from '#models/keyword'

export default class KeywordsController {
  /**
   * List keywords by user_id with optional filtering by is_active
   * GET /api/keywords?user_id=1&is_active=true
   */
  async index({ request, response }: HttpContext) {
    const userId = request.input('user_id')
    const isActive = request.input('is_active')

    if (!userId) {
      return response.badRequest({
        error: 'user_id query parameter is required',
      })
    }

    const query = Keyword.query().where('user_id', userId)

    if (isActive !== undefined) {
      const activeValue = isActive === 'true' || isActive === true
      query.where('is_active', activeValue)
    }

    const keywords = await query.orderBy('created_at', 'desc')

    return response.ok(keywords)
  }

  /**
   * Create a new keyword
   * POST /api/keywords
   * Body: { user_id: number, keyword: string, case_sensitive?: boolean }
   */
  async store({ request, response }: HttpContext) {
    const userId = request.input('user_id')
    const keyword = request.input('keyword')
    const caseSensitive = request.input('case_sensitive', false)

    if (!userId || !keyword) {
      return response.badRequest({
        error: 'user_id and keyword are required',
      })
    }

    if (typeof keyword !== 'string' || keyword.trim().length === 0) {
      return response.badRequest({
        error: 'keyword must be a non-empty string',
      })
    }

    try {
      const newKeyword = await Keyword.create({
        userId,
        keyword: keyword.trim(),
        caseSensitive,
        isActive: true,
      })

      return response.created(newKeyword)
    } catch (error) {
      return response.internalServerError({
        error: 'Failed to create keyword',
        message: error instanceof Error ? error.message : 'Unknown error',
      })
    }
  }

  /**
   * Delete a keyword by id
   * DELETE /api/keywords/:id
   */
  async destroy({ params, response }: HttpContext) {
    const keywordId = params.id

    if (!keywordId || isNaN(Number(keywordId))) {
      return response.badRequest({
        error: 'Invalid keyword id',
      })
    }

    try {
      const keyword = await Keyword.findOrFail(keywordId)
      await keyword.delete()

      return response.noContent()
    } catch (error) {
      if (error.code === 'E_ROW_NOT_FOUND') {
        return response.notFound({
          error: 'Keyword not found',
        })
      }

      return response.internalServerError({
        error: 'Failed to delete keyword',
        message: error instanceof Error ? error.message : 'Unknown error',
      })
    }
  }
}