package main

import (
	"fmt"
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promauto"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
)

var (
	grainSpawns = promauto.NewCounter(prometheus.CounterOpts{
		Name: "cart_grain_spawned_total",
		Help: "The total number of spawned grains",
	})
	grainMutations = promauto.NewCounter(prometheus.CounterOpts{
		Name: "cart_grain_mutations_total",
		Help: "The total number of mutations",
	})
	grainLookups = promauto.NewCounter(prometheus.CounterOpts{
		Name: "cart_grain_lookups_total",
		Help: "The total number of lookups",
	})
)

func spawn(id CartId) (*CartGrain, error) {
	grainSpawns.Inc()
	ret := &CartGrain{
		lastItemId:     0,
		lastDeliveryId: 0,
		Deliveries:     []*CartDelivery{},
		Id:             id,
		Items:          []*CartItem{},
		// storageMessages removed (legacy event log deprecated)
		TotalPrice: 0,
	}
	err := loadMessages(ret, id)
	return ret, err
}

func init() {
	os.Mkdir("data", 0755)
}

type App struct {
	pool    *GrainLocalPool
	storage *DiskStorage
}

func (a *App) Save() error {
	hasChanges := false
	a.pool.mu.RLock()
	defer a.pool.mu.RUnlock()
	for id, grain := range a.pool.GetGrains() {
		if grain == nil {
			continue
		}
		if grain.GetLastChange() > a.storage.LastSaves[id] {
			hasChanges = true
			err := a.storage.Store(id, grain)
			if err != nil {
				log.Printf("Error saving grain %s: %v\n", id, err)
			}
		}
	}

	if !hasChanges {
		return nil
	}
	return a.storage.saveState()
}



var podIp = os.Getenv("POD_IP")
var name = os.Getenv("POD_NAME")
var amqpUrl = os.Getenv("AMQP_URL")
var KlarnaInstance = NewKlarnaClient(KlarnaPlaygroundUrl, os.Getenv("KLARNA_API_USERNAME"), os.Getenv("KLARNA_API_PASSWORD"))

func GetDiscovery() Discovery {
	if podIp == "" {
		return nil
	}

	config, kerr := rest.InClusterConfig()

	if kerr != nil {
		log.Fatalf("Error creating kubernetes client: %v\n", kerr)
	}
	client, err := kubernetes.NewForConfig(config)
	if err != nil {
		log.Fatalf("Error creating client: %v\n", err)
	}
	return NewK8sDiscovery(client)
}



func main() {

	storage, err := NewDiskStorage(fmt.Sprintf("data/%s_state.gob", name))
	if err != nil {
		log.Printf("Error loading state: %v\n", err)
	}
	app := &App{
		pool:    NewGrainLocalPool(65535, 5*time.Minute, spawn),
		storage: storage,
	}

	syncedPool, err := NewSyncedPool(app.pool, podIp, GetDiscovery())
	if err != nil {
		log.Fatalf("Error creating synced pool: %v\n", err)
	}

	// Start unified gRPC server (CartActor + ControlPlane) replacing legacy RPC server on :1337
	// TODO: Remove any remaining legacy RPC server references and deprecated frame-based code after full gRPC migration is validated.
	grpcSrv, err := StartGRPCServer(":1337", app.pool, syncedPool)
	if err != nil {
		log.Fatalf("Error starting gRPC server: %v\n", err)
	}
	defer grpcSrv.GracefulStop()

	go func() {
		for range time.Tick(time.Minute * 10) {
			err := app.Save()
			if err != nil {
				log.Printf("Error saving: %v\n", err)
			}
		}
	}()


	sigs := make(chan os.Signal, 1)
	done := make(chan bool, 1)
	signal.Notify(sigs, syscall.SIGTERM)

	go func() {
		sig := <-sigs
		fmt.Println("Shutting down due to signal:", sig)
		go syncedPool.Close()
		app.Save()
		done <- true
	}()

	log.Print("Server started at port 1337")
	<-done

}