package models

import (
	"context"
	"database/sql"
	"screenmark/screenmark/.gen/haystack/haystack/model"
	. "screenmark/screenmark/.gen/haystack/haystack/table"

	. "github.com/go-jet/jet/v2/postgres"
	"github.com/go-jet/jet/v2/qrm"
	"github.com/google/uuid"
)

type UserModel struct {
	dbPool *sql.DB
}

type ImageWithProperties struct {
	ID uuid.UUID

	Image model.Image
}

func (m UserModel) GetUserIdFromEmail(ctx context.Context, email string) (uuid.UUID, error) {
	getUserIdStmt := Users.SELECT(Users.ID).WHERE(Users.Email.EQ(String(email)))

	user := model.Users{}
	err := getUserIdStmt.QueryContext(ctx, m.dbPool, &user)

	return user.ID, err
}

func (m UserModel) DoesUserExist(ctx context.Context, email string) bool {
	getUserIdStmt := Users.SELECT(Users.ID).WHERE(Users.Email.EQ(String(email)))

	user := model.Users{}
	err := getUserIdStmt.QueryContext(ctx, m.dbPool, &user)

	return err != qrm.ErrNoRows
}

func (m UserModel) Save(ctx context.Context, user model.Users) (model.Users, error) {
	insertUserStmt := Users.INSERT(Users.Email).VALUES(user.Email).RETURNING(Users.AllColumns)

	insertedUser := model.Users{}
	err := insertUserStmt.QueryContext(ctx, m.dbPool, &insertedUser)

	return insertedUser, err
}

type UserImageWithImage struct {
	model.Image
	ImageStacks []model.ImageStacks
}

func (m UserModel) GetUserImages(ctx context.Context, userId uuid.UUID) ([]UserImageWithImage, error) {
	getUserImagesStmt := SELECT(
		Image.AllColumns.Except(Image.Image),
		ImageStacks.AllColumns,
	).
		FROM(
			Image.
				LEFT_JOIN(ImageStacks, ImageStacks.ImageID.EQ(Image.ID)),
		).
		WHERE(Image.UserID.EQ(UUID(userId)))

	userImages := []UserImageWithImage{}
	err := getUserImagesStmt.QueryContext(ctx, m.dbPool, &userImages)

	return userImages, err
}

type ListsWithImages struct {
	model.Stacks

	SchemaItems []model.SchemaItems

	Images []struct {
		model.ImageStacks

		Items []model.ImageSchemaItems
	}
}

func (m UserModel) ListWithImages(ctx context.Context, userId uuid.UUID) ([]ListsWithImages, error) {
	stmt := SELECT(
		Stacks.AllColumns,
		ImageStacks.AllColumns,
		SchemaItems.AllColumns,
		ImageSchemaItems.AllColumns,
	).
		FROM(
			Stacks.
				INNER_JOIN(SchemaItems, SchemaItems.StackID.EQ(Stacks.ID)).
				LEFT_JOIN(ImageStacks, ImageStacks.StackID.EQ(Stacks.ID)).
				LEFT_JOIN(ImageSchemaItems, ImageSchemaItems.ImageID.EQ(ImageStacks.ID)),
		).
		WHERE(Stacks.UserID.EQ(UUID(userId)))

	lists := []ListsWithImages{}
	err := stmt.QueryContext(ctx, m.dbPool, &lists)

	return lists, err
}

func NewUserModel(db *sql.DB) UserModel {
	return UserModel{dbPool: db}
}