package document

import (
	"context"
	"queryorchestration/internal/collector"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	queryqueue "queryorchestration/internal/queryQueue"
	"queryorchestration/internal/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 Service struct {
	db *database.Connection
}

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

func (s *Service) Sync(ctx context.Context, doc *Document) error {
	collector, err := collector.NewByJobId(ctx, s.db, doc.JobID)
	if err != nil {
		return err
	}

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

	queue, err := queryqueue.New(ctx, s.db, collector, results, doc.ID, doc.CleanVersion, 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
}