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

package dbgen

import (
	"context"

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

const AddSubCoursePrerequisite = `-- name: AddSubCoursePrerequisite :one
INSERT INTO sub_course_prerequisites (sub_course_id, prerequisite_sub_course_id)
VALUES ($1, $2)
RETURNING id, sub_course_id, prerequisite_sub_course_id, created_at
`

type AddSubCoursePrerequisiteParams struct {
	SubCourseID             int64 `json:"sub_course_id"`
	PrerequisiteSubCourseID int64 `json:"prerequisite_sub_course_id"`
}

func (q *Queries) AddSubCoursePrerequisite(ctx context.Context, arg AddSubCoursePrerequisiteParams) (SubCoursePrerequisite, error) {
	row := q.db.QueryRow(ctx, AddSubCoursePrerequisite, arg.SubCourseID, arg.PrerequisiteSubCourseID)
	var i SubCoursePrerequisite
	err := row.Scan(
		&i.ID,
		&i.SubCourseID,
		&i.PrerequisiteSubCourseID,
		&i.CreatedAt,
	)
	return i, err
}

const CountUnmetPrerequisites = `-- name: CountUnmetPrerequisites :one
SELECT COUNT(*)::bigint AS unmet_count
FROM sub_course_prerequisites p
WHERE p.sub_course_id = $1
  AND p.prerequisite_sub_course_id NOT IN (
      SELECT usp.sub_course_id
      FROM user_sub_course_progress usp
      WHERE usp.user_id = $2
        AND usp.status = 'COMPLETED'
  )
`

type CountUnmetPrerequisitesParams struct {
	SubCourseID int64 `json:"sub_course_id"`
	UserID      int64 `json:"user_id"`
}

func (q *Queries) CountUnmetPrerequisites(ctx context.Context, arg CountUnmetPrerequisitesParams) (int64, error) {
	row := q.db.QueryRow(ctx, CountUnmetPrerequisites, arg.SubCourseID, arg.UserID)
	var unmet_count int64
	err := row.Scan(&unmet_count)
	return unmet_count, err
}

const DeleteAllPrerequisitesForSubCourse = `-- name: DeleteAllPrerequisitesForSubCourse :exec
DELETE FROM sub_course_prerequisites
WHERE sub_course_id = $1
`

func (q *Queries) DeleteAllPrerequisitesForSubCourse(ctx context.Context, subCourseID int64) error {
	_, err := q.db.Exec(ctx, DeleteAllPrerequisitesForSubCourse, subCourseID)
	return err
}

const GetSubCourseDependents = `-- name: GetSubCourseDependents :many
SELECT
    p.id,
    p.sub_course_id,
    p.prerequisite_sub_course_id,
    p.created_at,
    sc.title AS dependent_title,
    sc.level AS dependent_level
FROM sub_course_prerequisites p
JOIN sub_courses sc ON sc.id = p.sub_course_id
WHERE p.prerequisite_sub_course_id = $1
ORDER BY sc.display_order
`

type GetSubCourseDependentsRow struct {
	ID                      int64              `json:"id"`
	SubCourseID             int64              `json:"sub_course_id"`
	PrerequisiteSubCourseID int64              `json:"prerequisite_sub_course_id"`
	CreatedAt               pgtype.Timestamptz `json:"created_at"`
	DependentTitle          string             `json:"dependent_title"`
	DependentLevel          string             `json:"dependent_level"`
}

func (q *Queries) GetSubCourseDependents(ctx context.Context, prerequisiteSubCourseID int64) ([]GetSubCourseDependentsRow, error) {
	rows, err := q.db.Query(ctx, GetSubCourseDependents, prerequisiteSubCourseID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetSubCourseDependentsRow
	for rows.Next() {
		var i GetSubCourseDependentsRow
		if err := rows.Scan(
			&i.ID,
			&i.SubCourseID,
			&i.PrerequisiteSubCourseID,
			&i.CreatedAt,
			&i.DependentTitle,
			&i.DependentLevel,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetSubCoursePrerequisites = `-- name: GetSubCoursePrerequisites :many
SELECT
    p.id,
    p.sub_course_id,
    p.prerequisite_sub_course_id,
    p.created_at,
    sc.title AS prerequisite_title,
    sc.level AS prerequisite_level,
    sc.display_order AS prerequisite_display_order
FROM sub_course_prerequisites p
JOIN sub_courses sc ON sc.id = p.prerequisite_sub_course_id
WHERE p.sub_course_id = $1
ORDER BY sc.display_order
`

type GetSubCoursePrerequisitesRow struct {
	ID                       int64              `json:"id"`
	SubCourseID              int64              `json:"sub_course_id"`
	PrerequisiteSubCourseID  int64              `json:"prerequisite_sub_course_id"`
	CreatedAt                pgtype.Timestamptz `json:"created_at"`
	PrerequisiteTitle        string             `json:"prerequisite_title"`
	PrerequisiteLevel        string             `json:"prerequisite_level"`
	PrerequisiteDisplayOrder int32              `json:"prerequisite_display_order"`
}

func (q *Queries) GetSubCoursePrerequisites(ctx context.Context, subCourseID int64) ([]GetSubCoursePrerequisitesRow, error) {
	rows, err := q.db.Query(ctx, GetSubCoursePrerequisites, subCourseID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetSubCoursePrerequisitesRow
	for rows.Next() {
		var i GetSubCoursePrerequisitesRow
		if err := rows.Scan(
			&i.ID,
			&i.SubCourseID,
			&i.PrerequisiteSubCourseID,
			&i.CreatedAt,
			&i.PrerequisiteTitle,
			&i.PrerequisiteLevel,
			&i.PrerequisiteDisplayOrder,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const RemoveSubCoursePrerequisite = `-- name: RemoveSubCoursePrerequisite :exec
DELETE FROM sub_course_prerequisites
WHERE sub_course_id = $1 AND prerequisite_sub_course_id = $2
`

type RemoveSubCoursePrerequisiteParams struct {
	SubCourseID             int64 `json:"sub_course_id"`
	PrerequisiteSubCourseID int64 `json:"prerequisite_sub_course_id"`
}

func (q *Queries) RemoveSubCoursePrerequisite(ctx context.Context, arg RemoveSubCoursePrerequisiteParams) error {
	_, err := q.db.Exec(ctx, RemoveSubCoursePrerequisite, arg.SubCourseID, arg.PrerequisiteSubCourseID)
	return err
}