package models

import (
	"context"
	"database/sql"
	. "github.com/go-jet/jet/v2/postgres"
	"screenmark/screenmark/.gen/haystack/haystack/model"
	. "screenmark/screenmark/.gen/haystack/haystack/table"

	"github.com/google/uuid"
)

type EventModel struct {
	dbPool *sql.DB
}

func (m EventModel) Save(ctx context.Context, userId uuid.UUID, event model.Events) (model.Events, error) {
	// TODO tx here
	insertEventStmt := Events.
		INSERT(Events.Name, Events.Description).
		VALUES(event.Name, event.Description).
		RETURNING(Events.AllColumns)

	insertedEvent := model.Events{}
	err := insertEventStmt.QueryContext(ctx, m.dbPool, &insertedEvent)

	if err != nil {
		return insertedEvent, err
	}

	insertUserEventStmt := UserEvents.
		INSERT(UserEvents.UserID, UserEvents.EventID).
		VALUES(userId, insertedEvent.ID).
		RETURNING(UserEvents.AllColumns)

	_, err = insertUserEventStmt.ExecContext(ctx, m.dbPool)

	return insertedEvent, err
}

func (m EventModel) SaveToImage(ctx context.Context, userId uuid.UUID, imageId uuid.UUID, event model.Events) error {
	event, err := m.Save(ctx, userId, event)

	if err != nil {
		return err
	}

	insertImageEventStmt := ImageEvents.
		INSERT(ImageEvents.ImageID, ImageEvents.EventID).
		VALUES(imageId, event.ID)

	_, err = insertImageEventStmt.ExecContext(ctx, m.dbPool)

	return err
}

func (m EventModel) UpdateLocation(ctx context.Context, eventId uuid.UUID, locationId uuid.UUID) (model.Events, error) {
	updateEventLocationStmt := Events.
		UPDATE(Events.LocationID).
		SET(locationId).
		WHERE(Events.ID.EQ(UUID(eventId))).
		RETURNING(Events.AllColumns)

	updatedEvent := model.Events{}
	err := updateEventLocationStmt.QueryContext(ctx, m.dbPool, &updatedEvent)

	return updatedEvent, err
}

func NewEventModel(db *sql.DB) EventModel {
	return EventModel{dbPool: db}
}