package query

import (
	"context"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	queryprocessor "queryorchestration/internal/query/processor"

	"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) {
	var reqQueryIDs *[]uuid.UUID
	if len(q.Requiredids) > 0 {
		rQ, err := database.ToUUIDArray(q.Requiredids)
		if err != nil {
			return nil, err
		}
		reqQueryIDs = &rQ
	}

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

	var scfg *string
	if q.Config != nil && string(q.Config) != "" {
		s := string(q.Config)
		scfg = &s
	}

	return &Query{
		ID:               database.MustToUUID(q.ID),
		ActiveVersion:    q.Activeversion,
		LatestVersion:    q.Latestversion,
		Type:             qType,
		RequiredQueryIDs: reqQueryIDs,
		Config:           scfg,
	}, 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
}