package models

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

	"github.com/google/uuid"
)

type EventModel struct {
	dbPool *sql.DB
}

// This looks stupid
func getEventValues(event model.Events) []any {
	arr := make([]any, 0)

	if event.Description != nil {
		arr = append(arr, *event.Description)
	} else {
		arr = append(arr, nil)
	}

	if event.LocationID != nil {
		arr = append(arr, *event.LocationID)
	} else {
		arr = append(arr, nil)
	}

	return arr
}

func (m EventModel) Save(ctx context.Context, events []model.Events) (model.Events, error) {
	insertEventStmt := Events.
		INSERT(Events.Name, Events.Description)

	for _, event := range events {
		insertEventStmt = insertEventStmt.VALUES(event.Name, getEventValues(event)...)
	}

	insertEventStmt = insertEventStmt.RETURNING(Events.AllColumns)

	log.Println(insertEventStmt.DebugSql())

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

	return insertedEvent, err
}

func (m EventModel) SaveToImage(ctx context.Context, imageId uuid.UUID, events []model.Events) error {
	if len(events) == 0 {
		return nil
	}

	event, err := m.Save(ctx, events)

	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 NewEventModel(db *sql.DB) EventModel {
	return EventModel{dbPool: db}
}