package document

import (
	"context"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/job/collector"
	queryqueue "queryorchestration/internal/query/queue"
	"queryorchestration/internal/query/result"

	"github.com/google/uuid"
)

type Document struct {
	ID           uuid.UUID `json:"id" validate:"required,uuid"`
	JobID        uuid.UUID `json:"jobId" validate:"required,uuid"`
	Name         string    `json:"name" validate:"required"`
	CleanVersion int32     `json:"cleanVersion" validate:"required,gt=0"`
	TextVersion  int32     `json:"textVersion" validate:"required,gt=0"`
}

type Services struct {
	Collector *collector.Service
}

type Service struct {
	db  *database.Connection
	svc *Services
}

func New(db *database.Connection, svc *Services) *Service {
	return &Service{
		db,
		svc,
	}
}

func (s *Service) Sync(ctx context.Context, doc *Document) error {
	coll, err := s.svc.Collector.GetByJobID(ctx, doc.JobID)
	if err != nil {
		return err
	}

	results, err := s.getResults(ctx, doc.ID, coll)
	if err != nil {
		return err
	}

	queue, err := queryqueue.New(ctx, &queryqueue.NewConfig{
		DB:           s.db,
		Collector:    coll,
		Results:      results,
		DocumentID:   doc.ID,
		CleanVersion: doc.CleanVersion,
		TextVersion:  doc.TextVersion,
	})
	if err != nil {
		return err
	}

	err = queue.Execute(ctx)
	if err != nil {
		return err
	}

	return nil
}

func (s *Service) getResults(ctx context.Context, id uuid.UUID, coll *collector.Collector) ([]*result.Result, error) {
	docID := database.MustToDBUUID(id)

	results, err := s.db.Queries.ListResultsByDocumentID(ctx, &repository.ListResultsByDocumentIDParams{
		Documentid:   docID,
		Textversion:  coll.MinTextVersion,
		Cleanversion: coll.MinCleanVersion,
	})
	if err != nil {
		return nil, err
	}

	cleanResults := make([]*result.Result, len(results))
	for index, dbResult := range results {
		cleanResults[index] = result.Parse(dbResult)
	}

	return cleanResults, nil
}