package result

import (
	"context"
	"errors"
	"fmt"
	resultprocessor "queryorchestration/internal/query/result/processor"
	contextfull "queryorchestration/internal/query/types/contextFull"
	jsonextractor "queryorchestration/internal/query/types/jsonExtractor"

	"github.com/google/uuid"
)

type Process struct {
	DocumentID      uuid.UUID
	MinCleanVersion int32
	MinTextVersion  int32
	Query           *resultprocessor.Query
}

func (s *Service) Process(ctx context.Context, p *Process) (resultprocessor.Value, error) {
	values, err := s.listRequiredValues(ctx, p)
	if err != nil {
		return nil, err
	}

	processor, err := s.getProcessor(p.Query.Type)
	if err != nil {
		return nil, err
	}

	val, err := processor.Process(ctx, p.Query, values)
	if err != nil {
		return nil, err
	}

	return getValueByType(p.Query.Type, val)
}

func (s *Service) listRequiredValues(ctx context.Context, p *Process) (*[]resultprocessor.Value, error) {
	if p == nil || p.Query == nil || p.Query.RequiredQueryIDs == nil || len(*p.Query.RequiredQueryIDs) == 0 {
		return nil, nil
	}

	values, err := s.ListQueryRequirementValues(ctx, &ListQueryRequirementValuesParams{
		QueryID:         p.Query.ID,
		QueryVersion:    p.Query.Version,
		DocumentID:      p.DocumentID,
		MinCleanVersion: p.MinCleanVersion,
		MinTextVersion:  p.MinTextVersion,
	})
	if err != nil {
		return nil, err
	} else if values == nil || len(*values) != len(*p.Query.RequiredQueryIDs) {
		return nil, errors.New("document not synced")
	}

	return values, nil
}

func (s *Service) getProcessor(queryType resultprocessor.Type) (resultprocessor.Processor, error) {
	switch queryType {
	case resultprocessor.TypeJsonExtractor:
		return jsonextractor.NewExtractor(s.cfg), nil
	case resultprocessor.TypeContextFull:
		return contextfull.NewExtractor(), nil
	default:
		return nil, fmt.Errorf("attempting to process invalid query type")
	}
}