import { SubjectService } from '#services/subject_service'
import { updateUserValidator, matchStudentValidator, mergeStudentValidator } from '#validators/user'
import { inject } from '@adonisjs/core'
import type { HttpContext } from '@adonisjs/core/http'
import User from '#models/user'

@inject()
export default class UserController {
  constructor(private subjectService: SubjectService) {}

  // GET /users/@me
  async me({ auth }: HttpContext) {
    const user = auth.user!
    return {
      success: true,
      data: {
        ...user.serialize(),
        firstName: user.firstName,
        lastName: user.lastName,
        email: user.email,
        preferences: user.preferences,
        pastStudentId: user.pastStudentId,
      },
    }
  }

  // POST /users/@me
  // Update user preferences (for subjects)
  async update({ request, response, auth }: HttpContext) {
    const user = auth.user!
    const { preferences: data } = await request.validateUsing(updateUserValidator)
    const preferences = user.extras?.preferences || []

    // Validate subject names
    const validSubjects = await this.subjectService.getAll(user.className)
    for (const { name, emoji, color } of data) {
      if (!validSubjects.includes(name)) {
        return response.badRequest({
          message: `Invalid subject name: ${name}`,
        })
      }
      const existing = preferences.find((p: any) => p.name === name)
      if (existing) {
        // Update
        existing.emoji = emoji
        existing.color = color
      } else {
        // Create new preference
        preferences.push({ name, emoji, color })
      }
    }

    user.extras = {
      ...user.extras,
      preferences,
    }
    await user.save()
    return {
      success: true,
      data: {
        ...user.serialize(),
        firstName: user.firstName,
        lastName: user.lastName,
        email: user.email,
        preferences: user.preferences,
        pastStudentId: user.pastStudentId,
      },
    }
  }

  // GET /match-student
  async matchStudent({ request, response }: HttpContext) {
    const { firstName, lastName, classId } = await request.validateUsing(matchStudentValidator)

    const user = await User.query()
      .where('firstName', firstName)
      .andWhere('lastName', lastName)
      .andWhere('className', classId)
      .first()

    if (!user) {
      return response.notFound({ message: 'User not found' })
    }

    return {
      success: true,
      data: {
        ...user.serialize(),
        preferences: user.preferences,
        pastStudentId: user.pastStudentId,
      },
    }
  }

  // POST /merge-student
  async mergeStudent({ request, auth }: HttpContext) {
    const user = auth.user!
    const { pastStudentId } = await request.validateUsing(mergeStudentValidator)

    user.pastStudentId = pastStudentId
    await user.save()

    return {
      success: true,
      data: {
        ...user.serialize(),
        preferences: user.preferences,
        pastStudentId: user.pastStudentId,
      },
    }
  }
}