package queryprocessor

import (
	"fmt"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
)

func ParseDBNullType(qType repository.NullQuerytype) (Type, error) {
	if !qType.Valid {
		return TypeJsonExtractor, fmt.Errorf("invalid database query type")
	}

	return ParseDBType(qType.Querytype)
}

func ParseDBType(qType repository.Querytype) (Type, error) {
	switch qType {
	case repository.QuerytypeJsonExtractor:
		return TypeJsonExtractor, nil
	case repository.QuerytypeContextFull:
		return TypeContextFull, nil
	default:
		return TypeJsonExtractor, fmt.Errorf("invalid database query type")
	}
}

func ToDBQueryType(t Type) (repository.Querytype, error) {
	var dbType repository.Querytype

	switch t {
	case TypeJsonExtractor:
		dbType = repository.QuerytypeJsonExtractor
	case TypeContextFull:
		dbType = repository.QuerytypeContextFull
	default:
		return repository.QuerytypeContextFull, fmt.Errorf("invalid database query type")
	}

	return dbType, nil
}

func ToDBQueryTypeArray(t []Type) ([]repository.Querytype, error) {
	arr := make([]repository.Querytype, len(t))
	for index, value := range t {
		v, err := ToDBQueryType(value)
		if err != nil {
			return nil, err
		}

		arr[index] = v
	}

	return arr, nil
}

func ToDBNullQueryType(t Type) (repository.NullQuerytype, error) {
	dbType, err := ToDBQueryType(t)
	if err != nil {
		return repository.NullQuerytype{}, err
	}

	return repository.NullQuerytype{Querytype: dbType, Valid: true}, nil
}

func ParseDBCollectorQuery(q *repository.GetCollectorQueriesRow) (*Query, error) {
	reqQueryIDs := database.MustToUUIDArray(q.Requiredids)

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

	return &Query{
		ID:               database.MustToUUID(q.Queryid),
		Version:          *q.Queryversion,
		Type:             qType,
		RequiredQueryIDs: reqQueryIDs,
	}, nil
}