package query

import (
	"context"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	queryprocessor "queryorchestration/internal/queryProcessor"

	"github.com/google/uuid"
)

type Query struct {
	ID               uuid.UUID
	Type             queryprocessor.Type
	ActiveVersion    int32
	LatestVersion    int32
	RequiredQueryIDs []uuid.UUID
	Config           string
}

func (s *Service) Get(ctx context.Context, id uuid.UUID) (*Query, error) {
	query, err := s.db.Queries.GetQuery(ctx, database.MustToDBUUID(id))
	if err != nil {
		return nil, err
	}

	return ParseFullActiveQuery(query)
}

func ParseFullActiveQuery(q *repository.Fullactivequery) (*Query, error) {
	reqQueryIDs := []uuid.UUID{}
	if !(len(q.Requiredids) == 0 || len(q.Requiredids) == 1 && database.MustToUUID(q.Requiredids[0]) == uuid.Nil) {
		reqQueryIDs = database.MustToUUIDArray(q.Requiredids)
	}

	qType, err := queryprocessor.ParseDBType(q.Type)
	if err != nil {
		return nil, err
	}

	return &Query{
		ID:               database.MustToUUID(q.ID),
		ActiveVersion:    q.Activeversion,
		LatestVersion:    q.Latestversion,
		Type:             qType,
		RequiredQueryIDs: reqQueryIDs,
		Config:           string(q.Config),
	}, nil
}

func ParseFullActiveQueryArray(q []*repository.Fullactivequery) ([]*Query, error) {
	queries := make([]*Query, len(q))
	for index, query := range q {
		q, err := ParseFullActiveQuery(query)
		if err != nil {
			return nil, err
		}

		queries[index] = q
	}

	return queries, nil
}