package commands

import (
	"cmp"
	"errors"
	"flag"
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	"congo.gg/cmd/internal"
	"congo.gg/pkg/platform"
)

const launchUsage = `Provision and deploy infrastructure described in infra.json

Usage:
  congo launch [flags]

Flags:
  --server <name>    Deploy to a specific server instance
  --new <name>       Provision a new server and deploy
  --skip-build       Skip Docker build, deploy existing image
  --dry-run          Validate config and show what would happen

Environment variables in infra.json are expanded: "$MY_TOKEN" reads from env.

Examples:
  congo launch                    # deploy to all instances
  congo launch --new web          # provision + deploy a new "web" server
  congo launch --server web-1     # deploy to specific instance
  congo launch --dry-run          # validate without deploying
`

func Launch() {
	fs := flag.NewFlagSet("launch", flag.ExitOnError)
	fs.Usage = func() { fmt.Print(launchUsage) }

	serverName := fs.String("server", "", "Deploy to specific server instance")
	newServer := fs.String("new", "", "Provision a new server")
	skipBuild := fs.Bool("skip-build", false, "Skip Docker build")
	dryRun := fs.Bool("dry-run", false, "Validate and show plan")

	fs.Parse(os.Args[2:])

	cfg, err := scaffold.LoadInfraConfig(".")
	if err != nil {
		log.Fatalf("load infra.json: %v", err)
	}

	if *dryRun {
		printDryRun(cfg, *newServer, *serverName)
		return
	}

	providers, err := scaffold.InitProviders(cfg)
	if err != nil {
		log.Fatal(err)
	}

	start := time.Now()

	switch {
	case *newServer != "":
		provisionAndDeploy(providers, cfg, *newServer, *skipBuild)
	case *serverName != "":
		deployToNamed(providers, cfg, *serverName, *skipBuild)
	default:
		deployAll(providers, cfg, *skipBuild)
	}

	printDeploySummary(cfg, start)
}

// provisionAndDeploy creates a new server instance and deploys services to it.
func provisionAndDeploy(providers map[string]*platform.Platform, cfg *scaffold.InfraConfig, name string, skipBuild bool) {
	spec, ok := cfg.Servers[name]
	if !ok {
		var types []string
		for t := range cfg.Servers {
			types = append(types, t)
		}
		log.Fatalf("server type %q not found in infra.json\nAvailable types: %s", name, strings.Join(types, ", "))
	}

	p := scaffold.ProviderFor(providers, cfg, name)
	pc := cfg.PlatformFor(name)
	region := cmp.Or(pc.Region, "sfo")

	instanceNum := len(cfg.Instances[name]) + 1
	instanceName := fmt.Sprintf("%s-%d", name, instanceNum)

	inst, err := scaffold.CreateInstance(p, instanceName, spec, region)
	if err != nil {
		if errors.Is(err, platform.ErrUnsupported) {
			log.Fatalf("metal servers are pre-configured — add instances to infra.json:\n" +
				"  { \"name\": \"pi-1\", \"ip\": \"192.168.1.100\" }")
		}
		log.Fatalf("create server: %v", err)
	}

	cfg.Instances[name] = append(cfg.Instances[name], *inst)
	if err := cfg.Save("."); err != nil {
		log.Fatalf("save infra.json: %v", err)
	}

	imagePaths := buildIfNeeded(spec.Services, cfg.Services, skipBuild)

	if err := scaffold.DeployToInstance(p, imagePaths, cfg, name, inst, platform.Region(region)); err != nil {
		log.Fatalf("deploy: %v", err)
	}

	log.Printf("Created and deployed %s (%s)", inst.Name, inst.IP)
}

// deployToNamed deploys to a specific server instance by name.
func deployToNamed(providers map[string]*platform.Platform, cfg *scaffold.InfraConfig, serverName string, skipBuild bool) {
	inst, serverType, err := scaffold.FindInstance(cfg, serverName)
	if err != nil {
		log.Fatal(err)
	}

	p := scaffold.ProviderFor(providers, cfg, serverType)
	pc := cfg.PlatformFor(serverType)
	region := cmp.Or(pc.Region, "sfo")

	spec := cfg.Servers[serverType]
	imagePaths := buildIfNeeded(spec.Services, cfg.Services, skipBuild)

	if err := scaffold.DeployToInstance(p, imagePaths, cfg, serverType, inst, platform.Region(region)); err != nil {
		log.Fatalf("deploy: %v", err)
	}

	log.Printf("Deployed to %s (%s)", inst.Name, inst.IP)
}

// deployAll deploys to every existing instance.
func deployAll(providers map[string]*platform.Platform, cfg *scaffold.InfraConfig, skipBuild bool) {
	if len(cfg.Instances) == 0 {
		log.Println("No instances deployed. Use 'congo launch --new <server-type>' to create one.")
		return
	}

	for serverType, instances := range cfg.Instances {
		if len(instances) == 0 {
			continue
		}

		p := scaffold.ProviderFor(providers, cfg, serverType)
		pc := cfg.PlatformFor(serverType)
		region := cmp.Or(pc.Region, "sfo")

		spec := cfg.Servers[serverType]
		imagePaths := buildIfNeeded(spec.Services, cfg.Services, skipBuild)

		for i := range instances {
			if instances[i].IP == "" {
				log.Printf("%s has no IP, skipping — configure mesh or add IP to infra.json", instances[i].Name)
				continue
			}
			if err := scaffold.DeployToInstance(p, imagePaths, cfg, serverType, &instances[i], platform.Region(region)); err != nil {
				log.Fatalf("deploy to %s: %v", instances[i].Name, err)
			}
		}
	}

	log.Println("Deployment complete")
}

// buildIfNeeded builds Docker images for source-based services unless skipped.
func buildIfNeeded(serviceNames []string, specs map[string]scaffold.ServiceSpec, skip bool) map[string]string {
	if skip {
		return make(map[string]string)
	}
	images, err := scaffold.BuildSourceImages(serviceNames, specs)
	if err != nil {
		log.Fatal(err)
	}
	return images
}

func printDryRun(cfg *scaffold.InfraConfig, newServer, serverName string) {
	fmt.Println("Dry run — no changes will be made")
	fmt.Println()

	for name, pc := range cfg.Platforms {
		fmt.Printf("Platform %q: %s (region: %s)\n", name, pc.Provider, cmp.Or(pc.Region, "-"))
	}
	fmt.Printf("Server types: %d, Services: %d, Instances: %d\n\n",
		len(cfg.Servers), len(cfg.Services), scaffold.CountInstances(cfg))

	if newServer != "" {
		spec, ok := cfg.Servers[newServer]
		if !ok {
			var types []string
			for t := range cfg.Servers {
				types = append(types, t)
			}
			log.Fatalf("server type %q not found in infra.json\nAvailable types: %s", newServer, strings.Join(types, ", "))
		}
		n := len(cfg.Instances[newServer]) + 1
		pc := cfg.PlatformFor(newServer)
		fmt.Printf("Would provision: %s-%d (size: %s, platform: %s)\n", newServer, n, spec.Size, pc.Provider)
		if spec.Setup != "" {
			fmt.Printf("  Server setup: %s\n", spec.Setup)
		}
		for _, svc := range spec.Services {
			s := cfg.Services[svc]
			source := cmp.Or(s.Source, s.Image)
			fmt.Printf("  Service: %s (from %s)\n", svc, source)
			if s.Setup != "" {
				fmt.Printf("    Setup: %s\n", s.Setup)
			}
			for _, p := range s.Ports {
				fmt.Printf("    Port: %d → %d\n", p.Host, p.Container)
			}
		}
		for _, vol := range spec.Volumes {
			fmt.Printf("  Volume: %s (%d GB → %s)\n", vol.Name, vol.Size, vol.Mount)
		}
		return
	}

	if serverName != "" {
		inst, _, err := scaffold.FindInstance(cfg, serverName)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("Would deploy to: %s (%s)\n", inst.Name, inst.IP)
		return
	}

	if scaffold.CountInstances(cfg) == 0 {
		fmt.Println("No instances deployed. Use --new <server-type> to create one.")
		return
	}

	fmt.Println("Would deploy to all instances:")
	for serverType, instances := range cfg.Instances {
		for _, inst := range instances {
			fmt.Printf("  %s (%s) [type: %s]\n", inst.Name, inst.IP, serverType)
		}
	}
}

func printDeploySummary(cfg *scaffold.InfraConfig, start time.Time) {
	elapsed := time.Since(start).Round(time.Second)
	n := scaffold.CountInstances(cfg)

	fmt.Printf("\nDeployed to %d instance", n)
	if n != 1 {
		fmt.Print("s")
	}
	fmt.Printf(" in %s.\n\n", elapsed)

	for _, instances := range cfg.Instances {
		for _, inst := range instances {
			fmt.Printf("  %s → %s\n", inst.Name, inst.IP)
		}
	}

	fmt.Println("\nNext steps:")
	fmt.Println("  congo status    # check deployment health")
	fmt.Println("  congo logs      # view service logs")
	fmt.Println("  congo connect   # SSH into a server")
}