package store

import (
	"context"
	"fmt"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgxpool"

	"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
)

type ScheduledMessageEventStore interface {
	Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessageEvent, error)
	Delete(ctx context.Context, id uuid.UUID) error
	CreateScheduledMessageEvent(ctx context.Context, event *scheduling.ScheduledMessageEvent) error
	Exists(ctx context.Context, event *scheduling.ScheduledMessageEvent) (bool, error)
}

type PGScheduledMessageEventStore struct {
	db *pgxpool.Pool
}

func NewScheduledMessageEventStore(db *pgxpool.Pool) *PGScheduledMessageEventStore {
	return &PGScheduledMessageEventStore{db: db}
}

func (s *PGScheduledMessageEventStore) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessageEvent, error) {
	query := `SELECT id, recipient_id, message_id, scheduled_message_id, created FROM scheduled_message_events WHERE id = $1`

	var event scheduling.ScheduledMessageEvent
	err := s.db.QueryRow(ctx, query, id).Scan(
		&event.Id, &event.RecipientId, &event.MessageId, &event.ScheduledMessageId, &event.Created,
	)

	if err == pgx.ErrNoRows {
		return nil, nil
	} else if err != nil {
		return nil, fmt.Errorf("getting scheduled message event by ID: %w", err)
	} else {
		return &event, nil
	}
}

func (s *PGScheduledMessageEventStore) Delete(ctx context.Context, id uuid.UUID) error {
	query := `
		DELETE FROM scheduled_message_events WHERE id = $1
	`

	commandTag, err := s.db.Exec(ctx, query, id)
	if err != nil {
		return fmt.Errorf("error deleting event: %w", err)
	}

	if commandTag.RowsAffected() == 0 {
		return fmt.Errorf("no event found with id %d", id)
	} else {
		return nil
	}
}

func (s *PGScheduledMessageEventStore) CreateScheduledMessageEvent(ctx context.Context, event *scheduling.ScheduledMessageEvent) error {
	query := `
		INSERT INTO scheduled_message_events (recipient_id, message_id, scheduled_message_id)
		VALUES ($1, $2, $3)
		RETURNING id, created
	`

	return s.db.QueryRow(ctx, query, event.RecipientId, event.MessageId, event.ScheduledMessageId).Scan(
		&event.Id, &event.Created,
	)
}

func (s *PGScheduledMessageEventStore) Exists(ctx context.Context, event *scheduling.ScheduledMessageEvent) (bool, error) {
	query := `SELECT EXISTS(SELECT 1 FROM scheduled_message_events WHERE scheduled_message_id = $1 AND recipient_id = $2)`

	var exists bool
	err := s.db.QueryRow(ctx, query, event.ScheduledMessageId, event.RecipientId).Scan(&exists)
	if err != nil {
		return false, fmt.Errorf("Scheduled message event does not exist: %w", err)
	} else {
		return exists, nil
	}
}