package query

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"queryorchestration/internal/database"
	resultprocessor "queryorchestration/internal/query/result/processor"
	"queryorchestration/internal/server/validation"
	"strings"

	"github.com/google/uuid"
)

type Config interface {
	GetConfig() *string
	SetConfig(*string)
}

func (s *Service) normalizeConfig(config Config) error {
	if config == nil || config.GetConfig() == nil {
		return nil
	}

	trim := strings.TrimSpace(*config.GetConfig())

	if trim == "" {
		config.SetConfig(nil)
		return nil
	}

	if !json.Valid([]byte(trim)) {
		return errors.New("invalid config JSON")
	}

	var data map[string]interface{}
	if err := json.Unmarshal([]byte(trim), &data); err != nil {
		return fmt.Errorf("error unmarshalling JSON: %s", err)
	}

	prettyJSON, err := json.Marshal(data)
	if err != nil {
		return fmt.Errorf("error marshalling JSON: %s", err)
	}

	strJSON := string(prettyJSON)

	config.SetConfig(&strJSON)

	return nil
}

type RequiredQueryIDs interface {
	GetRequiredQueryIDs() *[]uuid.UUID
	SetRequiredQueryIDs(*[]uuid.UUID)
}

func (s *Service) NormalizeQueryIDs(ctx context.Context, ids RequiredQueryIDs) error {
	if ids == nil || ids.GetRequiredQueryIDs() == nil {
		return nil
	}

	ide := ids.GetRequiredQueryIDs()

	if len(*ide) == 0 {
		ids.SetRequiredQueryIDs(nil)
		return nil
	}

	dedup := validation.DeduplicateArray(*ide)
	ids.SetRequiredQueryIDs(&dedup)

	dbids := database.MustToDBUUIDArray(dedup)

	exist, err := s.db.Queries.AllQueriesExist(ctx, dbids)
	if err != nil {
		return err
	} else if !exist {
		return errors.New("not all required ids are present")
	}

	return nil
}

func (s *Service) normalizeActiveVersion(current *Query, entity *resultprocessor.Update) error {
	if current == nil {
		return errors.New("current query required")
	}

	if entity == nil {
		return nil
	}

	err := validation.NormalizeInClosedInterval(&entity.ActiveVersion, current.ActiveVersion, 1, current.LatestVersion+1)
	if err != nil {
		return err
	}

	return nil
}