// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: initial_assessment.sql

package dbgen

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const CreateAssessmentAnswer = `-- name: CreateAssessmentAnswer :exec
INSERT INTO assessment_answers (
    attempt_id,
    question_id,
    selected_option_id,
    short_answer,
    is_correct
)
VALUES (
    $1, -- attempt_id
    $2, -- question_id
    $3, -- selected_option_id
    $4, -- short_answer
    $5  -- is_correct
)
`

type CreateAssessmentAnswerParams struct {
	AttemptID        int64       `json:"attempt_id"`
	QuestionID       int64       `json:"question_id"`
	SelectedOptionID pgtype.Int8 `json:"selected_option_id"`
	ShortAnswer      pgtype.Text `json:"short_answer"`
	IsCorrect        bool        `json:"is_correct"`
}

func (q *Queries) CreateAssessmentAnswer(ctx context.Context, arg CreateAssessmentAnswerParams) error {
	_, err := q.db.Exec(ctx, CreateAssessmentAnswer,
		arg.AttemptID,
		arg.QuestionID,
		arg.SelectedOptionID,
		arg.ShortAnswer,
		arg.IsCorrect,
	)
	return err
}

const CreateAssessmentAttempt = `-- name: CreateAssessmentAttempt :one
INSERT INTO assessment_attempts (
    user_id,
    total_questions,
    correct_answers,
    score_percentage,
    knowledge_level
)
VALUES (
    $1, -- user_id
    $2, -- total_questions
    $3, -- correct_answers
    $4, -- score_percentage
    $5  -- knowledge_level
)
RETURNING
    id,
    user_id,
    total_questions,
    correct_answers,
    score_percentage,
    knowledge_level,
    completed_at
`

type CreateAssessmentAttemptParams struct {
	UserID          int64          `json:"user_id"`
	TotalQuestions  int32          `json:"total_questions"`
	CorrectAnswers  int32          `json:"correct_answers"`
	ScorePercentage pgtype.Numeric `json:"score_percentage"`
	KnowledgeLevel  string         `json:"knowledge_level"`
}

func (q *Queries) CreateAssessmentAttempt(ctx context.Context, arg CreateAssessmentAttemptParams) (AssessmentAttempt, error) {
	row := q.db.QueryRow(ctx, CreateAssessmentAttempt,
		arg.UserID,
		arg.TotalQuestions,
		arg.CorrectAnswers,
		arg.ScorePercentage,
		arg.KnowledgeLevel,
	)
	var i AssessmentAttempt
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.TotalQuestions,
		&i.CorrectAnswers,
		&i.ScorePercentage,
		&i.KnowledgeLevel,
		&i.CompletedAt,
	)
	return i, err
}

const CreateAssessmentQuestion = `-- name: CreateAssessmentQuestion :one
INSERT INTO assessment_questions (
    title,
    description,
    question_type,
    difficulty_level
)
VALUES ($1, $2, $3, $4)
RETURNING id, title, description, question_type, difficulty_level, is_active, created_at, updated_at
`

type CreateAssessmentQuestionParams struct {
	Title           string      `json:"title"`
	Description     pgtype.Text `json:"description"`
	QuestionType    string      `json:"question_type"`
	DifficultyLevel string      `json:"difficulty_level"`
}

func (q *Queries) CreateAssessmentQuestion(ctx context.Context, arg CreateAssessmentQuestionParams) (AssessmentQuestion, error) {
	row := q.db.QueryRow(ctx, CreateAssessmentQuestion,
		arg.Title,
		arg.Description,
		arg.QuestionType,
		arg.DifficultyLevel,
	)
	var i AssessmentQuestion
	err := row.Scan(
		&i.ID,
		&i.Title,
		&i.Description,
		&i.QuestionType,
		&i.DifficultyLevel,
		&i.IsActive,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateAssessmentQuestionOption = `-- name: CreateAssessmentQuestionOption :exec
INSERT INTO assessment_question_options (
    question_id,
    option_text,
    is_correct
)
VALUES ($1, $2, $3)
`

type CreateAssessmentQuestionOptionParams struct {
	QuestionID int64  `json:"question_id"`
	OptionText string `json:"option_text"`
	IsCorrect  bool   `json:"is_correct"`
}

func (q *Queries) CreateAssessmentQuestionOption(ctx context.Context, arg CreateAssessmentQuestionOptionParams) error {
	_, err := q.db.Exec(ctx, CreateAssessmentQuestionOption, arg.QuestionID, arg.OptionText, arg.IsCorrect)
	return err
}

const GetActiveAssessmentQuestions = `-- name: GetActiveAssessmentQuestions :many
SELECT id, title, description, question_type, difficulty_level, is_active, created_at, updated_at
FROM assessment_questions
WHERE is_active = TRUE
ORDER BY difficulty_level, id
`

func (q *Queries) GetActiveAssessmentQuestions(ctx context.Context) ([]AssessmentQuestion, error) {
	rows, err := q.db.Query(ctx, GetActiveAssessmentQuestions)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AssessmentQuestion
	for rows.Next() {
		var i AssessmentQuestion
		if err := rows.Scan(
			&i.ID,
			&i.Title,
			&i.Description,
			&i.QuestionType,
			&i.DifficultyLevel,
			&i.IsActive,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetAssessmentOptionByID = `-- name: GetAssessmentOptionByID :one
SELECT
    id,
    question_id,
    option_text,
    is_correct
FROM assessment_question_options
WHERE id = $1
LIMIT 1
`

func (q *Queries) GetAssessmentOptionByID(ctx context.Context, id int64) (AssessmentQuestionOption, error) {
	row := q.db.QueryRow(ctx, GetAssessmentOptionByID, id)
	var i AssessmentQuestionOption
	err := row.Scan(
		&i.ID,
		&i.QuestionID,
		&i.OptionText,
		&i.IsCorrect,
	)
	return i, err
}

const GetCorrectOptionForQuestion = `-- name: GetCorrectOptionForQuestion :one
SELECT
    id
FROM assessment_question_options
WHERE question_id = $1
  AND is_correct = TRUE
LIMIT 1
`

func (q *Queries) GetCorrectOptionForQuestion(ctx context.Context, questionID int64) (int64, error) {
	row := q.db.QueryRow(ctx, GetCorrectOptionForQuestion, questionID)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const GetLatestAssessmentAttempt = `-- name: GetLatestAssessmentAttempt :one
SELECT id, user_id, total_questions, correct_answers, score_percentage, knowledge_level, completed_at
FROM assessment_attempts
WHERE user_id = $1
ORDER BY completed_at DESC
LIMIT 1
`

func (q *Queries) GetLatestAssessmentAttempt(ctx context.Context, userID int64) (AssessmentAttempt, error) {
	row := q.db.QueryRow(ctx, GetLatestAssessmentAttempt, userID)
	var i AssessmentAttempt
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.TotalQuestions,
		&i.CorrectAnswers,
		&i.ScorePercentage,
		&i.KnowledgeLevel,
		&i.CompletedAt,
	)
	return i, err
}

const GetQuestionOptions = `-- name: GetQuestionOptions :many
SELECT id, question_id, option_text, is_correct
FROM assessment_question_options
WHERE question_id = $1
`

func (q *Queries) GetQuestionOptions(ctx context.Context, questionID int64) ([]AssessmentQuestionOption, error) {
	rows, err := q.db.Query(ctx, GetQuestionOptions, questionID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AssessmentQuestionOption
	for rows.Next() {
		var i AssessmentQuestionOption
		if err := rows.Scan(
			&i.ID,
			&i.QuestionID,
			&i.OptionText,
			&i.IsCorrect,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}