query.resolvers.go

package resolver

// This file will be automatically regenerated based on the schema, any resolver implementations
// will be copied through when generating and any unknown code will be moved to the end.
// Code generated by github.com/99designs/gqlgen version v0.17.78

import (
	"context"
	"fmt"
	"quizfreely/api/auth"
	"quizfreely/api/graph"
	"quizfreely/api/graph/cursor"
	"quizfreely/api/graph/model"
	"time"

	"github.com/georgysavva/scany/v2/pgxscan"
)

// StudysetIds is the resolver for the studysetIds field.
func (r *practiceTestResolver) StudysetIds(ctx context.Context, obj *model.PracticeTest) ([]string, error) {
	if obj == nil || obj.ID == nil {
		return nil, nil
	}

	var ids []string
	sql := `SELECT studyset_id FROM practice_test_studysets WHERE practice_test_id = $1`
	err := pgxscan.Select(ctx, r.DB, &ids, sql, *obj.ID)
	if err != nil {
		return nil, fmt.Errorf("failed to fetch studyset ids for practice test: %w", err)
	}

	return ids, nil
}

// Authed is the resolver for the authed field.
func (r *queryResolver) Authed(ctx context.Context) (bool, error) {
	authed := auth.AuthedUserContext(ctx) != nil
	return authed, nil
}

// AuthedUser is the resolver for the authedUser field.
func (r *queryResolver) AuthedUser(ctx context.Context) (*model.AuthedUser, error) {
	return auth.AuthedUserContext(ctx), nil
}

// Studyset is the resolver for the studyset field.
func (r *queryResolver) Studyset(ctx context.Context, id string) (*model.Studyset, error) {
	authedUser := auth.AuthedUserContext(ctx)

	var studyset model.Studyset
	var err error
	if authedUser != nil {
		sql := `
			SELECT id, user_id, title, private, subject_id, draft, seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
			FROM public.studysets
			WHERE id = $1 AND ((private = false AND draft = false) OR user_id = $2)`
		err = pgxscan.Get(ctx, r.DB, &studyset, sql, id, authedUser.ID)
	} else {
		sql := `
			SELECT id, user_id, title, private, subject_id, draft, seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
			FROM public.studysets
			WHERE id = $1 AND private = false AND draft = false`
		err = pgxscan.Get(ctx, r.DB, &studyset, sql, id)
	}
	if err != nil {
		if pgxscan.NotFound(err) {
			return nil, fmt.Errorf("studyset not found")
		}
		return nil, fmt.Errorf("failed to fetch studyset: %w", err)
	}

	return &studyset, nil
}

// User is the resolver for the user field.
func (r *queryResolver) User(ctx context.Context, id string) (*model.User, error) {
	var user model.User
	sql := `
		SELECT
			id,
			username,
			display_name
		FROM auth.users
		WHERE id = $1
	`
	err := pgxscan.Get(ctx, r.DB, &user, sql, id)
	if err != nil {
		if pgxscan.NotFound(err) {
			return nil, fmt.Errorf("user not found")
		}
		return nil, fmt.Errorf("failed to fetch user: %w", err)
	}
	return &user, nil
}

// Term is the resolver for the term field.
func (r *queryResolver) Term(ctx context.Context, id string) (*model.Term, error) {
	authedUser := auth.AuthedUserContext(ctx)

	var term model.Term
	var err error
	if authedUser != nil {
		err = pgxscan.Get(
			ctx,
			r.DB,
			&term,
			`SELECT terms.id, terms.studyset_id, terms.term, terms.def, ($3||terms.term_image_key) as term_image_url, ($3||terms.def_image_key) as def_image_url, terms.sort_order,
		to_char(terms.created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
		to_char(terms.updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
FROM terms
JOIN studysets ON terms.studyset_id = studysets.id
WHERE terms.id = $1 AND (
    	(studysets.private = FALSE AND studysets.draft = FALSE) OR
		studysets.user_id = $2
)`,
			id,
			authedUser.ID,
			r.UsercontentBaseURL,
		)
	} else {
		err = pgxscan.Get(
			ctx,
			r.DB,
			&term,
			`SELECT terms.id, terms.studyset_id, terms.term, terms.def, ($2||terms.term_image_key) as term_image_url, ($2||terms.def_image_key) as def_image_url, terms.sort_order,
		to_char(terms.created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
		to_char(terms.updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
FROM terms
JOIN studysets ON terms.studyset_id = studysets.id
WHERE terms.id = $1 AND studysets.private = FALSE AND studysets.draft = FALSE`,
			id,
			r.UsercontentBaseURL,
		)
	}
	if err != nil {
		if pgxscan.NotFound(err) {
			return nil, fmt.Errorf("term not found")
		}
		return nil, fmt.Errorf("failed to fetch term: %w", err)
	}

	return &term, nil
}

// RecentlyCreatedStudysets is the resolver for the recentlyCreatedStudysets field.
func (r *queryResolver) RecentlyCreatedStudysets(ctx context.Context, first *int32, after *string, last *int32, before *string) (*model.StudysetConnection, error) {
	l := 24
	if first != nil && *first > 0 && *first < 1000 {
		l = int(*first)
	} else if last != nil && *last > 0 && *last < 1000 {
		l = int(*last)
	}
	limit := l + 1

	cursorScore, cursorID := cursor.DecodeStudysetCursor(ptrToString(after))
	beforeCursorScore, beforeCursorID := cursor.DecodeStudysetCursor(ptrToString(before))

	// Check for Previous Page possibility
	hasPrevious := cursorScore != "" || cursorID != ""
	if before != nil {
		// If we are paginating backwards, there is always a "next" page (which is the one we came from)
		// but in the context of "hasPrevious", it means "are there newer items?"
		// When going backwards (using before), we are moving towards newer items.
		// If we find more than limit, it means there are even newer items.
		// For the sake of the connection spec:
		// hasNextPage: false (usually, unless we fetched more than limit)
		// hasPreviousPage: true (we assume there are older items if we are in the middle)
		// But let's stick to the data:
	}

	var studysets []*model.Studyset
	var err error

	if beforeCursorID != "" {
		// Backward pagination
		// We want items NEWER than the cursor, sorted ASC (oldest to newest) to get the "previous" 24 items
		// Then we reverse them back to DESC (newest to oldest) for the client.

		sql := `
			SELECT
				id,
				user_id,
				title,
				private,
				draft,
				subject_id,
				seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
			FROM public.studysets
			WHERE private = false AND draft = false
				AND (to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) > ($1, $2::uuid)
			ORDER BY created_at ASC, id ASC
			LIMIT $3
		`
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, beforeCursorScore, beforeCursorID, limit)
		if err != nil {
			return nil, fmt.Errorf("failed to fetch recently created studysets: %w", err)
		}

		// If we found more than the limit, it means there is a "previous" page (newer items)
		hasPrevious = len(studysets) > l
		if hasPrevious {
			studysets = studysets[:l]
		}

		// Reverse connections to restore DESC order
		for i, j := 0, len(studysets)-1; i < j; i, j = i+1, j-1 {
			studysets[i], studysets[j] = studysets[j], studysets[i]
		}

		// Since we moved backwards, we know there is a "next" page (older items, where we came from)
		// strictly speaking, unless we are at the very beginning of the list?
		// No, if we successfully fetched items using `before`, it implies we are not at the end.
		// But we need to know if there are MORE older items. `hasPrevious` check above tells us if there are NEWER.
		// To know if there are OLDER items (hasNextPage), we'd typically rely on where we came from or do a peek.
		// For simple prev/next buttons, we can assume:
		// If we utilized `before`, we definitely have `hasNextPage` = true (the page we came from).

	} else if cursorID != "" {
		// Forward pagination
		sql := `
			SELECT
				id,
				user_id,
				title,
				private,
				draft,
				subject_id,
				seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
			FROM public.studysets
			WHERE private = false AND draft = false
				AND (to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) < ($1, $2::uuid)
			ORDER BY created_at DESC, id DESC
			LIMIT $3
		`
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, cursorScore, cursorID, limit)
	} else {
		// First page
		sql := `
			SELECT
				id,
				user_id,
				title,
				private,
				draft,
				subject_id,
				seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
			FROM public.studysets
			WHERE private = false AND draft = false
			ORDER BY created_at DESC, id DESC
			LIMIT $1
		`
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, limit)
	}

	if err != nil {
		return nil, fmt.Errorf("failed to fetch recently created studysets: %w", err)
	}

	hasNext := false
	if beforeCursorID != "" {
		// If we went backwards, we assume there's a next page (older items)
		// This is a simplification but sufficient for linear navigation
		hasNext = true
	} else {
		hasNext = len(studysets) > l
		if hasNext {
			studysets = studysets[:l]
		}
	}

	getCursor := func(s *model.Studyset) (string, string) {
		return ptrToString(s.CreatedAt), ptrToString(s.ID)
	}
	return cursor.StudysetConnectionFrom(studysets, hasNext, hasPrevious, getCursor), nil
}

// RecentlyUpdatedStudysets is the resolver for the recentlyUpdatedStudysets field.
func (r *queryResolver) RecentlyUpdatedStudysets(ctx context.Context, first *int32, after *string, last *int32, before *string) (*model.StudysetConnection, error) {
	l := 24
	if first != nil && *first > 0 && *first < 1000 {
		l = int(*first)
	} else if last != nil && *last > 0 && *last < 1000 {
		l = int(*last)
	}
	limit := l + 1

	cursorScore, cursorID := cursor.DecodeStudysetCursor(ptrToString(after))
	beforeCursorScore, beforeCursorID := cursor.DecodeStudysetCursor(ptrToString(before))

	// Check for Previous Page possibility
	hasPrevious := cursorScore != "" || cursorID != ""
	if before != nil {

	}

	var studysets []*model.Studyset
	var err error

	if beforeCursorID != "" {
		// Backward pagination
		// We want items NEWER than the cursor, sorted ASC (oldest to newest) to get the "previous" 24 items
		// Then we reverse them back to DESC (newest to oldest) for the client.

		sql := `
			SELECT
				id,
				user_id,
				title,
				private,
				draft,
				subject_id,
				seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
			FROM public.studysets
			WHERE private = false AND draft = false
				AND (to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) > ($1, $2::uuid)
			ORDER BY updated_at ASC, id ASC
			LIMIT $3
		`
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, beforeCursorScore, beforeCursorID, limit)
		if err != nil {
			return nil, fmt.Errorf("failed to fetch recently updated studysets: %w", err)
		}

		// If we found more than the limit, it means there is a "previous" page (newer items)
		hasPrevious = len(studysets) > l
		if hasPrevious {
			studysets = studysets[:l]
		}

		// Reverse connections to restore DESC order
		for i, j := 0, len(studysets)-1; i < j; i, j = i+1, j-1 {
			studysets[i], studysets[j] = studysets[j], studysets[i]
		}

	} else if cursorID != "" {
		// Forward pagination
		sql := `
			SELECT
				id,
				user_id,
				title,
				private,
				draft,
				subject_id,
				seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
			FROM public.studysets
			WHERE private = false AND draft = false
				AND (to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) < ($1, $2::uuid)
			ORDER BY updated_at DESC, id DESC
			LIMIT $3
		`
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, cursorScore, cursorID, limit)
	} else {
		// First page
		sql := `
			SELECT
				id,
				user_id,
				title,
				private,
				draft,
				subject_id,
				seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at
			FROM public.studysets
			WHERE private = false AND draft = false
			ORDER BY updated_at DESC, id DESC
			LIMIT $1
		`
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, limit)
	}

	if err != nil {
		return nil, fmt.Errorf("failed to fetch recently updated studysets: %w", err)
	}

	hasNext := false
	if beforeCursorID != "" {
		// If we went backwards, we assume there's a next page (older items)
		// This is a simplification but sufficient for linear navigation
		hasNext = true
	} else {
		hasNext = len(studysets) > l
		if hasNext {
			studysets = studysets[:l]
		}
	}

	getCursor := func(s *model.Studyset) (string, string) {
		return ptrToString(s.UpdatedAt), ptrToString(s.ID)
	}
	return cursor.StudysetConnectionFrom(studysets, hasNext, hasPrevious, getCursor), nil
}

// SearchStudysets is the resolver for the searchStudysets field.
func (r *queryResolver) SearchStudysets(ctx context.Context, q string, first *int32, after *string, last *int32, before *string) (*model.StudysetConnection, error) {
	if len(q) < 1 {
		return &model.StudysetConnection{
			Edges:    []*model.StudysetEdge{},
			PageInfo: &model.PageInfo{},
		}, nil
	}
	// limit query length before using it with the database because `word_similarity` can become really heavy
	if len(q) > 200 {
		q = q[:200]
	}
	l := 240
	if first != nil && *first > 0 && *first < 1000 {
		l = int(*first)
	} else if last != nil && *last > 0 && *last < 1000 {
		l = int(*last)
	}
	limit := l + 1

	cursorScore, cursorTS, cursorID := cursor.DecodeStudysetScoreCursor(ptrToString(after))
	beforeCursorScore, beforeCursorTS, beforeCursorID := cursor.DecodeStudysetScoreCursor(ptrToString(before))

	isBackward := beforeCursorID != ""
	hasPrevious := false
	if !isBackward {
		hasPrevious = cursorScore != "" || cursorTS != "" || cursorID != ""
	}

	// We need a temporary struct to hold the score for cursor generation
	type searchRow struct {
		model.Studyset
		Score float64 `db:"score"`
	}

	var rows []*searchRow
	var err error

	// Common select columns matching model.Studyset fields (via scany/db tags or name matching)
	selectCols := `
		id,
		user_id,
		title,
		private,
		draft,
		subject_id,
		seo_indexing_approved,
		to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
		to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at,
		word_similarity(lower($1), lower(title)) as score
	`

	if isBackward {
		sql := `
			SELECT ` + selectCols + `
			FROM public.studysets
			WHERE lower($1) <% lower(title) AND private = false AND draft = false
				AND (word_similarity(lower($1), lower(title)), to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) > ($2::float4, $3, $4::uuid)
			ORDER BY score ASC, created_at ASC, id ASC
			LIMIT $5
		`
		err = pgxscan.Select(ctx, r.DB, &rows, sql, q, beforeCursorScore, beforeCursorTS, beforeCursorID, limit)
		if err == nil {
			// If we found more than the limit, it means there is a "previous" page (newer items)
			hasPrevious = len(rows) > l
			if hasPrevious {
				rows = rows[:l]
			}
			// Reverse results to restore DESC order
			for i, j := 0, len(rows)-1; i < j; i, j = i+1, j-1 {
				rows[i], rows[j] = rows[j], rows[i]
			}
		}
	} else if cursorID != "" {
		sql := `
			SELECT ` + selectCols + `
			FROM public.studysets
			WHERE lower($1) <% lower(title) AND private = false AND draft = false
				AND (word_similarity(lower($1), lower(title)), to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) < ($2::float4, $3, $4::uuid)
			ORDER BY score DESC, created_at DESC, id DESC
			LIMIT $5
		`
		// cursorScore is passed as string, Postgres will parse it with ::float4
		err = pgxscan.Select(ctx, r.DB, &rows, sql, q, cursorScore, cursorTS, cursorID, limit)
	} else {
		// No cursor
		sql := `
			SELECT ` + selectCols + `
			FROM public.studysets
			WHERE lower($1) <% lower(title) AND private = false AND draft = false
			ORDER BY score DESC, created_at DESC, id DESC
			LIMIT $2
		`
		err = pgxscan.Select(ctx, r.DB, &rows, sql, q, limit)
	}
	if err != nil {
		return nil, fmt.Errorf("failed to search studysets: %w", err)
	}

	hasNext := false
	if isBackward {
		hasNext = true
	} else {
		hasNext = len(rows) > l
		if hasNext {
			rows = rows[:l]
		}
	}

	// Convert back to []*model.Studyset for the connection
	studysets := make([]*model.Studyset, len(rows))
	for i, r := range rows {
		// Make a copy or point to the embedded struct?
		// r.Studyset is embedded. We can take address of it?
		// Be careful with loop variable capturing.
		// Actually, r is a pointer to searchRow.
		// We can just return &row.Studyset?
		// Yes, r.Studyset is the struct value embedded. &r.Studyset works.
		s := r.Studyset
		studysets[i] = &s
	}

	// Manual connection building
	edges := make([]*model.StudysetEdge, 0, len(studysets))
	for i, s := range studysets {
		score := rows[i].Score
		edges = append(edges, &model.StudysetEdge{
			Node:   s,
			Cursor: cursor.EncodeStudysetScoreCursor(fmt.Sprintf("%f", score), ptrToString(s.CreatedAt), ptrToString(s.ID)),
		})
	}

	var startCursor, endCursor *string
	if len(edges) > 0 {
		startCursor = &edges[0].Cursor
		endCursor = &edges[len(edges)-1].Cursor
	}

	return &model.StudysetConnection{
		Edges: edges,
		PageInfo: &model.PageInfo{
			HasNextPage:     hasNext,
			HasPreviousPage: hasPrevious,
			StartCursor:     startCursor,
			EndCursor:       endCursor,
		},
	}, nil

	// Note: I am not using StudysetConnectionFrom because it hardcodes EncodeStudysetCursor.
	// `getCursor` var above was just to show I considered it.
}

// MyStudysets is the resolver for the myStudysets field.
func (r *queryResolver) MyStudysets(ctx context.Context, first *int32, after *string, last *int32, before *string, hideFoldered *bool) (*model.StudysetConnection, error) {
	authedUser := auth.AuthedUserContext(ctx)
	if authedUser == nil {
		return nil, fmt.Errorf("not authenticated")
	}

	l := 240
	if first != nil && *first > 0 && *first < 1000 {
		l = int(*first)
	} else if last != nil && *last > 0 && *last < 1000 {
		l = int(*last)
	}
	limit := l + 1

	cursorTS, cursorID := cursor.DecodeStudysetCursor(ptrToString(after))
	beforeCursorTS, beforeCursorID := cursor.DecodeStudysetCursor(ptrToString(before))

	isBackward := beforeCursorID != ""
	hasPrevious := false
	if !isBackward {
		hasPrevious = cursorTS != "" || cursorID != ""
	}

	var studysets []*model.Studyset
	var err error

	// Common columns for selectivity
	cols := `id, user_id, title, private, subject_id, draft, seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at`

	// Where clause fragments
	whereBase := `WHERE user_id = $1 AND draft = false`
	if hideFoldered != nil && *hideFoldered {
		whereBase += ` AND id NOT IN (SELECT fs.studyset_id FROM folder_studysets fs WHERE fs.user_id = $1)`
	}

	if isBackward {
		sql := fmt.Sprintf(`
			SELECT %s
			FROM public.studysets
			%s AND (to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) > ($2, $3::uuid)
			ORDER BY updated_at ASC, id ASC
			LIMIT $4
		`, cols, whereBase)
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, authedUser.ID, beforeCursorTS, beforeCursorID, limit)
		if err == nil {
			hasPrevious = len(studysets) > l
			if hasPrevious {
				studysets = studysets[:l]
			}
			// Reverse
			for i, j := 0, len(studysets)-1; i < j; i, j = i+1, j-1 {
				studysets[i], studysets[j] = studysets[j], studysets[i]
			}
		}
	} else if cursorID != "" {
		sql := fmt.Sprintf(`
			SELECT %s
			FROM public.studysets
			%s AND (to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) < ($2, $3::uuid)
			ORDER BY updated_at DESC, id DESC
			LIMIT $4
		`, cols, whereBase)
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, authedUser.ID, cursorTS, cursorID, limit)
	} else {
		sql := fmt.Sprintf(`
			SELECT %s
			FROM public.studysets
			%s
			ORDER BY updated_at DESC, id DESC
			LIMIT $2
		`, cols, whereBase)
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, authedUser.ID, limit)
	}
	if err != nil {
		return nil, fmt.Errorf("failed to fetch my studysets: %w", err)
	}

	hasNext := false
	if isBackward {
		hasNext = true
	} else {
		hasNext = len(studysets) > l
		if hasNext {
			studysets = studysets[:l]
		}
	}
	getCursor := func(s *model.Studyset) (string, string) {
		return ptrToString(s.UpdatedAt), ptrToString(s.ID)
	}
	return cursor.StudysetConnectionFrom(studysets, hasNext, hasPrevious, getCursor), nil
}

// MyStudysetDrafts is the resolver for the myStudysetDrafts field.
func (r *queryResolver) MyStudysetDrafts(ctx context.Context, first *int32, after *string, last *int32, before *string, hideFoldered *bool) (*model.StudysetConnection, error) {
	authedUser := auth.AuthedUserContext(ctx)
	if authedUser == nil {
		return nil, fmt.Errorf("not authenticated")
	}

	l := 240
	if first != nil && *first > 0 && *first < 1000 {
		l = int(*first)
	} else if last != nil && *last > 0 && *last < 1000 {
		l = int(*last)
	}
	limit := l + 1

	cursorTS, cursorID := cursor.DecodeStudysetCursor(ptrToString(after))
	beforeCursorTS, beforeCursorID := cursor.DecodeStudysetCursor(ptrToString(before))

	isBackward := beforeCursorID != ""
	hasPrevious := false
	if !isBackward {
		hasPrevious = cursorTS != "" || cursorID != ""
	}

	var studysets []*model.Studyset
	var err error

	cols := `id, user_id, title, private, subject_id, draft, seo_indexing_approved,
				to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at`

	whereBase := `WHERE user_id = $1 AND draft = true`
	if hideFoldered != nil && *hideFoldered {
		whereBase += ` AND id NOT IN (SELECT fs.studyset_id FROM folder_studysets fs WHERE fs.user_id = $1)`
	}

	if isBackward {
		sql := fmt.Sprintf(`
			SELECT %s
			FROM public.studysets
			%s AND (to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) > ($2, $3::uuid)
			ORDER BY updated_at ASC, id ASC
			LIMIT $4
		`, cols, whereBase)
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, authedUser.ID, beforeCursorTS, beforeCursorID, limit)
		if err == nil {
			hasPrevious = len(studysets) > l
			if hasPrevious {
				studysets = studysets[:l]
			}
			for i, j := 0, len(studysets)-1; i < j; i, j = i+1, j-1 {
				studysets[i], studysets[j] = studysets[j], studysets[i]
			}
		}
	} else if cursorID != "" {
		sql := fmt.Sprintf(`
			SELECT %s
			FROM public.studysets
			%s AND (to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), id) < ($2, $3::uuid)
			ORDER BY updated_at DESC, id DESC
			LIMIT $4
		`, cols, whereBase)
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, authedUser.ID, cursorTS, cursorID, limit)
	} else {
		sql := fmt.Sprintf(`
			SELECT %s
			FROM public.studysets
			%s
			ORDER BY updated_at DESC, id DESC
			LIMIT $2
		`, cols, whereBase)
		err = pgxscan.Select(ctx, r.DB, &studysets, sql, authedUser.ID, limit)
	}
	if err != nil {
		return nil, fmt.Errorf("failed to fetch my studyset drafts: %w", err)
	}

	hasNext := false
	if isBackward {
		hasNext = true
	} else {
		hasNext = len(studysets) > l
		if hasNext {
			studysets = studysets[:l]
		}
	}
	getCursor := func(s *model.Studyset) (string, string) {
		return ptrToString(s.UpdatedAt), ptrToString(s.ID)
	}
	return cursor.StudysetConnectionFrom(studysets, hasNext, hasPrevious, getCursor), nil
}

// MyFolders is the resolver for the myFolders field.
func (r *queryResolver) MyFolders(ctx context.Context, first *int32, after *string) (*model.FolderConnection, error) {
	authedUser := auth.AuthedUserContext(ctx)
	if authedUser == nil {
		return nil, fmt.Errorf("not authenticated")
	}

	l := 240
	if first != nil && *first > 0 && *first < 1000 {
		l = int(*first)
	}
	limit := l + 1

	cursorID := cursor.DecodeFolderCursor(ptrToString(after))
	hasPrevious := cursorID != ""

	var folders []*model.Folder
	var err error
	if cursorID != "" {
		sql := `
			SELECT id, name
			FROM folders
			WHERE user_id = $1 AND id < $2::uuid
			ORDER BY id DESC
			LIMIT $3
		`
		err = pgxscan.Select(ctx, r.DB, &folders, sql, authedUser.ID, cursorID, limit)
	} else {
		sql := `
			SELECT id, name
			FROM folders
			WHERE user_id = $1
			ORDER BY id DESC
			LIMIT $2
		`
		err = pgxscan.Select(ctx, r.DB, &folders, sql, authedUser.ID, limit)
	}
	if err != nil {
		return nil, fmt.Errorf("failed to fetch my folders: %w", err)
	}

	hasNext := len(folders) > l
	if hasNext {
		folders = folders[:l]
	}
	edges := make([]*model.FolderEdge, 0, len(folders))
	for _, f := range folders {
		idStr := f.ID
		edges = append(edges, &model.FolderEdge{
			Node:   f,
			Cursor: cursor.EncodeFolderCursor(ptrToString(idStr)),
		})
	}
	var startCursor, endCursor *string
	if len(edges) > 0 {
		startCursor = &edges[0].Cursor
		endCursor = &edges[len(edges)-1].Cursor
	}
	return &model.FolderConnection{
		Edges: edges,
		PageInfo: &model.PageInfo{
			HasNextPage:     hasNext,
			HasPreviousPage: hasPrevious,
			StartCursor:     startCursor,
			EndCursor:       endCursor,
		},
	}, nil
}

// MySavedStudysets is the resolver for the mySavedStudysets field.
func (r *queryResolver) MySavedStudysets(ctx context.Context, first *int32, after *string, last *int32, before *string) (*model.StudysetConnection, error) {
	authedUser := auth.AuthedUserContext(ctx)
	if authedUser == nil {
		return nil, fmt.Errorf("not authenticated")
	}

	l := 240
	if first != nil && *first > 0 && *first < 1000 {
		l = int(*first)
	} else if last != nil && *last > 0 && *last < 1000 {
		l = int(*last)
	}
	limit := l + 1

	cursorTS, cursorID := cursor.DecodeStudysetCursor(ptrToString(after))
	beforeCursorTS, beforeCursorID := cursor.DecodeStudysetCursor(ptrToString(before))

	isBackward := beforeCursorID != ""
	hasPrevious := false
	if !isBackward {
		hasPrevious = cursorTS != "" || cursorID != ""
	}

	var rows []*cursor.SavedStudysetRow
	var err error
	if isBackward {
		sql := `
			SELECT
				s.id,
				s.user_id,
				s.title,
				s.draft,
				s.private,
				s.subject_id,
				s.seo_indexing_approved,
				to_char(s.created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(s.updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at,
				to_char(saved_studysets.timestamp, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as saved_at
			FROM saved_studysets
			JOIN studysets s ON saved_studysets.studyset_id = s.id
			WHERE saved_studysets.user_id = $1
				AND s.private = false AND s.draft = false
				AND (to_char(saved_studysets.timestamp, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), s.id) > ($2, $3::uuid)
			ORDER BY saved_studysets.timestamp ASC, s.id ASC
			LIMIT $4
		`
		err = pgxscan.Select(ctx, r.DB, &rows, sql, authedUser.ID, beforeCursorTS, beforeCursorID, limit)
		if err == nil {
			hasPrevious = len(rows) > l
			if hasPrevious {
				rows = rows[:l]
			}
			// Reverse
			for i, j := 0, len(rows)-1; i < j; i, j = i+1, j-1 {
				rows[i], rows[j] = rows[j], rows[i]
			}
		}
	} else if cursorID != "" {
		sql := `
			SELECT
				s.id,
				s.user_id,
				s.title,
				s.draft,
				s.private,
				s.subject_id,
				s.seo_indexing_approved,
				to_char(s.created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(s.updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at,
				to_char(saved_studysets.timestamp, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as saved_at
			FROM saved_studysets
			JOIN studysets s ON saved_studysets.studyset_id = s.id
			WHERE saved_studysets.user_id = $1
				AND s.private = false AND s.draft = false
				AND (to_char(saved_studysets.timestamp, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM'), s.id) < ($2, $3::uuid)
			ORDER BY saved_studysets.timestamp DESC, s.id DESC
			LIMIT $4
		`
		err = pgxscan.Select(ctx, r.DB, &rows, sql, authedUser.ID, cursorTS, cursorID, limit)
	} else {
		sql := `
			SELECT
				s.id,
				s.user_id,
				s.title,
				s.draft,
				s.private,
				s.subject_id,
				s.seo_indexing_approved,
				to_char(s.created_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as created_at,
				to_char(s.updated_at, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as updated_at,
				to_char(saved_studysets.timestamp, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as saved_at
			FROM saved_studysets
			JOIN studysets s ON saved_studysets.studyset_id = s.id
			WHERE saved_studysets.user_id = $1
				AND s.private = false AND s.draft = false
			ORDER BY saved_studysets.timestamp DESC, s.id DESC
			LIMIT $2
		`
		err = pgxscan.Select(ctx, r.DB, &rows, sql, authedUser.ID, limit)
	}
	if err != nil {
		return nil, fmt.Errorf("failed to fetch saved studysets: %w", err)
	}

	hasNext := false
	if isBackward {
		hasNext = true
	} else {
		hasNext = len(rows) > l
		if hasNext {
			rows = rows[:l]
		}
	}
	edges := make([]*model.StudysetEdge, 0, len(rows))
	for _, row := range rows {
		edges = append(edges, &model.StudysetEdge{
			Node:   &row.Studyset,
			Cursor: cursor.EncodeStudysetCursor(ptrToString(row.SavedAt), ptrToString(row.ID)),
		})
	}
	var startCursor, endCursor *string
	if len(edges) > 0 {
		startCursor = &edges[0].Cursor
		endCursor = &edges[len(edges)-1].Cursor
	}
	return &model.StudysetConnection{
		Edges: edges,
		PageInfo: &model.PageInfo{
			HasNextPage:     hasNext,
			HasPreviousPage: hasPrevious,
			StartCursor:     startCursor,
			EndCursor:       endCursor,
		},
	}, nil
}

// PracticeTest is the resolver for the practiceTest field.
func (r *queryResolver) PracticeTest(ctx context.Context, id string) (*model.PracticeTest, error) {
	authedUser := auth.AuthedUserContext(ctx)
	if authedUser == nil {
		return nil, fmt.Errorf("not authenticated")
	}

	var practiceTest model.PracticeTest
	err := pgxscan.Get(
		ctx,
		r.DB,
		&practiceTest,
		`SELECT id,
	to_char(timestamp, 'YYYY-MM-DD"T"HH24:MI:SS.MSTZH:TZM') as timestamp,
	questions_correct,
	questions_total,
	questions
FROM practice_tests
WHERE id = $1 AND user_id = $2`,
		id,
		authedUser.ID,
	)
	if err != nil {
		return nil, fmt.Errorf("failed to fetch practice test by id: %w", err)
	}

	return &practiceTest, nil
}

// Subject is the resolver for the subject field.
func (r *queryResolver) Subject(ctx context.Context, id string) (*model.Subject, error) {
	var subject model.Subject
	err := pgxscan.Get(
		ctx,
		r.DB,
		&subject,
		`SELECT id, name, category
FROM subjects WHERE id = $1`,
		id,
	)
	if err != nil {
		return nil, fmt.Errorf("failed to get subject by id: %w", err)
	}

	return &subject, nil
}

// SubjectsByKeyword is the resolver for the subjectsByKeyword field.
func (r *queryResolver) SubjectsByKeyword(ctx context.Context, keyword *string) ([]*model.Subject, error) {
	var subjects []*model.Subject
	err := pgxscan.Select(
		ctx,
		r.DB,
		&subjects,
		`SELECT s.id, s.name, s.category
FROM subjects s
JOIN subject_keywords sk ON sk.subject_id = s.id
WHERE sk.keyword = $1`,
		keyword,
	)
	if err != nil {
		return nil, fmt.Errorf("failed to get subject by id: %w", err)
	}

	return subjects, nil
}

// SubjectsByCategory is the resolver for the subjectsByCategory field.
func (r *queryResolver) SubjectsByCategory(ctx context.Context, category *model.SubjectCategory) ([]*model.Subject, error) {
	var subjects []*model.Subject
	err := pgxscan.Select(
		ctx,
		r.DB,
		&subjects,
		`SELECT id, name, category
FROM subjects
WHERE category = $1`,
		category,
	)
	if err != nil {
		return nil, fmt.Errorf("failed to get subjects by category: %w", err)
	}

	return subjects, nil
}

// AllSubjects is the resolver for the allSubjects field.
func (r *queryResolver) AllSubjects(ctx context.Context) ([]*model.Subject, error) {
	var subjects []*model.Subject
	err := pgxscan.Select(
		ctx,
		r.DB,
		&subjects,
		`SELECT id, name, category FROM subjects`,
	)
	if err != nil {
		return nil, fmt.Errorf("failed to get all subjects: %w", err)
	}

	return subjects, nil
}

// Folder is the resolver for the folder field.
func (r *queryResolver) Folder(ctx context.Context, id string) (*model.Folder, error) {
	authedUser := auth.AuthedUserContext(ctx)
	if authedUser == nil {
		return nil, fmt.Errorf("not authenticated")
	}

	var folder model.Folder
	sql := `
		SELECT
			id,
			name
		FROM folders
		WHERE id = $1 AND user_id = $2
	`
	err := pgxscan.Get(ctx, r.DB, &folder, sql, id, authedUser.ID)
	if err != nil {
		if pgxscan.NotFound(err) {
			return nil, nil
		}
		return nil, fmt.Errorf("failed to get folder: %w", err)
	}

	return &folder, nil
}

// StudysetCount is the resolver for the studysetCount field.
func (r *queryResolver) StudysetCount(ctx context.Context, after *string, includePrivate *bool, includeDrafts *bool) (int32, error) {
	incPrivate := false
	if includePrivate != nil {
		incPrivate = *includePrivate
	}
	incDrafts := false
	if includeDrafts != nil {
		incDrafts = *includeDrafts
	}

	if after == nil {
		var count int32
		err := r.DB.QueryRow(ctx, "SELECT COUNT(*) FROM studysets WHERE (private = false OR $1 = true) AND (draft = false OR $2 = true)", incPrivate, incDrafts).Scan(&count)
		if err != nil {
			return 0, fmt.Errorf("failed to fetch total studysets: %w", err)
		}
		return count, nil
	}

	afterTime, err := time.Parse(time.RFC3339, *after)
	if err != nil {
		return 0, fmt.Errorf("invalid date format: %w", err)
	}

	var count int32
	err = r.DB.QueryRow(ctx, "SELECT COUNT(*) FROM studysets WHERE (private = false OR $1 = true) AND (draft = false OR $2 = true) AND created_at > $3", incPrivate, incDrafts, afterTime).Scan(&count)
	if err != nil {
		return 0, fmt.Errorf("failed to fetch studysets after date: %w", err)
	}
	return count, nil
}

// StudysetUpdateCount is the resolver for the studysetUpdateCount field.
func (r *queryResolver) StudysetUpdateCount(ctx context.Context, after *string, includePrivate *bool, includeDrafts *bool) (int32, error) {
	incPrivate := false
	if includePrivate != nil {
		incPrivate = *includePrivate
	}
	incDrafts := false
	if includeDrafts != nil {
		incDrafts = *includeDrafts
	}

	if after == nil {
		var count int32
		err := r.DB.QueryRow(ctx, "SELECT COUNT(*) FROM studysets WHERE (private = false OR $1 = true) AND (draft = false OR $2 = true)", incPrivate, incDrafts).Scan(&count)
		if err != nil {
			return 0, fmt.Errorf("failed to fetch total studysets: %w", err)
		}
		return count, nil
	}

	afterTime, err := time.Parse(time.RFC3339, *after)
	if err != nil {
		return 0, fmt.Errorf("invalid date format: %w", err)
	}

	var count int32
	err = r.DB.QueryRow(ctx, "SELECT COUNT(*) FROM studysets WHERE (private = false OR $1 = true) AND (draft = false OR $2 = true) AND updated_at > $3", incPrivate, incDrafts, afterTime).Scan(&count)
	if err != nil {
		return 0, fmt.Errorf("failed to fetch studysets updated after date: %w", err)
	}
	return count, nil
}

// SearchStudysetCount is the resolver for the searchStudysetCount field.
func (r *queryResolver) SearchStudysetCount(ctx context.Context, q string) (int32, error) {
	if len(q) < 1 {
		return 0, nil
	}
	if len(q) > 200 {
		q = q[:200]
	}

	var count int32
	// Matching the WHERE clause of SearchStudysets
	sql := `
		SELECT COUNT(*)
		FROM public.studysets
		WHERE lower($1) <% lower(title) AND private = false AND draft = false
	`
	err := r.DB.QueryRow(ctx, sql, q).Scan(&count)
	if err != nil {
		return 0, fmt.Errorf("failed to count search results: %w", err)
	}
	return count, nil
}

// MyStudysetCount is the resolver for the myStudysetCount field.
func (r *queryResolver) MyStudysetCount(ctx context.Context, hideFoldered *bool, includeDrafts *bool) (int32, error) {
	authedUser := auth.AuthedUserContext(ctx)
	if authedUser == nil {
		return 0, fmt.Errorf("not authenticated")
	}

	incDrafts := false
	if includeDrafts != nil {
		incDrafts = *includeDrafts
	}

	sql := `SELECT COUNT(*) FROM studysets WHERE user_id = $1 AND (draft = false OR $2 = true)`
	args := []interface{}{authedUser.ID, incDrafts}

	if hideFoldered != nil && *hideFoldered {
		sql += ` AND NOT EXISTS (
			SELECT 1 FROM folder_studysets fs 
			WHERE fs.studyset_id = studysets.id
		)`
	}

	var count int32
	err := r.DB.QueryRow(ctx, sql, args...).Scan(&count)
	if err != nil {
		return 0, fmt.Errorf("failed to count my studysets: %w", err)
	}

	return count, nil
}

// MySavedStudysetCount is the resolver for the mySavedStudysetCount field.
func (r *queryResolver) MySavedStudysetCount(ctx context.Context) (int32, error) {
	authedUser := auth.AuthedUserContext(ctx)
	if authedUser == nil {
		return 0, fmt.Errorf("not authenticated")
	}

	// Only counting public saved studysets to match MySavedStudysets resolver logic
	sql := `
		SELECT COUNT(*)
		FROM saved_studysets
		JOIN studysets s ON saved_studysets.studyset_id = s.id
		WHERE saved_studysets.user_id = $1
			AND s.private = false AND s.draft = false
	`
	var count int32
	err := r.DB.QueryRow(ctx, sql, authedUser.ID).Scan(&count)
	if err != nil {
		return 0, fmt.Errorf("failed to count saved studysets: %w", err)
	}
	return count, nil
}

// PracticeTest returns graph.PracticeTestResolver implementation.
func (r *Resolver) PracticeTest() graph.PracticeTestResolver { return &practiceTestResolver{r} }

// Query returns graph.QueryResolver implementation.
func (r *Resolver) Query() graph.QueryResolver { return &queryResolver{r} }

type practiceTestResolver struct{ *Resolver }
type queryResolver struct{ *Resolver }