package main

import (
	"context"
	"log"
	"os"
	"sync"
	"time"

	"github.com/jackman0925/discovery"
)

func main() {
	// Use a standard logger for the example's own output
	stdLogger := log.New(os.Stdout, "[ELECTION-EXAMPLE] ", log.LstdFlags)

	// Create a logger option for the discovery library.
	// For production, you might use LogLevelWarn to reduce noise.
	libLoggerOption := discovery.WithLoggerAndLevel(stdLogger, discovery.LogLevelInfo)

	etcdEndpoints := []string{"localhost:2379"}

	// Create two separate registry instances to simulate two different nodes
	reg1, err := discovery.NewEtcdRegistry(etcdEndpoints, libLoggerOption)
	if err != nil {
		stdLogger.Fatalf("Failed to create registry 1: %v", err)
	}
	defer reg1.Close()

	reg2, err := discovery.NewEtcdRegistry(etcdEndpoints, libLoggerOption)
	if err != nil {
		stdLogger.Fatalf("Failed to create registry 2: %v", err)
	}
	defer reg2.Close()

	var wg sync.WaitGroup
	wg.Add(2)

	// --- Candidate 1 ---
	go func() {
		defer wg.Done()
		election, err := reg1.NewElection(discovery.ElectionOptions{
			ElectionName: "my-critical-task",
			Proposal:     "candidate-1",
		})
		if err != nil {
			stdLogger.Printf("candidate-1: failed to create election: %v", err)
			return
		}

		stdLogger.Println("candidate-1: Campaigning for leadership...")
		// Campaign for leadership. This call blocks until leadership is won or the context is cancelled.
		if err := election.Campaign(context.Background()); err != nil {
			stdLogger.Printf("candidate-1: campaign failed: %v", err)
			return
		}

		stdLogger.Println("candidate-1: I am the leader!")

		// Hold leadership for 10 seconds, then resign.
		time.Sleep(10 * time.Second)

		stdLogger.Println("candidate-1: Resigning from leadership.")
		if err := election.Resign(context.Background()); err != nil {
			stdLogger.Printf("candidate-1: failed to resign: %v", err)
		}
	}()

	// --- Candidate 2 ---
	go func() {
		defer wg.Done()
		// Give candidate 1 a head start
		time.Sleep(1 * time.Second)

		election, err := reg2.NewElection(discovery.ElectionOptions{
			ElectionName: "my-critical-task",
			Proposal:     "candidate-2",
		})
		if err != nil {
			stdLogger.Printf("candidate-2: failed to create election: %v", err)
			return
		}

		stdLogger.Println("candidate-2: Campaigning for leadership...")
		if err := election.Campaign(context.Background()); err != nil {
			stdLogger.Printf("candidate-2: campaign failed: %v", err)
			return
		}

		// This part will only execute after candidate-1 has resigned.
		stdLogger.Println("candidate-2: I am the leader now!")
		time.Sleep(5 * time.Second)
		stdLogger.Println("candidate-2: Resigning from leadership.")
		if err := election.Resign(context.Background()); err != nil {
			stdLogger.Printf("candidate-2: failed to resign: %v", err)
		}
	}()

	wg.Wait()
	stdLogger.Println("Example finished.")
}

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/jackman0925/discovery"
)

func main() {
	// Use the standard logger for this example
	stdLogger := log.New(os.Stdout, "[DISCOVERY-EXAMPLE] ", log.LstdFlags)
	
	// Create a logger option for the discovery library
	// For production environments, you might want to use a lower log level to reduce log volume
	loggerOption := discovery.WithLoggerAndLevel(stdLogger, discovery.LogLevelWarn)

	// Create a new registry instance
	registry, err := discovery.NewEtcdRegistry(
		[]string{"localhost:2379"},      // Etcd server endpoints
		discovery.WithTTL(15),           // Set lease TTL to 15 seconds
		discovery.WithNamespace("prod"), // Set a namespace for services
		loggerOption,                    // Provide the logger option
	)
	if err != nil {
		log.Fatalf("Failed to create etcd registry: %v", err)
	}

	// It's crucial to close the registry to deregister the service and release resources.
	// defer is a great way to ensure this happens on exit.
	defer registry.Close()

	// Define the service to be registered
	serviceInfo := &discovery.ServiceInfo{
		Name:    "my-awesome-api",
		ID:      "instance-01",
		Address: "192.168.1.100",
		Port:    "8080",
		Version: "1.0.2",
	}

	// Register the service.
	// Use a context with a timeout for the registration call to avoid blocking indefinitely.
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err := registry.Register(ctx, serviceInfo); err != nil {
		log.Fatalf("Failed to register service: %v", err)
	}

	fmt.Println("Service registered successfully. It will be kept alive automatically.")

	// Keep the application running to simulate a live service
	// In a real application, this would be your main application logic (e.g., an HTTP server)
	select {
	case <-time.After(60 * time.Second):
		fmt.Println("Shutting down after 60 seconds...")
	}
}

serviceName := "my-awesome-api"

err := registry.WatchService(context.Background(), serviceName, func(services []*discovery.ServiceInfo) {
	// services contains all current instances of my-awesome-api
	fmt.Printf("service %s now has %d instance(s)\n", serviceName, len(services))
})
if err != nil {
	log.Fatalf("watch service failed: %v", err)
}

err := registry.WatchNamespace(context.Background(), func(services []*discovery.ServiceInfo) {
	// services contains all current instances under the configured namespace
	fmt.Printf("namespace now has %d total instance(s)\n", len(services))
})
if err != nil {
	log.Fatalf("watch namespace failed: %v", err)
}

registry, err := discovery.NewEtcdRegistry(
    []string{"localhost:2379"},
    discovery.WithLoggerAndLevel(myLogger, discovery.LogLevelWarn), // Only log warnings and errors
    discovery.WithTTL(15),
    discovery.WithNamespace("prod"),
)

registry, err := discovery.NewEtcdRegistry(
    []string{"localhost:2379"},
    discovery.WithLoggerAndLevel(myLogger, discovery.LogLevelDebug), // Log everything
    discovery.WithTTL(15),
    discovery.WithNamespace("dev"),
)