package main

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

	"github.com/grafana/tanka/pkg/kubernetes"
	"github.com/grafana/tanka/pkg/process"
	"github.com/grafana/tanka/pkg/spec/v1alpha1"
)

func main() {
	specPath := flag.String("spec", "", "Path to spec.json")
	mainPath := flag.String("main", "", "Path to main.json")
	action := flag.String("action", "show", "Action to perform: show, diff, apply")
	flag.Parse()

	if *specPath == "" || *mainPath == "" {
		fmt.Fprintln(os.Stderr, "Usage: tanka --spec <spec.json> --main <main.json> [--action <action>]")
		os.Exit(1)
	}

	// 1. Load Spec
	specData, err := os.ReadFile(*specPath)
	if err != nil {
		panic(fmt.Errorf("reading spec: %w", err))
	}

	var env v1alpha1.Environment
	if err := json.Unmarshal(specData, &env); err != nil {
		panic(fmt.Errorf("unmarshaling spec: %w", err))
	}

	// 2. Load Main (Data)
	mainData, err := os.ReadFile(*mainPath)
	if err != nil {
		panic(fmt.Errorf("reading main: %w", err))
	}

	var rawData interface{}
	if err := json.Unmarshal(mainData, &rawData); err != nil {
		panic(fmt.Errorf("unmarshaling main: %w", err))
	}
	env.Data = rawData

	// 3. Process (Extract, Label, Filter)
	// We use empty matchers for now
	list, err := process.Process(env, process.Matchers{})
	if err != nil {
		panic(fmt.Errorf("processing manifests: %w", err))
	}

	fmt.Printf("Processed %d manifests for env %s (namespace: %s)\n", len(list), env.Metadata.Name, env.Spec.Namespace)

	if *action == "show" {
		for _, m := range list {
			fmt.Printf("- %s: %s\n", m.Kind(), m.Metadata().Name())
		}
		return
	}

	// 4. Initialize Kubernetes Client
	// This will fail if no valid kubeconfig/context is found matching spec.json
	kube, err := kubernetes.New(env)
	if err != nil {
		fmt.Printf("Warning: Failed to initialize Kubernetes client (expected if no cluster context): %v\n", err)
		return
	}
	defer kube.Close()

	// 5. Perform Action
	switch *action {
	case "diff":
		fmt.Println("Running Diff...")
		diff, err := kube.Diff(context.Background(), list, kubernetes.DiffOpts{})
		if err != nil {
			panic(err)
		}
		if diff != nil {
			fmt.Println(*diff)
		} else {
			fmt.Println("No changes.")
		}
	case "apply":
		fmt.Println("Running Apply...")
		err := kube.Apply(list, kubernetes.ApplyOpts{})
		if err != nil {
			panic(err)
		}
		fmt.Println("Apply finished.")
	default:
		fmt.Printf("Unknown action: %s\n", *action)
	}
}