package main

import (
	"bufio"
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"strconv"
	"strings"
	"syscall"
	"time"

	"neuralhunt/internal/customer"
	"neuralhunt/internal/customerui"
)

func loadDotEnv(path string) {
	f, err := os.Open(path)
	if err != nil {
		return
	}
	defer f.Close()
	s := bufio.NewScanner(f)
	for s.Scan() {
		line := strings.TrimSpace(s.Text())
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}
		if strings.HasPrefix(line, "export ") {
			line = strings.TrimSpace(strings.TrimPrefix(line, "export "))
		}
		k, v, ok := strings.Cut(line, "=")
		if !ok {
			continue
		}
		k, v = strings.TrimSpace(k), strings.TrimSpace(v)
		if k == "" {
			continue
		}
		if _, exists := os.LookupEnv(k); exists {
			continue
		}
		if len(v) >= 2 && ((v[0] == '"' && v[len(v)-1] == '"') || (v[0] == '\'' && v[len(v)-1] == '\'')) {
			v = v[1 : len(v)-1]
		}
		_ = os.Setenv(k, v)
	}
}
func env(k, d string) string {
	if v := strings.TrimSpace(os.Getenv(k)); v != "" {
		return v
	}
	return d
}
func boolEnv(k string, d bool) bool {
	v := strings.ToLower(strings.TrimSpace(os.Getenv(k)))
	if v == "" {
		return d
	}
	return v == "1" || v == "true" || v == "yes" || v == "on"
}
func intEnv(k string, d int) int {
	v, err := strconv.Atoi(strings.TrimSpace(os.Getenv(k)))
	if err != nil {
		return d
	}
	return v
}
func floatEnv(k string, d float64) float64 {
	v, err := strconv.ParseFloat(strings.TrimSpace(os.Getenv(k)), 64)
	if err != nil {
		return d
	}
	return v
}
func durationEnv(k string, d time.Duration) time.Duration {
	v := strings.TrimSpace(os.Getenv(k))
	if v == "" {
		return d
	}
	if x, err := time.ParseDuration(v); err == nil {
		return x
	}
	return d
}

// CS_CREDIT_PACKAGES format: id:amount_cents:CURRENCY:credits;...
// Example: starter:499:EUR:60;plus:1999:EUR:300
func packagesFromEnv() ([]customer.CreditPackage, error) {
	raw := env("CS_CREDIT_PACKAGES", "starter:499:EUR:60;plus:1999:EUR:300;power:4999:EUR:900")
	var out []customer.CreditPackage
	for _, part := range strings.Split(raw, ";") {
		part = strings.TrimSpace(part)
		if part == "" {
			continue
		}
		f := strings.Split(part, ":")
		if len(f) != 4 {
			return nil, fmt.Errorf("invalid CS_CREDIT_PACKAGES entry %q", part)
		}
		cents, err := strconv.ParseInt(f[1], 10, 64)
		if err != nil || cents <= 0 {
			return nil, fmt.Errorf("invalid package cents %q", f[1])
		}
		credits, err := strconv.ParseFloat(f[3], 64)
		if err != nil || credits <= 0 {
			return nil, fmt.Errorf("invalid package credits %q", f[3])
		}
		out = append(out, customer.CreditPackage{ID: strings.TrimSpace(f[0]), AmountCents: cents, Currency: strings.ToUpper(strings.TrimSpace(f[2])), CreditsMicros: int64(credits*1_000_000 + 0.5)})
	}
	if len(out) == 0 {
		return nil, fmt.Errorf("no credit packages configured")
	}
	return out, nil
}

func validate(cfg customer.Config) error {
	shared := strings.TrimSpace(cfg.SharedSecret)
	if len(shared) < 32 || strings.Contains(strings.ToLower(shared), "replace-with") || strings.Contains(strings.ToLower(shared), "change-me") {
		return fmt.Errorf("CUSTOMER_SERVICE_SHARED_SECRET must be a unique random value of at least 32 characters; example placeholders are rejected")
	}
	adminPass := strings.TrimSpace(cfg.AdminPassword)
	if len(adminPass) < 16 || strings.Contains(strings.ToLower(adminPass), "replace-with") || strings.Contains(strings.ToLower(adminPass), "change-me") {
		return fmt.Errorf("CS_ADMIN_PASSWORD must be a unique value of at least 16 characters; example placeholders are rejected")
	}
	if cfg.PublicBaseURL == "" {
		return fmt.Errorf("CS_PUBLIC_BASE_URL is required (the HTTPS customer portal URL)")
	}
	if cfg.WorkerImage == "" {
		return fmt.Errorf("CS_WORKER_IMAGE is required")
	}
	if _, err := customer.RegistryAuthHeader(cfg.WorkerRegistryUsername, cfg.WorkerRegistryPassword, cfg.WorkerRegistryServer); err != nil {
		return fmt.Errorf("worker registry auth: %w", err)
	}
	if cfg.PayPalEnabled && strings.EqualFold(cfg.PayPalEnvironment, "live") && cfg.PayPalLiveApprovalAck != "I_HAVE_PAYPAL_APPROVAL" {
		log.Printf("WARNING: PayPal live remains disabled until PAYPAL_LIVE_APPROVAL_ACK=I_HAVE_PAYPAL_APPROVAL is set after provider/legal approval")
	}
	return nil
}

func main() {
	loadDotEnv(".env")
	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer cancel()
	pkgs, err := packagesFromEnv()
	if err != nil {
		log.Fatal(err)
	}
	rate := floatEnv("CS_WORKER_CREDITS_PER_MINUTE", 1.0)
	if rate <= 0 {
		log.Fatal("CS_WORKER_CREDITS_PER_MINUTE must be > 0")
	}
	cfg := customer.Config{
		PublicAddr: env("CS_HTTP_ADDR", ":8090"), AdminAddr: env("CS_ADMIN_HTTP_ADDR", ":8091"), InternalAddr: env("CS_INTERNAL_ADDR", ":8092"),
		PublicBaseURL: strings.TrimRight(env("CS_PUBLIC_BASE_URL", ""), "/"), GamePublicURL: env("CS_GAME_PUBLIC_URL", "http://app:8080"), GameAdminURL: env("CS_GAME_ADMIN_URL", "http://app:8081"), SharedSecret: env("CUSTOMER_SERVICE_SHARED_SECRET", ""),
		DockerHost: env("DOCKER_HOST", "unix:///var/run/docker.sock"), WorkerImage: env("CS_WORKER_IMAGE", "neuralhunt-worker:local"), WorkerEntrypoint: env("CS_WORKER_ENTRYPOINT", ""), WorkerNetwork: env("CS_WORKER_NETWORK", "neuralhunt_backend"), WorkerRegisterURL: env("CS_WORKER_REGISTER_URL", "http://customer-service:8092/internal/workers/register"), WorkerAutoPull: boolEnv("CS_WORKER_AUTO_PULL", true), WorkerRegistryUsername: env("CS_WORKER_REGISTRY_USERNAME", ""), WorkerRegistryPassword: env("CS_WORKER_REGISTRY_PASSWORD", ""), WorkerRegistryServer: env("CS_WORKER_REGISTRY_SERVER", ""), WorkerRateMicrosPerMinute: int64(rate*1_000_000 + 0.5), MaxWorkersPerCustomer: intEnv("CS_MAX_WORKERS_PER_CUSTOMER", 20), MaxWorkersGlobal: intEnv("CS_MAX_WORKERS_GLOBAL", 1000), MaxRunningPerCustomer: intEnv("CS_MAX_RUNNING_WORKERS_PER_CUSTOMER", 10), MaxRunningGlobal: intEnv("CS_MAX_RUNNING_WORKERS_GLOBAL", 100),
		SessionTTL: durationEnv("CS_SESSION_TTL", 24*time.Hour), CookieSecure: boolEnv("CS_COOKIE_SECURE", true), AdminUser: env("CS_ADMIN_USER", "admin"), AdminPassword: env("CS_ADMIN_PASSWORD", ""), AllowManualCredits: boolEnv("CS_ALLOW_MANUAL_CREDITS", false),
		PayPalEnabled: boolEnv("PAYPAL_ENABLED", false), PayPalEnvironment: env("PAYPAL_ENVIRONMENT", "sandbox"), PayPalWebhookID: env("PAYPAL_WEBHOOK_ID", ""), PayPalLiveApprovalAck: env("PAYPAL_LIVE_APPROVAL_ACK", ""), Packages: pkgs,
	}
	if err := validate(cfg); err != nil {
		log.Fatal(err)
	}
	st, err := customer.Open(ctx, env("CUSTOMER_SQLITE_PATH", "/customer-data/customer-service.db"))
	if err != nil {
		log.Fatal(err)
	}
	defer st.DB.Close()
	if err := st.RecoverStartingWorkers(ctx); err != nil {
		log.Fatal(err)
	}
	dc, err := customer.NewDockerClient(cfg.DockerHost)
	if err != nil {
		log.Fatal(err)
	}
	if err := dc.Ping(ctx); err != nil {
		log.Fatalf("Docker Engine API unavailable: %v", err)
	}
	pp := customer.NewPayPalClient(env("PAYPAL_CLIENT_ID", ""), env("PAYPAL_CLIENT_SECRET", ""), cfg.PayPalEnvironment)
	svc := customer.NewService(st, dc, pp, cfg)
	go svc.RunBilling(ctx)
	servers := []*http.Server{
		{Addr: cfg.PublicAddr, Handler: svc.PublicRoutes(customerui.Public()), ReadHeaderTimeout: 5 * time.Second, IdleTimeout: 60 * time.Second},
		{Addr: cfg.AdminAddr, Handler: svc.AdminRoutes(customerui.Admin()), ReadHeaderTimeout: 5 * time.Second, IdleTimeout: 60 * time.Second},
		{Addr: cfg.InternalAddr, Handler: svc.InternalRoutes(), ReadHeaderTimeout: 5 * time.Second, IdleTimeout: 30 * time.Second},
	}
	names := []string{"customer public", "customer admin/private", "customer worker/internal"}
	for i, s := range servers {
		go func(n string, hs *http.Server) {
			log.Printf("%s listener on %s", n, hs.Addr)
			if err := hs.ListenAndServe(); err != nil && err != http.ErrServerClosed {
				log.Fatal(err)
			}
		}(names[i], s)
	}
	<-ctx.Done()
	shutdown, done := context.WithTimeout(context.Background(), 10*time.Second)
	defer done()
	for _, s := range servers {
		_ = s.Shutdown(shutdown)
	}
}