package quiz_controller

import (
	"net/http"
	"strconv"

	"api.qobiltu.id/middleware"
	"api.qobiltu.id/models"
	"api.qobiltu.id/response"
	"api.qobiltu.id/services"
	"github.com/gin-gonic/gin"
)

type QuizController interface {
	// === ADMIN ===

	// === USER ===
	UserGetQuiz(ctx *gin.Context)
	UserAttemptQuiz(ctx *gin.Context)
	UserGetQuestionQuiz(ctx *gin.Context)
	UserAnswerQuiz(ctx *gin.Context)
	UserSubmitQuiz(ctx *gin.Context)
	UserResultQuiz(ctx *gin.Context)
	UserReviewQuiz(ctx *gin.Context)
}

type quizController struct {
	quizService services.QuizService
}

func NewQuizController(quizService services.QuizService) QuizController {
	return &quizController{
		quizService: quizService,
	}
}

func (c *quizController) UserGetQuiz(ctx *gin.Context) {
	academyID := ctx.Query("academy_id")
	academyIDInt, err := strconv.Atoi(academyID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	accountData := middleware.GetAccountData(ctx)

	req := models.UserGetQuizRequest{
		AccountID: int64(accountData.UserID),
		AcademyID: int64(academyIDInt),
	}

	res, err := c.quizService.UserGetQuiz(ctx, &req)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	response.HandleSuccess(ctx, http.StatusOK, "Quiz retrieved successfully", res, nil)
}

func (c *quizController) UserAttemptQuiz(ctx *gin.Context) {
	academyID := ctx.Query("academy_id")
	academyIDInt, err := strconv.Atoi(academyID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	accountData := middleware.GetAccountData(ctx)

	req := models.UserAttemptQuizRequest{
		AccountID: int64(accountData.UserID),
		AcademyID: int64(academyIDInt),
	}

	res, err := c.quizService.UserAttemptQuiz(ctx, &req)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	response.HandleSuccess(ctx, http.StatusOK, "Quiz attempt retrieved successfully", res, nil)
}

func (c *quizController) UserGetQuestionQuiz(ctx *gin.Context) {
	academyID := ctx.Query("academy_id")
	academyIDInt, err := strconv.Atoi(academyID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	questionID := ctx.Query("question_id")
	questionIDInt, err := strconv.Atoi(questionID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	attemptID := ctx.Query("attempt_id")
	attemptIDInt, err := strconv.Atoi(attemptID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	accountData := middleware.GetAccountData(ctx)

	req := models.GetQuestionQuizRequest{
		AccountID:  int64(accountData.UserID),
		AcademyID:  int64(academyIDInt),
		QuestionID: int64(questionIDInt),
		AttemptID:  int64(attemptIDInt),
	}

	res, err := c.quizService.UserGetQuestionQuiz(ctx, &req)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	response.HandleSuccess(ctx, http.StatusOK, "Question retrieved successfully", res, nil)
}

func (c *quizController) UserAnswerQuiz(ctx *gin.Context) {
	var req models.AnswerQuizRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		response.HandleError(ctx, err)
		return
	}

	academyID := ctx.Query("academy_id")
	academyIDInt, err := strconv.Atoi(academyID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	attemptID := ctx.Query("attempt_id")
	attemptIDInt, err := strconv.Atoi(attemptID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	accountData := middleware.GetAccountData(ctx)

	req.AccountID = int64(accountData.UserID)
	req.AcademyID = int64(academyIDInt)
	req.AttemptID = int64(attemptIDInt)

	res, err := c.quizService.UserAnswerQuiz(ctx, &req)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	response.HandleSuccess(ctx, http.StatusOK, "Question retrieved successfully", res, nil)
}

func (c *quizController) UserSubmitQuiz(ctx *gin.Context) {
	academyID := ctx.Query("academy_id")
	academyIDInt, err := strconv.Atoi(academyID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	attemptID := ctx.Query("attempt_id")
	attemptIDInt, err := strconv.Atoi(attemptID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	accountData := middleware.GetAccountData(ctx)

	req := models.SubmitQuizRequest{
		AccountID: int64(accountData.UserID),
		AcademyID: int64(academyIDInt),
		AttemptID: int64(attemptIDInt),
	}

	res, err := c.quizService.UserSubmitQuiz(ctx, &req)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	response.HandleSuccess(ctx, http.StatusOK, "Quiz submitted successfully", res, nil)
}

func (c *quizController) UserResultQuiz(ctx *gin.Context) {
	academyID := ctx.Query("academy_id")
	academyIDInt, err := strconv.Atoi(academyID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	accountData := middleware.GetAccountData(ctx)
	req := models.ResultQuizRequest{
		AccountID: int64(accountData.UserID),
		AcademyID: int64(academyIDInt),
	}

	res, err := c.quizService.UserResultQuiz(ctx, &req)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	response.HandleSuccess(ctx, http.StatusOK, "Quiz submitted successfully", res, nil)
}

func (c *quizController) UserReviewQuiz(ctx *gin.Context) {
	academyID := ctx.Query("academy_id")
	academyIDInt, err := strconv.Atoi(academyID)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	accountData := middleware.GetAccountData(ctx)

	req := models.ReviewQuizRequest{
		AccountID: int64(accountData.UserID),
		AcademyID: int64(academyIDInt),
	}

	res, err := c.quizService.UserReviewQuiz(ctx, &req)
	if err != nil {
		response.HandleError(ctx, err)
		return
	}

	response.HandleSuccess(ctx, http.StatusOK, "Quiz review retrieved successfully", res.Reviews, nil)
}