package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"gitea.maximumdirect.net/eric/ConfigKit"
	"gitea.maximumdirect.net/eric/promptkit"
)

type summary struct {
	PromptID        string              `json:"prompt_id"`
	PromptVersion   *string             `json:"prompt_version,omitempty"`
	SelectedProfile string              `json:"selected_profile"`
	Model           string              `json:"model"`
	MessageCount    int                 `json:"message_count"`
	ProfileTimeout  int                 `json:"profile_timeout_seconds"`
	Namespaces      []string            `json:"namespaces"`
	Collections     []collectionSummary `json:"collections"`
	ScopedPrompts   []string            `json:"scoped_prompts"`
	ReviewPrompts   []string            `json:"review_prompts"`
}

type collectionSummary struct {
	Namespace      string  `json:"namespace"`
	ReleaseVersion *string `json:"release_version"`
}

func main() {
	support, err := promptkit.CollectionInput(
		"support",
		configkit.File("examples/go-library/prepare/collections/support/collection.yaml"),
	)
	if err != nil {
		exit(err)
	}
	review, err := promptkit.CollectionInput(
		"review",
		configkit.File("examples/go-library/prepare/collections/review/collection.yaml"),
	)
	if err != nil {
		exit(err)
	}
	override, err := promptkit.CollectionInput(
		"support",
		configkit.File("examples/go-library/prepare/collections/support/operator-overrides.yaml"),
	)
	if err != nil {
		exit(err)
	}
	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
		Underlays: []configkit.Underlay{
			{Inputs: []configkit.Input{support, review}},
			{Inputs: []configkit.Input{override}},
		},
	}})
	if err != nil {
		exit(err)
	}
	ctx := context.Background()
	scoped, err := engine.WithNamespaces(promptkit.Namespaces{
		Prompt: "support", Profile: "support", Backend: "support",
	})
	if err != nil {
		exit(err)
	}
	view, err := engine.InspectConfiguration()
	if err != nil {
		exit(err)
	}
	if _, found := view.Explain(configkit.Keys(
		"collections", "support", "profiles", "fast", "timeout_seconds",
	)); !found {
		exit(fmt.Errorf("collection profile override was not found"))
	}
	requirements, err := scoped.InspectRequirements(ctx, promptkit.RequirementInspectionRequest{
		PromptID: "prepare",
	})
	if err != nil {
		exit(err)
	}
	if !requirements.Complete || len(requirements.Inputs) != 1 ||
		requirements.Inputs[0].Name != "note" ||
		requirements.Inputs[0].Kind != promptkit.RequirementRequired {
		exit(fmt.Errorf("required note input was not discovered before preparation"))
	}

	request := promptkit.RunRequest{
		PromptID:  "prepare",
		ProfileID: "fast",
		Inputs: map[string]promptkit.ArtifactRef{
			"note": promptkit.Inline("Ada finished the migration review."),
		},
	}
	if err := scoped.ValidateRequest(ctx, request); err != nil {
		exit(err)
	}
	prepared, err := scoped.Prepare(ctx, request)
	if err != nil {
		exit(err)
	}
	profile, err := scoped.InspectProfile(ctx, "fast")
	if err != nil {
		exit(err)
	}
	if profile.EffectiveModelParams.TimeoutSeconds != 30 {
		exit(fmt.Errorf(
			"later profile override was not applied: timeout is %d seconds",
			profile.EffectiveModelParams.TimeoutSeconds,
		))
	}
	namespaces, err := scoped.ListNamespaces(ctx)
	if err != nil {
		exit(err)
	}
	collections, err := scoped.ListCollections(ctx)
	if err != nil {
		exit(err)
	}
	scopedPrompts, err := scoped.ListPrompts(ctx)
	if err != nil {
		exit(err)
	}
	reviewPrompts, err := scoped.ListPrompts(ctx, promptkit.NamespaceFilter{
		Mode: promptkit.NamespaceNamed, Name: "review",
	})
	if err != nil {
		exit(err)
	}
	scopedPromptIDs := make([]string, len(scopedPrompts))
	for index := range scopedPrompts {
		scopedPromptIDs[index] = scopedPrompts[index].ID
	}
	reviewPromptIDs := make([]string, len(reviewPrompts))
	for index := range reviewPrompts {
		reviewPromptIDs[index] = reviewPrompts[index].ID
	}
	collectionSummaries := make([]collectionSummary, len(collections))
	for index := range collections {
		collectionSummaries[index] = collectionSummary{
			Namespace: collections[index].Namespace, ReleaseVersion: collections[index].ReleaseVersion,
		}
	}

	encoder := json.NewEncoder(os.Stdout)
	encoder.SetIndent("", "  ")
	if err := encoder.Encode(summary{
		PromptID:        prepared.PromptID,
		PromptVersion:   prepared.PromptVersion,
		SelectedProfile: prepared.SelectedProfileID,
		Model:           prepared.EffectiveModelParams.Model,
		MessageCount:    len(prepared.Messages),
		ProfileTimeout:  profile.EffectiveModelParams.TimeoutSeconds,
		Namespaces:      namespaces,
		Collections:     collectionSummaries,
		ScopedPrompts:   scopedPromptIDs,
		ReviewPrompts:   reviewPromptIDs,
	}); err != nil {
		exit(err)
	}
}

func exit(err error) {
	fmt.Fprintln(os.Stderr, err)
	os.Exit(1)
}