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.UserImages

	Image struct {
		model.Image
		ImageLists []model.ImageLists
	}
}

func (m UserModel) GetUserImages(ctx context.Context, userId uuid.UUID) ([]UserImageWithImage, error) {
	getUserImagesStmt := SELECT(
		UserImages.AllColumns,
		Image.ID,
		Image.ImageName,
		Image.Description,
		ImageLists.AllColumns,
	).
		FROM(
			UserImages.
				INNER_JOIN(Image, Image.ID.EQ(UserImages.ImageID)).
				INNER_JOIN(ImageLists, ImageLists.ImageID.EQ(UserImages.ImageID)),
		).
		WHERE(UserImages.UserID.EQ(UUID(userId)))

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

	return userImages, err
}

type ListsWithImages struct {
	model.Lists

	Schema struct {
		model.Schemas

		SchemaItems []model.SchemaItems
	}

	Images []struct {
		model.ImageLists

		Items []model.ImageSchemaItems
	}
}

func (m UserModel) ListWithImages(ctx context.Context, userId uuid.UUID) ([]ListsWithImages, error) {
	stmt := SELECT(
		Lists.AllColumns,
		ImageLists.AllColumns,
		Schemas.AllColumns,
		SchemaItems.AllColumns,
		ImageSchemaItems.AllColumns,
	).
		FROM(
			Lists.
				INNER_JOIN(ImageLists, ImageLists.ListID.EQ(Lists.ID)).
				INNER_JOIN(Schemas, Schemas.ListID.EQ(Lists.ID)).
				INNER_JOIN(SchemaItems, SchemaItems.SchemaID.EQ(Schemas.ID)).
				INNER_JOIN(ImageSchemaItems, ImageSchemaItems.ImageID.EQ(ImageLists.ImageID)),
		).
		WHERE(Lists.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}
}