package document

import (
	"context"
	"gotemplate/internal/collector"
	"gotemplate/internal/database"
	"gotemplate/internal/database/repository"
	"gotemplate/internal/query"

	"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 *repository.Queries
}

func New(db *repository.Queries) *Service {
	return &Service{
		db: 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 := query.NewQueue(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) (*[]query.Result, error) {
	docID, err := database.ToDBUUID(id)
	if err != nil {
		return nil, err
	}

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

	cleanResults := make([]query.Result, len(results))
	for index, dbResult := range results {
		cleanResults[index] = *s.parseResult(&dbResult)
	}

	return &cleanResults, nil
}

func (s *Service) parseResult(dbQuery *repository.ListResultsByDocumentIDRow) *query.Result {
	return &query.Result{
		ID:           database.MustToUUID(dbQuery.ID),
		QueryID:      database.MustToUUID(dbQuery.Queryid),
		QueryVersion: dbQuery.Queryversion,
	}
}