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

package dbgen

import (
	"context"

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

const CreateCourseSubCategory = `-- name: CreateCourseSubCategory :one
INSERT INTO course_sub_categories (
    category_id,
    name,
    description,
    display_order,
    is_active
)
VALUES ($1, $2, $3, COALESCE($4, 0), COALESCE($5, TRUE))
RETURNING id, category_id, name, description, is_active, display_order, created_at
`

type CreateCourseSubCategoryParams struct {
	CategoryID  int64       `json:"category_id"`
	Name        string      `json:"name"`
	Description pgtype.Text `json:"description"`
	Column4     interface{} `json:"column_4"`
	Column5     interface{} `json:"column_5"`
}

func (q *Queries) CreateCourseSubCategory(ctx context.Context, arg CreateCourseSubCategoryParams) (CourseSubCategory, error) {
	row := q.db.QueryRow(ctx, CreateCourseSubCategory,
		arg.CategoryID,
		arg.Name,
		arg.Description,
		arg.Column4,
		arg.Column5,
	)
	var i CourseSubCategory
	err := row.Scan(
		&i.ID,
		&i.CategoryID,
		&i.Name,
		&i.Description,
		&i.IsActive,
		&i.DisplayOrder,
		&i.CreatedAt,
	)
	return i, err
}

const CreateLevel = `-- name: CreateLevel :one
INSERT INTO levels (
    course_id,
    cefr_level,
    title,
    description,
    thumbnail,
    display_order,
    is_active
)
VALUES ($1, $2, $3, $4, $5, COALESCE($6, 0), COALESCE($7, TRUE))
RETURNING id, course_id, cefr_level, display_order, is_active, created_at, title, description, thumbnail
`

type CreateLevelParams struct {
	CourseID    int64       `json:"course_id"`
	CefrLevel   string      `json:"cefr_level"`
	Title       string      `json:"title"`
	Description pgtype.Text `json:"description"`
	Thumbnail   pgtype.Text `json:"thumbnail"`
	Column6     interface{} `json:"column_6"`
	Column7     interface{} `json:"column_7"`
}

func (q *Queries) CreateLevel(ctx context.Context, arg CreateLevelParams) (Level, error) {
	row := q.db.QueryRow(ctx, CreateLevel,
		arg.CourseID,
		arg.CefrLevel,
		arg.Title,
		arg.Description,
		arg.Thumbnail,
		arg.Column6,
		arg.Column7,
	)
	var i Level
	err := row.Scan(
		&i.ID,
		&i.CourseID,
		&i.CefrLevel,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.Title,
		&i.Description,
		&i.Thumbnail,
	)
	return i, err
}

const CreateModule = `-- name: CreateModule :one
INSERT INTO modules (
    level_id,
    title,
    description,
    icon_url,
    display_order,
    is_active
)
VALUES ($1, $2, $3, $4, COALESCE($5, 0), COALESCE($6, TRUE))
RETURNING id, level_id, title, description, display_order, is_active, created_at, icon_url
`

type CreateModuleParams struct {
	LevelID     int64       `json:"level_id"`
	Title       string      `json:"title"`
	Description pgtype.Text `json:"description"`
	IconUrl     pgtype.Text `json:"icon_url"`
	Column5     interface{} `json:"column_5"`
	Column6     interface{} `json:"column_6"`
}

func (q *Queries) CreateModule(ctx context.Context, arg CreateModuleParams) (Module, error) {
	row := q.db.QueryRow(ctx, CreateModule,
		arg.LevelID,
		arg.Title,
		arg.Description,
		arg.IconUrl,
		arg.Column5,
		arg.Column6,
	)
	var i Module
	err := row.Scan(
		&i.ID,
		&i.LevelID,
		&i.Title,
		&i.Description,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.IconUrl,
	)
	return i, err
}

const CreateModuleCapstone = `-- name: CreateModuleCapstone :one
INSERT INTO module_capstones (
    module_id,
    title,
    description,
    tips,
    thumbnail,
    question_set_id,
    display_order,
    is_active
)
VALUES ($1, $2, $3, $4, $5, $6, COALESCE($7, 0), COALESCE($8, TRUE))
RETURNING id, module_id, title, description, tips, thumbnail, question_set_id, display_order, is_active, created_at
`

type CreateModuleCapstoneParams struct {
	ModuleID      int64       `json:"module_id"`
	Title         string      `json:"title"`
	Description   pgtype.Text `json:"description"`
	Tips          pgtype.Text `json:"tips"`
	Thumbnail     pgtype.Text `json:"thumbnail"`
	QuestionSetID int64       `json:"question_set_id"`
	Column7       interface{} `json:"column_7"`
	Column8       interface{} `json:"column_8"`
}

func (q *Queries) CreateModuleCapstone(ctx context.Context, arg CreateModuleCapstoneParams) (ModuleCapstone, error) {
	row := q.db.QueryRow(ctx, CreateModuleCapstone,
		arg.ModuleID,
		arg.Title,
		arg.Description,
		arg.Tips,
		arg.Thumbnail,
		arg.QuestionSetID,
		arg.Column7,
		arg.Column8,
	)
	var i ModuleCapstone
	err := row.Scan(
		&i.ID,
		&i.ModuleID,
		&i.Title,
		&i.Description,
		&i.Tips,
		&i.Thumbnail,
		&i.QuestionSetID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
	)
	return i, err
}

const CreateSubModule = `-- name: CreateSubModule :one
INSERT INTO sub_modules (
    module_id,
    title,
    description,
    thumbnail,
    tips,
    display_order,
    is_active
)
VALUES ($1, $2, $3, $4, $5, COALESCE($6, 0), COALESCE($7, TRUE))
RETURNING id, module_id, title, description, display_order, is_active, created_at, legacy_sub_course_id, thumbnail, tips
`

type CreateSubModuleParams struct {
	ModuleID    int64       `json:"module_id"`
	Title       string      `json:"title"`
	Description pgtype.Text `json:"description"`
	Thumbnail   pgtype.Text `json:"thumbnail"`
	Tips        pgtype.Text `json:"tips"`
	Column6     interface{} `json:"column_6"`
	Column7     interface{} `json:"column_7"`
}

func (q *Queries) CreateSubModule(ctx context.Context, arg CreateSubModuleParams) (SubModule, error) {
	row := q.db.QueryRow(ctx, CreateSubModule,
		arg.ModuleID,
		arg.Title,
		arg.Description,
		arg.Thumbnail,
		arg.Tips,
		arg.Column6,
		arg.Column7,
	)
	var i SubModule
	err := row.Scan(
		&i.ID,
		&i.ModuleID,
		&i.Title,
		&i.Description,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.LegacySubCourseID,
		&i.Thumbnail,
		&i.Tips,
	)
	return i, err
}

const CreateSubModuleCapstone = `-- name: CreateSubModuleCapstone :one
INSERT INTO sub_module_capstones (
    sub_module_id,
    title,
    description,
    tips,
    thumbnail,
    question_set_id,
    display_order,
    is_active,
    inactive_since
)
VALUES ($1, $2, $3, $4, $5, $6, COALESCE($7, 0), COALESCE($8, TRUE), CASE WHEN COALESCE($8, TRUE) THEN NULL ELSE NOW() END)
RETURNING id, sub_module_id, title, description, tips, thumbnail, question_set_id, display_order, is_active, created_at, inactive_since
`

type CreateSubModuleCapstoneParams struct {
	SubModuleID   int64       `json:"sub_module_id"`
	Title         string      `json:"title"`
	Description   pgtype.Text `json:"description"`
	Tips          pgtype.Text `json:"tips"`
	Thumbnail     pgtype.Text `json:"thumbnail"`
	QuestionSetID int64       `json:"question_set_id"`
	Column7       interface{} `json:"column_7"`
	Column8       interface{} `json:"column_8"`
}

func (q *Queries) CreateSubModuleCapstone(ctx context.Context, arg CreateSubModuleCapstoneParams) (SubModuleCapstone, error) {
	row := q.db.QueryRow(ctx, CreateSubModuleCapstone,
		arg.SubModuleID,
		arg.Title,
		arg.Description,
		arg.Tips,
		arg.Thumbnail,
		arg.QuestionSetID,
		arg.Column7,
		arg.Column8,
	)
	var i SubModuleCapstone
	err := row.Scan(
		&i.ID,
		&i.SubModuleID,
		&i.Title,
		&i.Description,
		&i.Tips,
		&i.Thumbnail,
		&i.QuestionSetID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.InactiveSince,
	)
	return i, err
}

const CreateSubModuleLesson = `-- name: CreateSubModuleLesson :one
INSERT INTO sub_module_lessons (
    sub_module_id,
    title,
    description,
    thumbnail,
    teaching_text,
    teaching_image_url,
    teaching_audio_url,
    teaching_video_url,
    display_order,
    is_active,
    inactive_since
)
VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6,
    $7,
    $8,
    COALESCE($9, 0),
    COALESCE($10, TRUE),
    CASE WHEN COALESCE($10, TRUE) THEN NULL ELSE NOW() END
)
RETURNING id, sub_module_id, display_order, is_active, created_at, title, description, thumbnail, teaching_text, teaching_image_url, teaching_audio_url, teaching_video_url, inactive_since
`

type CreateSubModuleLessonParams struct {
	SubModuleID      int64       `json:"sub_module_id"`
	Title            string      `json:"title"`
	Description      pgtype.Text `json:"description"`
	Thumbnail        pgtype.Text `json:"thumbnail"`
	TeachingText     pgtype.Text `json:"teaching_text"`
	TeachingImageUrl pgtype.Text `json:"teaching_image_url"`
	TeachingAudioUrl pgtype.Text `json:"teaching_audio_url"`
	TeachingVideoUrl pgtype.Text `json:"teaching_video_url"`
	Column9          interface{} `json:"column_9"`
	Column10         interface{} `json:"column_10"`
}

func (q *Queries) CreateSubModuleLesson(ctx context.Context, arg CreateSubModuleLessonParams) (SubModuleLesson, error) {
	row := q.db.QueryRow(ctx, CreateSubModuleLesson,
		arg.SubModuleID,
		arg.Title,
		arg.Description,
		arg.Thumbnail,
		arg.TeachingText,
		arg.TeachingImageUrl,
		arg.TeachingAudioUrl,
		arg.TeachingVideoUrl,
		arg.Column9,
		arg.Column10,
	)
	var i SubModuleLesson
	err := row.Scan(
		&i.ID,
		&i.SubModuleID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.Title,
		&i.Description,
		&i.Thumbnail,
		&i.TeachingText,
		&i.TeachingImageUrl,
		&i.TeachingAudioUrl,
		&i.TeachingVideoUrl,
		&i.InactiveSince,
	)
	return i, err
}

const CreateSubModulePractice = `-- name: CreateSubModulePractice :one
INSERT INTO sub_module_practices (
    sub_module_id,
    title,
    description,
    thumbnail,
    intro_video_url,
    question_set_id,
    display_order,
    is_active,
    inactive_since
)
VALUES ($1, $2, $3, $4, $5, $6, COALESCE($7, 0), COALESCE($8, TRUE), CASE WHEN COALESCE($8, TRUE) THEN NULL ELSE NOW() END)
RETURNING id, sub_module_id, question_set_id, intro_video_url, display_order, is_active, created_at, title, description, thumbnail, inactive_since
`

type CreateSubModulePracticeParams struct {
	SubModuleID   int64       `json:"sub_module_id"`
	Title         string      `json:"title"`
	Description   pgtype.Text `json:"description"`
	Thumbnail     pgtype.Text `json:"thumbnail"`
	IntroVideoUrl pgtype.Text `json:"intro_video_url"`
	QuestionSetID int64       `json:"question_set_id"`
	Column7       interface{} `json:"column_7"`
	Column8       interface{} `json:"column_8"`
}

func (q *Queries) CreateSubModulePractice(ctx context.Context, arg CreateSubModulePracticeParams) (SubModulePractice, error) {
	row := q.db.QueryRow(ctx, CreateSubModulePractice,
		arg.SubModuleID,
		arg.Title,
		arg.Description,
		arg.Thumbnail,
		arg.IntroVideoUrl,
		arg.QuestionSetID,
		arg.Column7,
		arg.Column8,
	)
	var i SubModulePractice
	err := row.Scan(
		&i.ID,
		&i.SubModuleID,
		&i.QuestionSetID,
		&i.IntroVideoUrl,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.Title,
		&i.Description,
		&i.Thumbnail,
		&i.InactiveSince,
	)
	return i, err
}

const CreateSubModuleVideo = `-- name: CreateSubModuleVideo :one
INSERT INTO sub_module_videos (
    sub_module_id,
    title,
    description,
    video_url,
    duration,
    resolution,
    is_published,
    publish_date,
    visibility,
    instructor_id,
    thumbnail,
    display_order,
    status,
    vimeo_id,
    vimeo_embed_url,
    vimeo_player_html,
    vimeo_status,
    video_host_provider
)
VALUES (
    $1, $2, $3, $4, $5, $6,
    COALESCE($7, FALSE), $8, $9, $10, $11,
    COALESCE($12, 0), COALESCE($13, 'DRAFT'),
    $14, $15, $16, $17, COALESCE($18, 'DIRECT')
)
RETURNING id, sub_module_id, title, description, video_url, duration, resolution, is_published, publish_date, visibility, instructor_id, thumbnail, display_order, status, vimeo_id, vimeo_embed_url, vimeo_player_html, vimeo_status, video_host_provider, created_at
`

type CreateSubModuleVideoParams struct {
	SubModuleID     int64              `json:"sub_module_id"`
	Title           string             `json:"title"`
	Description     pgtype.Text        `json:"description"`
	VideoUrl        string             `json:"video_url"`
	Duration        pgtype.Int4        `json:"duration"`
	Resolution      pgtype.Text        `json:"resolution"`
	Column7         interface{}        `json:"column_7"`
	PublishDate     pgtype.Timestamptz `json:"publish_date"`
	Visibility      pgtype.Text        `json:"visibility"`
	InstructorID    pgtype.Text        `json:"instructor_id"`
	Thumbnail       pgtype.Text        `json:"thumbnail"`
	Column12        interface{}        `json:"column_12"`
	Column13        interface{}        `json:"column_13"`
	VimeoID         pgtype.Text        `json:"vimeo_id"`
	VimeoEmbedUrl   pgtype.Text        `json:"vimeo_embed_url"`
	VimeoPlayerHtml pgtype.Text        `json:"vimeo_player_html"`
	VimeoStatus     pgtype.Text        `json:"vimeo_status"`
	Column18        interface{}        `json:"column_18"`
}

func (q *Queries) CreateSubModuleVideo(ctx context.Context, arg CreateSubModuleVideoParams) (SubModuleVideo, error) {
	row := q.db.QueryRow(ctx, CreateSubModuleVideo,
		arg.SubModuleID,
		arg.Title,
		arg.Description,
		arg.VideoUrl,
		arg.Duration,
		arg.Resolution,
		arg.Column7,
		arg.PublishDate,
		arg.Visibility,
		arg.InstructorID,
		arg.Thumbnail,
		arg.Column12,
		arg.Column13,
		arg.VimeoID,
		arg.VimeoEmbedUrl,
		arg.VimeoPlayerHtml,
		arg.VimeoStatus,
		arg.Column18,
	)
	var i SubModuleVideo
	err := row.Scan(
		&i.ID,
		&i.SubModuleID,
		&i.Title,
		&i.Description,
		&i.VideoUrl,
		&i.Duration,
		&i.Resolution,
		&i.IsPublished,
		&i.PublishDate,
		&i.Visibility,
		&i.InstructorID,
		&i.Thumbnail,
		&i.DisplayOrder,
		&i.Status,
		&i.VimeoID,
		&i.VimeoEmbedUrl,
		&i.VimeoPlayerHtml,
		&i.VimeoStatus,
		&i.VideoHostProvider,
		&i.CreatedAt,
	)
	return i, err
}

const GetAllLevels = `-- name: GetAllLevels :many
SELECT
    COUNT(*) OVER () AS total_count,
    l.id, l.course_id, l.cefr_level, l.display_order, l.is_active, l.created_at, l.title, l.description, l.thumbnail
FROM levels l
ORDER BY l.display_order ASC, l.id ASC
LIMIT $2::INT
OFFSET $1::INT
`

type GetAllLevelsParams struct {
	Offset pgtype.Int4 `json:"offset"`
	Limit  pgtype.Int4 `json:"limit"`
}

type GetAllLevelsRow struct {
	TotalCount   int64              `json:"total_count"`
	ID           int64              `json:"id"`
	CourseID     int64              `json:"course_id"`
	CefrLevel    string             `json:"cefr_level"`
	DisplayOrder int32              `json:"display_order"`
	IsActive     bool               `json:"is_active"`
	CreatedAt    pgtype.Timestamptz `json:"created_at"`
	Title        string             `json:"title"`
	Description  pgtype.Text        `json:"description"`
	Thumbnail    pgtype.Text        `json:"thumbnail"`
}

func (q *Queries) GetAllLevels(ctx context.Context, arg GetAllLevelsParams) ([]GetAllLevelsRow, error) {
	rows, err := q.db.Query(ctx, GetAllLevels, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllLevelsRow
	for rows.Next() {
		var i GetAllLevelsRow
		if err := rows.Scan(
			&i.TotalCount,
			&i.ID,
			&i.CourseID,
			&i.CefrLevel,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
			&i.Title,
			&i.Description,
			&i.Thumbnail,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetAllModules = `-- name: GetAllModules :many
SELECT
    COUNT(*) OVER () AS total_count,
    m.id, m.level_id, m.title, m.description, m.display_order, m.is_active, m.created_at, m.icon_url
FROM modules m
ORDER BY m.display_order ASC, m.id ASC
LIMIT $2::INT
OFFSET $1::INT
`

type GetAllModulesParams struct {
	Offset pgtype.Int4 `json:"offset"`
	Limit  pgtype.Int4 `json:"limit"`
}

type GetAllModulesRow struct {
	TotalCount   int64              `json:"total_count"`
	ID           int64              `json:"id"`
	LevelID      int64              `json:"level_id"`
	Title        string             `json:"title"`
	Description  pgtype.Text        `json:"description"`
	DisplayOrder int32              `json:"display_order"`
	IsActive     bool               `json:"is_active"`
	CreatedAt    pgtype.Timestamptz `json:"created_at"`
	IconUrl      pgtype.Text        `json:"icon_url"`
}

func (q *Queries) GetAllModules(ctx context.Context, arg GetAllModulesParams) ([]GetAllModulesRow, error) {
	rows, err := q.db.Query(ctx, GetAllModules, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllModulesRow
	for rows.Next() {
		var i GetAllModulesRow
		if err := rows.Scan(
			&i.TotalCount,
			&i.ID,
			&i.LevelID,
			&i.Title,
			&i.Description,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
			&i.IconUrl,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetAllSubModules = `-- name: GetAllSubModules :many
SELECT
    COUNT(*) OVER () AS total_count,
    sm.id, sm.module_id, sm.title, sm.description, sm.display_order, sm.is_active, sm.created_at, sm.legacy_sub_course_id, sm.thumbnail, sm.tips
FROM sub_modules sm
ORDER BY sm.display_order ASC, sm.id ASC
LIMIT $2::INT
OFFSET $1::INT
`

type GetAllSubModulesParams struct {
	Offset pgtype.Int4 `json:"offset"`
	Limit  pgtype.Int4 `json:"limit"`
}

type GetAllSubModulesRow struct {
	TotalCount        int64              `json:"total_count"`
	ID                int64              `json:"id"`
	ModuleID          int64              `json:"module_id"`
	Title             string             `json:"title"`
	Description       pgtype.Text        `json:"description"`
	DisplayOrder      int32              `json:"display_order"`
	IsActive          bool               `json:"is_active"`
	CreatedAt         pgtype.Timestamptz `json:"created_at"`
	LegacySubCourseID pgtype.Int8        `json:"legacy_sub_course_id"`
	Thumbnail         pgtype.Text        `json:"thumbnail"`
	Tips              pgtype.Text        `json:"tips"`
}

func (q *Queries) GetAllSubModules(ctx context.Context, arg GetAllSubModulesParams) ([]GetAllSubModulesRow, error) {
	rows, err := q.db.Query(ctx, GetAllSubModules, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllSubModulesRow
	for rows.Next() {
		var i GetAllSubModulesRow
		if err := rows.Scan(
			&i.TotalCount,
			&i.ID,
			&i.ModuleID,
			&i.Title,
			&i.Description,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
			&i.LegacySubCourseID,
			&i.Thumbnail,
			&i.Tips,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetCourseSubCategories = `-- name: GetCourseSubCategories :many
SELECT
    COUNT(*) OVER () AS total_count,
    csc.id,
    csc.category_id,
    cc.name AS category_name,
    csc.name,
    csc.description,
    csc.display_order,
    csc.is_active,
    csc.created_at
FROM course_sub_categories csc
JOIN course_categories cc ON cc.id = csc.category_id
WHERE csc.is_active = TRUE
ORDER BY csc.display_order ASC, csc.id ASC
LIMIT $2::INT
OFFSET $1::INT
`

type GetCourseSubCategoriesParams struct {
	Offset pgtype.Int4 `json:"offset"`
	Limit  pgtype.Int4 `json:"limit"`
}

type GetCourseSubCategoriesRow struct {
	TotalCount   int64              `json:"total_count"`
	ID           int64              `json:"id"`
	CategoryID   int64              `json:"category_id"`
	CategoryName string             `json:"category_name"`
	Name         string             `json:"name"`
	Description  pgtype.Text        `json:"description"`
	DisplayOrder int32              `json:"display_order"`
	IsActive     bool               `json:"is_active"`
	CreatedAt    pgtype.Timestamptz `json:"created_at"`
}

func (q *Queries) GetCourseSubCategories(ctx context.Context, arg GetCourseSubCategoriesParams) ([]GetCourseSubCategoriesRow, error) {
	rows, err := q.db.Query(ctx, GetCourseSubCategories, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetCourseSubCategoriesRow
	for rows.Next() {
		var i GetCourseSubCategoriesRow
		if err := rows.Scan(
			&i.TotalCount,
			&i.ID,
			&i.CategoryID,
			&i.CategoryName,
			&i.Name,
			&i.Description,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetCourseSubCategoriesByCategoryID = `-- name: GetCourseSubCategoriesByCategoryID :many
SELECT
    COUNT(*) OVER () AS total_count,
    csc.id,
    csc.category_id,
    cc.name AS category_name,
    csc.name,
    csc.description,
    csc.display_order,
    csc.is_active,
    csc.created_at
FROM course_sub_categories csc
JOIN course_categories cc ON cc.id = csc.category_id
WHERE csc.category_id = $1
  AND csc.is_active = TRUE
ORDER BY csc.display_order ASC, csc.id ASC
LIMIT $3::INT
OFFSET $2::INT
`

type GetCourseSubCategoriesByCategoryIDParams struct {
	CategoryID int64       `json:"category_id"`
	Offset     pgtype.Int4 `json:"offset"`
	Limit      pgtype.Int4 `json:"limit"`
}

type GetCourseSubCategoriesByCategoryIDRow struct {
	TotalCount   int64              `json:"total_count"`
	ID           int64              `json:"id"`
	CategoryID   int64              `json:"category_id"`
	CategoryName string             `json:"category_name"`
	Name         string             `json:"name"`
	Description  pgtype.Text        `json:"description"`
	DisplayOrder int32              `json:"display_order"`
	IsActive     bool               `json:"is_active"`
	CreatedAt    pgtype.Timestamptz `json:"created_at"`
}

func (q *Queries) GetCourseSubCategoriesByCategoryID(ctx context.Context, arg GetCourseSubCategoriesByCategoryIDParams) ([]GetCourseSubCategoriesByCategoryIDRow, error) {
	rows, err := q.db.Query(ctx, GetCourseSubCategoriesByCategoryID, arg.CategoryID, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetCourseSubCategoriesByCategoryIDRow
	for rows.Next() {
		var i GetCourseSubCategoriesByCategoryIDRow
		if err := rows.Scan(
			&i.TotalCount,
			&i.ID,
			&i.CategoryID,
			&i.CategoryName,
			&i.Name,
			&i.Description,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetCoursesWithHierarchy = `-- name: GetCoursesWithHierarchy :many
SELECT
    cc.id AS category_id,
    cc.name AS category_name,
    csc.id AS sub_category_id,
    csc.name AS sub_category_name,
    c.id AS course_id,
    c.title AS course_title
FROM course_categories cc
LEFT JOIN course_sub_categories csc ON csc.category_id = cc.id AND csc.is_active = TRUE
LEFT JOIN courses c ON c.sub_category_id = csc.id AND c.is_active = TRUE
WHERE cc.is_active = TRUE
ORDER BY cc.id, csc.display_order, csc.id, c.id
`

type GetCoursesWithHierarchyRow struct {
	CategoryID      int64       `json:"category_id"`
	CategoryName    string      `json:"category_name"`
	SubCategoryID   pgtype.Int8 `json:"sub_category_id"`
	SubCategoryName pgtype.Text `json:"sub_category_name"`
	CourseID        pgtype.Int8 `json:"course_id"`
	CourseTitle     pgtype.Text `json:"course_title"`
}

func (q *Queries) GetCoursesWithHierarchy(ctx context.Context) ([]GetCoursesWithHierarchyRow, error) {
	rows, err := q.db.Query(ctx, GetCoursesWithHierarchy)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetCoursesWithHierarchyRow
	for rows.Next() {
		var i GetCoursesWithHierarchyRow
		if err := rows.Scan(
			&i.CategoryID,
			&i.CategoryName,
			&i.SubCategoryID,
			&i.SubCategoryName,
			&i.CourseID,
			&i.CourseTitle,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetFullHierarchyByCourseID = `-- name: GetFullHierarchyByCourseID :many
SELECT
    c.id AS course_id,
    c.title AS course_title,
    l.id AS level_id,
    l.cefr_level,
    l.title AS level_title,
    l.description AS level_description,
    l.thumbnail AS level_thumbnail,
    m.id AS module_id,
    m.title AS module_title,
    m.icon_url AS module_icon_url,
    sm.id AS sub_module_id,
    sm.title AS sub_module_title,
    sm.description AS sub_module_description,
    sm.thumbnail AS sub_module_thumbnail,
    sm.tips AS sub_module_tips,
    sm.display_order AS sub_module_display_order
FROM courses c
LEFT JOIN levels l ON l.course_id = c.id AND l.is_active = TRUE
LEFT JOIN modules m ON m.level_id = l.id AND m.is_active = TRUE
LEFT JOIN sub_modules sm ON sm.module_id = m.id AND sm.is_active = TRUE
WHERE c.id = $1
ORDER BY l.display_order, l.id, m.display_order, m.id, sm.display_order, sm.id
`

type GetFullHierarchyByCourseIDRow struct {
	CourseID              int64       `json:"course_id"`
	CourseTitle           string      `json:"course_title"`
	LevelID               pgtype.Int8 `json:"level_id"`
	CefrLevel             pgtype.Text `json:"cefr_level"`
	LevelTitle            pgtype.Text `json:"level_title"`
	LevelDescription      pgtype.Text `json:"level_description"`
	LevelThumbnail        pgtype.Text `json:"level_thumbnail"`
	ModuleID              pgtype.Int8 `json:"module_id"`
	ModuleTitle           pgtype.Text `json:"module_title"`
	ModuleIconUrl         pgtype.Text `json:"module_icon_url"`
	SubModuleID           pgtype.Int8 `json:"sub_module_id"`
	SubModuleTitle        pgtype.Text `json:"sub_module_title"`
	SubModuleDescription  pgtype.Text `json:"sub_module_description"`
	SubModuleThumbnail    pgtype.Text `json:"sub_module_thumbnail"`
	SubModuleTips         pgtype.Text `json:"sub_module_tips"`
	SubModuleDisplayOrder pgtype.Int4 `json:"sub_module_display_order"`
}

func (q *Queries) GetFullHierarchyByCourseID(ctx context.Context, id int64) ([]GetFullHierarchyByCourseIDRow, error) {
	rows, err := q.db.Query(ctx, GetFullHierarchyByCourseID, id)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetFullHierarchyByCourseIDRow
	for rows.Next() {
		var i GetFullHierarchyByCourseIDRow
		if err := rows.Scan(
			&i.CourseID,
			&i.CourseTitle,
			&i.LevelID,
			&i.CefrLevel,
			&i.LevelTitle,
			&i.LevelDescription,
			&i.LevelThumbnail,
			&i.ModuleID,
			&i.ModuleTitle,
			&i.ModuleIconUrl,
			&i.SubModuleID,
			&i.SubModuleTitle,
			&i.SubModuleDescription,
			&i.SubModuleThumbnail,
			&i.SubModuleTips,
			&i.SubModuleDisplayOrder,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetHumanLanguageCourseSubCategories = `-- name: GetHumanLanguageCourseSubCategories :many
SELECT
    COUNT(*) OVER () AS total_count,
    csc.id,
    csc.category_id,
    cc.name AS category_name,
    csc.name,
    csc.description,
    csc.display_order,
    csc.is_active,
    csc.created_at
FROM course_sub_categories csc
JOIN course_categories cc ON cc.id = csc.category_id
WHERE csc.is_active = TRUE
  AND cc.is_active = TRUE
  AND lower(trim(cc.name)) = 'human language'
ORDER BY csc.display_order ASC, csc.id ASC
LIMIT $2::INT
OFFSET $1::INT
`

type GetHumanLanguageCourseSubCategoriesParams struct {
	Offset pgtype.Int4 `json:"offset"`
	Limit  pgtype.Int4 `json:"limit"`
}

type GetHumanLanguageCourseSubCategoriesRow struct {
	TotalCount   int64              `json:"total_count"`
	ID           int64              `json:"id"`
	CategoryID   int64              `json:"category_id"`
	CategoryName string             `json:"category_name"`
	Name         string             `json:"name"`
	Description  pgtype.Text        `json:"description"`
	DisplayOrder int32              `json:"display_order"`
	IsActive     bool               `json:"is_active"`
	CreatedAt    pgtype.Timestamptz `json:"created_at"`
}

func (q *Queries) GetHumanLanguageCourseSubCategories(ctx context.Context, arg GetHumanLanguageCourseSubCategoriesParams) ([]GetHumanLanguageCourseSubCategoriesRow, error) {
	rows, err := q.db.Query(ctx, GetHumanLanguageCourseSubCategories, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetHumanLanguageCourseSubCategoriesRow
	for rows.Next() {
		var i GetHumanLanguageCourseSubCategoriesRow
		if err := rows.Scan(
			&i.TotalCount,
			&i.ID,
			&i.CategoryID,
			&i.CategoryName,
			&i.Name,
			&i.Description,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetLevelByID = `-- name: GetLevelByID :one
SELECT id, course_id, cefr_level, display_order, is_active, created_at, title, description, thumbnail
FROM levels
WHERE id = $1
`

func (q *Queries) GetLevelByID(ctx context.Context, id int64) (Level, error) {
	row := q.db.QueryRow(ctx, GetLevelByID, id)
	var i Level
	err := row.Scan(
		&i.ID,
		&i.CourseID,
		&i.CefrLevel,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.Title,
		&i.Description,
		&i.Thumbnail,
	)
	return i, err
}

const GetLevelsByCourseID = `-- name: GetLevelsByCourseID :many
SELECT id, course_id, cefr_level, display_order, is_active, created_at, title, description, thumbnail
FROM levels
WHERE course_id = $1
  AND is_active = TRUE
ORDER BY display_order ASC, id ASC
`

func (q *Queries) GetLevelsByCourseID(ctx context.Context, courseID int64) ([]Level, error) {
	rows, err := q.db.Query(ctx, GetLevelsByCourseID, courseID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Level
	for rows.Next() {
		var i Level
		if err := rows.Scan(
			&i.ID,
			&i.CourseID,
			&i.CefrLevel,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
			&i.Title,
			&i.Description,
			&i.Thumbnail,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetModuleByID = `-- name: GetModuleByID :one
SELECT id, level_id, title, description, display_order, is_active, created_at, icon_url
FROM modules
WHERE id = $1
`

func (q *Queries) GetModuleByID(ctx context.Context, id int64) (Module, error) {
	row := q.db.QueryRow(ctx, GetModuleByID, id)
	var i Module
	err := row.Scan(
		&i.ID,
		&i.LevelID,
		&i.Title,
		&i.Description,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.IconUrl,
	)
	return i, err
}

const GetModuleCapstoneByID = `-- name: GetModuleCapstoneByID :one
SELECT
    mc.id,
    mc.module_id,
    mc.title,
    mc.description,
    mc.tips,
    mc.thumbnail,
    mc.question_set_id,
    mc.display_order,
    mc.is_active,
    qs.status,
    qs.set_type,
    qs.time_limit_minutes,
    qs.passing_score,
    qs.shuffle_questions,
    (SELECT COUNT(*) FROM question_set_items qsi WHERE qsi.set_id = qs.id) AS question_count
FROM module_capstones mc
JOIN question_sets qs ON qs.id = mc.question_set_id
WHERE mc.id = $1
  AND mc.is_active = TRUE
  AND qs.set_type = 'CAPSTONE'
`

type GetModuleCapstoneByIDRow struct {
	ID               int64       `json:"id"`
	ModuleID         int64       `json:"module_id"`
	Title            string      `json:"title"`
	Description      pgtype.Text `json:"description"`
	Tips             pgtype.Text `json:"tips"`
	Thumbnail        pgtype.Text `json:"thumbnail"`
	QuestionSetID    int64       `json:"question_set_id"`
	DisplayOrder     int32       `json:"display_order"`
	IsActive         bool        `json:"is_active"`
	Status           string      `json:"status"`
	SetType          string      `json:"set_type"`
	TimeLimitMinutes pgtype.Int4 `json:"time_limit_minutes"`
	PassingScore     pgtype.Int4 `json:"passing_score"`
	ShuffleQuestions bool        `json:"shuffle_questions"`
	QuestionCount    int64       `json:"question_count"`
}

func (q *Queries) GetModuleCapstoneByID(ctx context.Context, id int64) (GetModuleCapstoneByIDRow, error) {
	row := q.db.QueryRow(ctx, GetModuleCapstoneByID, id)
	var i GetModuleCapstoneByIDRow
	err := row.Scan(
		&i.ID,
		&i.ModuleID,
		&i.Title,
		&i.Description,
		&i.Tips,
		&i.Thumbnail,
		&i.QuestionSetID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.Status,
		&i.SetType,
		&i.TimeLimitMinutes,
		&i.PassingScore,
		&i.ShuffleQuestions,
		&i.QuestionCount,
	)
	return i, err
}

const GetModuleCapstones = `-- name: GetModuleCapstones :many
SELECT
    mc.id,
    mc.module_id,
    mc.title,
    mc.description,
    mc.tips,
    mc.thumbnail,
    mc.question_set_id,
    mc.display_order,
    mc.is_active,
    qs.status,
    qs.set_type,
    qs.time_limit_minutes,
    qs.passing_score,
    qs.shuffle_questions,
    (SELECT COUNT(*) FROM question_set_items qsi WHERE qsi.set_id = qs.id) AS question_count
FROM module_capstones mc
JOIN question_sets qs ON qs.id = mc.question_set_id
WHERE mc.module_id = $1
  AND mc.is_active = TRUE
  AND qs.set_type = 'CAPSTONE'
ORDER BY mc.display_order ASC, mc.id ASC
`

type GetModuleCapstonesRow struct {
	ID               int64       `json:"id"`
	ModuleID         int64       `json:"module_id"`
	Title            string      `json:"title"`
	Description      pgtype.Text `json:"description"`
	Tips             pgtype.Text `json:"tips"`
	Thumbnail        pgtype.Text `json:"thumbnail"`
	QuestionSetID    int64       `json:"question_set_id"`
	DisplayOrder     int32       `json:"display_order"`
	IsActive         bool        `json:"is_active"`
	Status           string      `json:"status"`
	SetType          string      `json:"set_type"`
	TimeLimitMinutes pgtype.Int4 `json:"time_limit_minutes"`
	PassingScore     pgtype.Int4 `json:"passing_score"`
	ShuffleQuestions bool        `json:"shuffle_questions"`
	QuestionCount    int64       `json:"question_count"`
}

func (q *Queries) GetModuleCapstones(ctx context.Context, moduleID int64) ([]GetModuleCapstonesRow, error) {
	rows, err := q.db.Query(ctx, GetModuleCapstones, moduleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetModuleCapstonesRow
	for rows.Next() {
		var i GetModuleCapstonesRow
		if err := rows.Scan(
			&i.ID,
			&i.ModuleID,
			&i.Title,
			&i.Description,
			&i.Tips,
			&i.Thumbnail,
			&i.QuestionSetID,
			&i.DisplayOrder,
			&i.IsActive,
			&i.Status,
			&i.SetType,
			&i.TimeLimitMinutes,
			&i.PassingScore,
			&i.ShuffleQuestions,
			&i.QuestionCount,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetModulesByLevelID = `-- name: GetModulesByLevelID :many
SELECT id, level_id, title, description, display_order, is_active, created_at, icon_url
FROM modules
WHERE level_id = $1
  AND is_active = TRUE
ORDER BY display_order ASC, id ASC
`

func (q *Queries) GetModulesByLevelID(ctx context.Context, levelID int64) ([]Module, error) {
	rows, err := q.db.Query(ctx, GetModulesByLevelID, levelID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Module
	for rows.Next() {
		var i Module
		if err := rows.Scan(
			&i.ID,
			&i.LevelID,
			&i.Title,
			&i.Description,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
			&i.IconUrl,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetSubModuleByID = `-- name: GetSubModuleByID :one
SELECT id, module_id, title, description, display_order, is_active, created_at, legacy_sub_course_id, thumbnail, tips
FROM sub_modules
WHERE id = $1
`

func (q *Queries) GetSubModuleByID(ctx context.Context, id int64) (SubModule, error) {
	row := q.db.QueryRow(ctx, GetSubModuleByID, id)
	var i SubModule
	err := row.Scan(
		&i.ID,
		&i.ModuleID,
		&i.Title,
		&i.Description,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.LegacySubCourseID,
		&i.Thumbnail,
		&i.Tips,
	)
	return i, err
}

const GetSubModuleCapstoneByID = `-- name: GetSubModuleCapstoneByID :one
SELECT
    smc.id,
    smc.sub_module_id,
    smc.title,
    smc.description,
    smc.tips,
    smc.thumbnail,
    smc.question_set_id,
    smc.display_order,
    smc.is_active,
    smc.inactive_since,
    qs.status,
    qs.set_type,
    qs.time_limit_minutes,
    qs.passing_score,
    qs.shuffle_questions,
    (SELECT COUNT(*) FROM question_set_items qsi WHERE qsi.set_id = qs.id) AS question_count
FROM sub_module_capstones smc
JOIN question_sets qs ON qs.id = smc.question_set_id
WHERE smc.id = $1
  AND smc.is_active = TRUE
  AND qs.set_type = 'CAPSTONE'
`

type GetSubModuleCapstoneByIDRow struct {
	ID               int64              `json:"id"`
	SubModuleID      int64              `json:"sub_module_id"`
	Title            string             `json:"title"`
	Description      pgtype.Text        `json:"description"`
	Tips             pgtype.Text        `json:"tips"`
	Thumbnail        pgtype.Text        `json:"thumbnail"`
	QuestionSetID    int64              `json:"question_set_id"`
	DisplayOrder     int32              `json:"display_order"`
	IsActive         bool               `json:"is_active"`
	InactiveSince    pgtype.Timestamptz `json:"inactive_since"`
	Status           string             `json:"status"`
	SetType          string             `json:"set_type"`
	TimeLimitMinutes pgtype.Int4        `json:"time_limit_minutes"`
	PassingScore     pgtype.Int4        `json:"passing_score"`
	ShuffleQuestions bool               `json:"shuffle_questions"`
	QuestionCount    int64              `json:"question_count"`
}

func (q *Queries) GetSubModuleCapstoneByID(ctx context.Context, id int64) (GetSubModuleCapstoneByIDRow, error) {
	row := q.db.QueryRow(ctx, GetSubModuleCapstoneByID, id)
	var i GetSubModuleCapstoneByIDRow
	err := row.Scan(
		&i.ID,
		&i.SubModuleID,
		&i.Title,
		&i.Description,
		&i.Tips,
		&i.Thumbnail,
		&i.QuestionSetID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.InactiveSince,
		&i.Status,
		&i.SetType,
		&i.TimeLimitMinutes,
		&i.PassingScore,
		&i.ShuffleQuestions,
		&i.QuestionCount,
	)
	return i, err
}

const GetSubModuleCapstones = `-- name: GetSubModuleCapstones :many
SELECT
    smc.id,
    smc.sub_module_id,
    smc.title,
    smc.description,
    smc.tips,
    smc.thumbnail,
    smc.question_set_id,
    smc.display_order,
    smc.is_active,
    smc.inactive_since,
    qs.status,
    qs.set_type,
    qs.time_limit_minutes,
    qs.passing_score,
    qs.shuffle_questions,
    (SELECT COUNT(*) FROM question_set_items qsi WHERE qsi.set_id = qs.id) AS question_count
FROM sub_module_capstones smc
JOIN question_sets qs ON qs.id = smc.question_set_id
WHERE smc.sub_module_id = $1
  AND smc.is_active = TRUE
  AND qs.set_type = 'CAPSTONE'
ORDER BY smc.display_order ASC, smc.id ASC
`

type GetSubModuleCapstonesRow struct {
	ID               int64              `json:"id"`
	SubModuleID      int64              `json:"sub_module_id"`
	Title            string             `json:"title"`
	Description      pgtype.Text        `json:"description"`
	Tips             pgtype.Text        `json:"tips"`
	Thumbnail        pgtype.Text        `json:"thumbnail"`
	QuestionSetID    int64              `json:"question_set_id"`
	DisplayOrder     int32              `json:"display_order"`
	IsActive         bool               `json:"is_active"`
	InactiveSince    pgtype.Timestamptz `json:"inactive_since"`
	Status           string             `json:"status"`
	SetType          string             `json:"set_type"`
	TimeLimitMinutes pgtype.Int4        `json:"time_limit_minutes"`
	PassingScore     pgtype.Int4        `json:"passing_score"`
	ShuffleQuestions bool               `json:"shuffle_questions"`
	QuestionCount    int64              `json:"question_count"`
}

func (q *Queries) GetSubModuleCapstones(ctx context.Context, subModuleID int64) ([]GetSubModuleCapstonesRow, error) {
	rows, err := q.db.Query(ctx, GetSubModuleCapstones, subModuleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetSubModuleCapstonesRow
	for rows.Next() {
		var i GetSubModuleCapstonesRow
		if err := rows.Scan(
			&i.ID,
			&i.SubModuleID,
			&i.Title,
			&i.Description,
			&i.Tips,
			&i.Thumbnail,
			&i.QuestionSetID,
			&i.DisplayOrder,
			&i.IsActive,
			&i.InactiveSince,
			&i.Status,
			&i.SetType,
			&i.TimeLimitMinutes,
			&i.PassingScore,
			&i.ShuffleQuestions,
			&i.QuestionCount,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetSubModuleLessonByID = `-- name: GetSubModuleLessonByID :one
SELECT id, sub_module_id, display_order, is_active, created_at, title, description, thumbnail, teaching_text, teaching_image_url, teaching_audio_url, teaching_video_url, inactive_since
FROM sub_module_lessons
WHERE id = $1
`

func (q *Queries) GetSubModuleLessonByID(ctx context.Context, id int64) (SubModuleLesson, error) {
	row := q.db.QueryRow(ctx, GetSubModuleLessonByID, id)
	var i SubModuleLesson
	err := row.Scan(
		&i.ID,
		&i.SubModuleID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.Title,
		&i.Description,
		&i.Thumbnail,
		&i.TeachingText,
		&i.TeachingImageUrl,
		&i.TeachingAudioUrl,
		&i.TeachingVideoUrl,
		&i.InactiveSince,
	)
	return i, err
}

const GetSubModuleLessons = `-- name: GetSubModuleLessons :many
SELECT id, sub_module_id, display_order, is_active, created_at, title, description, thumbnail, teaching_text, teaching_image_url, teaching_audio_url, teaching_video_url, inactive_since
FROM sub_module_lessons
WHERE sub_module_id = $1
  AND is_active = TRUE
ORDER BY display_order ASC, id ASC
`

func (q *Queries) GetSubModuleLessons(ctx context.Context, subModuleID int64) ([]SubModuleLesson, error) {
	rows, err := q.db.Query(ctx, GetSubModuleLessons, subModuleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SubModuleLesson
	for rows.Next() {
		var i SubModuleLesson
		if err := rows.Scan(
			&i.ID,
			&i.SubModuleID,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
			&i.Title,
			&i.Description,
			&i.Thumbnail,
			&i.TeachingText,
			&i.TeachingImageUrl,
			&i.TeachingAudioUrl,
			&i.TeachingVideoUrl,
			&i.InactiveSince,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetSubModuleLessonsAll = `-- name: GetSubModuleLessonsAll :many
SELECT id, sub_module_id, display_order, is_active, created_at, title, description, thumbnail, teaching_text, teaching_image_url, teaching_audio_url, teaching_video_url, inactive_since
FROM sub_module_lessons
WHERE sub_module_id = $1
ORDER BY display_order ASC, id ASC
`

func (q *Queries) GetSubModuleLessonsAll(ctx context.Context, subModuleID int64) ([]SubModuleLesson, error) {
	rows, err := q.db.Query(ctx, GetSubModuleLessonsAll, subModuleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SubModuleLesson
	for rows.Next() {
		var i SubModuleLesson
		if err := rows.Scan(
			&i.ID,
			&i.SubModuleID,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
			&i.Title,
			&i.Description,
			&i.Thumbnail,
			&i.TeachingText,
			&i.TeachingImageUrl,
			&i.TeachingAudioUrl,
			&i.TeachingVideoUrl,
			&i.InactiveSince,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetSubModulePracticeByID = `-- name: GetSubModulePracticeByID :one
SELECT
    smp.id,
    smp.sub_module_id,
    smp.title,
    smp.description,
    smp.thumbnail,
    smp.intro_video_url,
    smp.question_set_id,
    smp.display_order,
    smp.is_active,
    smp.inactive_since,
    qs.status,
    qs.set_type,
    (SELECT COUNT(*) FROM question_set_items qsi WHERE qsi.set_id = qs.id) AS question_count
FROM sub_module_practices smp
JOIN question_sets qs ON qs.id = smp.question_set_id
WHERE smp.id = $1
  AND smp.is_active = TRUE
  AND qs.set_type = 'PRACTICE'
`

type GetSubModulePracticeByIDRow struct {
	ID            int64              `json:"id"`
	SubModuleID   int64              `json:"sub_module_id"`
	Title         string             `json:"title"`
	Description   pgtype.Text        `json:"description"`
	Thumbnail     pgtype.Text        `json:"thumbnail"`
	IntroVideoUrl pgtype.Text        `json:"intro_video_url"`
	QuestionSetID int64              `json:"question_set_id"`
	DisplayOrder  int32              `json:"display_order"`
	IsActive      bool               `json:"is_active"`
	InactiveSince pgtype.Timestamptz `json:"inactive_since"`
	Status        string             `json:"status"`
	SetType       string             `json:"set_type"`
	QuestionCount int64              `json:"question_count"`
}

func (q *Queries) GetSubModulePracticeByID(ctx context.Context, id int64) (GetSubModulePracticeByIDRow, error) {
	row := q.db.QueryRow(ctx, GetSubModulePracticeByID, id)
	var i GetSubModulePracticeByIDRow
	err := row.Scan(
		&i.ID,
		&i.SubModuleID,
		&i.Title,
		&i.Description,
		&i.Thumbnail,
		&i.IntroVideoUrl,
		&i.QuestionSetID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.InactiveSince,
		&i.Status,
		&i.SetType,
		&i.QuestionCount,
	)
	return i, err
}

const GetSubModulePractices = `-- name: GetSubModulePractices :many
SELECT
    smp.id,
    smp.sub_module_id,
    smp.title,
    smp.description,
    smp.thumbnail,
    smp.intro_video_url,
    smp.question_set_id,
    smp.display_order,
    smp.is_active,
    smp.inactive_since,
    qs.status,
    qs.set_type,
    (SELECT COUNT(*) FROM question_set_items qsi WHERE qsi.set_id = qs.id) AS question_count
FROM sub_module_practices smp
JOIN question_sets qs ON qs.id = smp.question_set_id
WHERE smp.sub_module_id = $1
  AND smp.is_active = TRUE
  AND qs.set_type = 'PRACTICE'
ORDER BY smp.display_order ASC, smp.id ASC
`

type GetSubModulePracticesRow struct {
	ID            int64              `json:"id"`
	SubModuleID   int64              `json:"sub_module_id"`
	Title         string             `json:"title"`
	Description   pgtype.Text        `json:"description"`
	Thumbnail     pgtype.Text        `json:"thumbnail"`
	IntroVideoUrl pgtype.Text        `json:"intro_video_url"`
	QuestionSetID int64              `json:"question_set_id"`
	DisplayOrder  int32              `json:"display_order"`
	IsActive      bool               `json:"is_active"`
	InactiveSince pgtype.Timestamptz `json:"inactive_since"`
	Status        string             `json:"status"`
	SetType       string             `json:"set_type"`
	QuestionCount int64              `json:"question_count"`
}

func (q *Queries) GetSubModulePractices(ctx context.Context, subModuleID int64) ([]GetSubModulePracticesRow, error) {
	rows, err := q.db.Query(ctx, GetSubModulePractices, subModuleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetSubModulePracticesRow
	for rows.Next() {
		var i GetSubModulePracticesRow
		if err := rows.Scan(
			&i.ID,
			&i.SubModuleID,
			&i.Title,
			&i.Description,
			&i.Thumbnail,
			&i.IntroVideoUrl,
			&i.QuestionSetID,
			&i.DisplayOrder,
			&i.IsActive,
			&i.InactiveSince,
			&i.Status,
			&i.SetType,
			&i.QuestionCount,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetSubModuleVideos = `-- name: GetSubModuleVideos :many
SELECT id, sub_module_id, title, description, video_url, duration, resolution, is_published, publish_date, visibility, instructor_id, thumbnail, display_order, status, vimeo_id, vimeo_embed_url, vimeo_player_html, vimeo_status, video_host_provider, created_at
FROM sub_module_videos
WHERE sub_module_id = $1
  AND status != 'ARCHIVED'
ORDER BY display_order ASC, id ASC
`

func (q *Queries) GetSubModuleVideos(ctx context.Context, subModuleID int64) ([]SubModuleVideo, error) {
	rows, err := q.db.Query(ctx, GetSubModuleVideos, subModuleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SubModuleVideo
	for rows.Next() {
		var i SubModuleVideo
		if err := rows.Scan(
			&i.ID,
			&i.SubModuleID,
			&i.Title,
			&i.Description,
			&i.VideoUrl,
			&i.Duration,
			&i.Resolution,
			&i.IsPublished,
			&i.PublishDate,
			&i.Visibility,
			&i.InstructorID,
			&i.Thumbnail,
			&i.DisplayOrder,
			&i.Status,
			&i.VimeoID,
			&i.VimeoEmbedUrl,
			&i.VimeoPlayerHtml,
			&i.VimeoStatus,
			&i.VideoHostProvider,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetSubModulesByModuleID = `-- name: GetSubModulesByModuleID :many
SELECT id, module_id, title, description, display_order, is_active, created_at, legacy_sub_course_id, thumbnail, tips
FROM sub_modules
WHERE module_id = $1
  AND is_active = TRUE
ORDER BY display_order ASC, id ASC
`

func (q *Queries) GetSubModulesByModuleID(ctx context.Context, moduleID int64) ([]SubModule, error) {
	rows, err := q.db.Query(ctx, GetSubModulesByModuleID, moduleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SubModule
	for rows.Next() {
		var i SubModule
		if err := rows.Scan(
			&i.ID,
			&i.ModuleID,
			&i.Title,
			&i.Description,
			&i.DisplayOrder,
			&i.IsActive,
			&i.CreatedAt,
			&i.LegacySubCourseID,
			&i.Thumbnail,
			&i.Tips,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const PurgeInactiveSubModuleCapstonesBefore = `-- name: PurgeInactiveSubModuleCapstonesBefore :execrows
DELETE FROM question_sets qs
USING (
    SELECT question_set_id
    FROM sub_module_capstones
    WHERE is_active = FALSE
      AND inactive_since IS NOT NULL
      AND inactive_since < $1
) doomed
WHERE qs.id = doomed.question_set_id
`

func (q *Queries) PurgeInactiveSubModuleCapstonesBefore(ctx context.Context, inactiveSince pgtype.Timestamptz) (int64, error) {
	result, err := q.db.Exec(ctx, PurgeInactiveSubModuleCapstonesBefore, inactiveSince)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const PurgeInactiveSubModuleLessonsBefore = `-- name: PurgeInactiveSubModuleLessonsBefore :execrows
DELETE FROM sub_module_lessons
WHERE is_active = FALSE
  AND inactive_since IS NOT NULL
  AND inactive_since < $1
`

func (q *Queries) PurgeInactiveSubModuleLessonsBefore(ctx context.Context, inactiveSince pgtype.Timestamptz) (int64, error) {
	result, err := q.db.Exec(ctx, PurgeInactiveSubModuleLessonsBefore, inactiveSince)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const PurgeInactiveSubModulePracticesBefore = `-- name: PurgeInactiveSubModulePracticesBefore :execrows
DELETE FROM question_sets qs
USING (
    SELECT question_set_id
    FROM sub_module_practices
    WHERE is_active = FALSE
      AND inactive_since IS NOT NULL
      AND inactive_since < $1
) doomed
WHERE qs.id = doomed.question_set_id
`

func (q *Queries) PurgeInactiveSubModulePracticesBefore(ctx context.Context, inactiveSince pgtype.Timestamptz) (int64, error) {
	result, err := q.db.Exec(ctx, PurgeInactiveSubModulePracticesBefore, inactiveSince)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const UpdateLevel = `-- name: UpdateLevel :one
UPDATE levels
SET
    title = $1,
    description = $2,
    thumbnail = $3,
    display_order = $4,
    is_active = $5
WHERE id = $6
RETURNING id, course_id, cefr_level, display_order, is_active, created_at, title, description, thumbnail
`

type UpdateLevelParams struct {
	Title        string      `json:"title"`
	Description  pgtype.Text `json:"description"`
	Thumbnail    pgtype.Text `json:"thumbnail"`
	DisplayOrder int32       `json:"display_order"`
	IsActive     bool        `json:"is_active"`
	ID           int64       `json:"id"`
}

func (q *Queries) UpdateLevel(ctx context.Context, arg UpdateLevelParams) (Level, error) {
	row := q.db.QueryRow(ctx, UpdateLevel,
		arg.Title,
		arg.Description,
		arg.Thumbnail,
		arg.DisplayOrder,
		arg.IsActive,
		arg.ID,
	)
	var i Level
	err := row.Scan(
		&i.ID,
		&i.CourseID,
		&i.CefrLevel,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.Title,
		&i.Description,
		&i.Thumbnail,
	)
	return i, err
}

const UpdateModule = `-- name: UpdateModule :one
UPDATE modules
SET
    title = $1,
    description = $2,
    icon_url = $3,
    display_order = $4,
    is_active = $5
WHERE id = $6
RETURNING id, level_id, title, description, display_order, is_active, created_at, icon_url
`

type UpdateModuleParams struct {
	Title        string      `json:"title"`
	Description  pgtype.Text `json:"description"`
	IconUrl      pgtype.Text `json:"icon_url"`
	DisplayOrder int32       `json:"display_order"`
	IsActive     bool        `json:"is_active"`
	ID           int64       `json:"id"`
}

func (q *Queries) UpdateModule(ctx context.Context, arg UpdateModuleParams) (Module, error) {
	row := q.db.QueryRow(ctx, UpdateModule,
		arg.Title,
		arg.Description,
		arg.IconUrl,
		arg.DisplayOrder,
		arg.IsActive,
		arg.ID,
	)
	var i Module
	err := row.Scan(
		&i.ID,
		&i.LevelID,
		&i.Title,
		&i.Description,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.IconUrl,
	)
	return i, err
}

const UpdateModuleCapstone = `-- name: UpdateModuleCapstone :one
UPDATE module_capstones
SET
    title = $1,
    description = $2,
    tips = $3,
    thumbnail = $4,
    display_order = $5,
    is_active = $6
WHERE id = $7
RETURNING id, module_id, title, description, tips, thumbnail, question_set_id, display_order, is_active, created_at
`

type UpdateModuleCapstoneParams struct {
	Title        string      `json:"title"`
	Description  pgtype.Text `json:"description"`
	Tips         pgtype.Text `json:"tips"`
	Thumbnail    pgtype.Text `json:"thumbnail"`
	DisplayOrder int32       `json:"display_order"`
	IsActive     bool        `json:"is_active"`
	ID           int64       `json:"id"`
}

func (q *Queries) UpdateModuleCapstone(ctx context.Context, arg UpdateModuleCapstoneParams) (ModuleCapstone, error) {
	row := q.db.QueryRow(ctx, UpdateModuleCapstone,
		arg.Title,
		arg.Description,
		arg.Tips,
		arg.Thumbnail,
		arg.DisplayOrder,
		arg.IsActive,
		arg.ID,
	)
	var i ModuleCapstone
	err := row.Scan(
		&i.ID,
		&i.ModuleID,
		&i.Title,
		&i.Description,
		&i.Tips,
		&i.Thumbnail,
		&i.QuestionSetID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
	)
	return i, err
}

const UpdateSubModule = `-- name: UpdateSubModule :one
UPDATE sub_modules
SET
    title = $1,
    description = $2,
    thumbnail = $3,
    tips = $4,
    display_order = $5,
    is_active = $6
WHERE id = $7
RETURNING id, module_id, title, description, display_order, is_active, created_at, legacy_sub_course_id, thumbnail, tips
`

type UpdateSubModuleParams struct {
	Title        string      `json:"title"`
	Description  pgtype.Text `json:"description"`
	Thumbnail    pgtype.Text `json:"thumbnail"`
	Tips         pgtype.Text `json:"tips"`
	DisplayOrder int32       `json:"display_order"`
	IsActive     bool        `json:"is_active"`
	ID           int64       `json:"id"`
}

func (q *Queries) UpdateSubModule(ctx context.Context, arg UpdateSubModuleParams) (SubModule, error) {
	row := q.db.QueryRow(ctx, UpdateSubModule,
		arg.Title,
		arg.Description,
		arg.Thumbnail,
		arg.Tips,
		arg.DisplayOrder,
		arg.IsActive,
		arg.ID,
	)
	var i SubModule
	err := row.Scan(
		&i.ID,
		&i.ModuleID,
		&i.Title,
		&i.Description,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.LegacySubCourseID,
		&i.Thumbnail,
		&i.Tips,
	)
	return i, err
}

const UpdateSubModuleCapstone = `-- name: UpdateSubModuleCapstone :one
UPDATE sub_module_capstones
SET
    title = $1,
    description = $2,
    tips = $3,
    thumbnail = $4,
    display_order = $5,
    is_active = $6,
    inactive_since = CASE
        WHEN $6 THEN NULL
        WHEN is_active THEN NOW()
        ELSE inactive_since
    END
WHERE id = $7
RETURNING id, sub_module_id, title, description, tips, thumbnail, question_set_id, display_order, is_active, created_at, inactive_since
`

type UpdateSubModuleCapstoneParams struct {
	Title        string      `json:"title"`
	Description  pgtype.Text `json:"description"`
	Tips         pgtype.Text `json:"tips"`
	Thumbnail    pgtype.Text `json:"thumbnail"`
	DisplayOrder int32       `json:"display_order"`
	IsActive     bool        `json:"is_active"`
	ID           int64       `json:"id"`
}

func (q *Queries) UpdateSubModuleCapstone(ctx context.Context, arg UpdateSubModuleCapstoneParams) (SubModuleCapstone, error) {
	row := q.db.QueryRow(ctx, UpdateSubModuleCapstone,
		arg.Title,
		arg.Description,
		arg.Tips,
		arg.Thumbnail,
		arg.DisplayOrder,
		arg.IsActive,
		arg.ID,
	)
	var i SubModuleCapstone
	err := row.Scan(
		&i.ID,
		&i.SubModuleID,
		&i.Title,
		&i.Description,
		&i.Tips,
		&i.Thumbnail,
		&i.QuestionSetID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.InactiveSince,
	)
	return i, err
}

const UpdateSubModuleLesson = `-- name: UpdateSubModuleLesson :one
UPDATE sub_module_lessons
SET
    sub_module_id = $1,
    title = $2,
    description = $3,
    thumbnail = $4,
    teaching_text = $5,
    teaching_image_url = $6,
    teaching_audio_url = $7,
    teaching_video_url = $8,
    display_order = $9,
    is_active = $10,
    inactive_since = CASE
        WHEN $10 THEN NULL
        WHEN is_active THEN NOW()
        ELSE inactive_since
    END
WHERE id = $11
RETURNING id, sub_module_id, display_order, is_active, created_at, title, description, thumbnail, teaching_text, teaching_image_url, teaching_audio_url, teaching_video_url, inactive_since
`

type UpdateSubModuleLessonParams struct {
	SubModuleID      int64       `json:"sub_module_id"`
	Title            string      `json:"title"`
	Description      pgtype.Text `json:"description"`
	Thumbnail        pgtype.Text `json:"thumbnail"`
	TeachingText     pgtype.Text `json:"teaching_text"`
	TeachingImageUrl pgtype.Text `json:"teaching_image_url"`
	TeachingAudioUrl pgtype.Text `json:"teaching_audio_url"`
	TeachingVideoUrl pgtype.Text `json:"teaching_video_url"`
	DisplayOrder     int32       `json:"display_order"`
	IsActive         bool        `json:"is_active"`
	ID               int64       `json:"id"`
}

func (q *Queries) UpdateSubModuleLesson(ctx context.Context, arg UpdateSubModuleLessonParams) (SubModuleLesson, error) {
	row := q.db.QueryRow(ctx, UpdateSubModuleLesson,
		arg.SubModuleID,
		arg.Title,
		arg.Description,
		arg.Thumbnail,
		arg.TeachingText,
		arg.TeachingImageUrl,
		arg.TeachingAudioUrl,
		arg.TeachingVideoUrl,
		arg.DisplayOrder,
		arg.IsActive,
		arg.ID,
	)
	var i SubModuleLesson
	err := row.Scan(
		&i.ID,
		&i.SubModuleID,
		&i.DisplayOrder,
		&i.IsActive,
		&i.CreatedAt,
		&i.Title,
		&i.Description,
		&i.Thumbnail,
		&i.TeachingText,
		&i.TeachingImageUrl,
		&i.TeachingAudioUrl,
		&i.TeachingVideoUrl,
		&i.InactiveSince,
	)
	return i, err
}