main.go

// Command fakebambu emulates a Bambu Lab 3D printer running in LAN-only
// Developer Mode: it exposes the same MQTT (report/command), FTPS (file
// upload) and SSDP-style discovery surface a real printer does, so it can
// be added to Bambu Studio / Bambu Handy / Bambuddy via IP + serial +
// access code, and will report plausible online status, temperatures, AMS
// state, and print progress while safely no-opping every command it
// receives.
package main

import (
	"context"
	"flag"
	"fmt"
	"log/slog"
	"net"
	"os"
	"os/signal"
	"path/filepath"
	"strings"
	"syscall"
	"time"

	"fakebambu/internal/autoplay"
	"fakebambu/internal/certs"
	"fakebambu/internal/discovery"
	"fakebambu/internal/ftps"
	"fakebambu/internal/identity"
	fbmqtt "fakebambu/internal/mqtt"
	"fakebambu/internal/preview"
	"fakebambu/internal/profile"
	"fakebambu/internal/queue"
	"fakebambu/internal/state"
)

func main() {
	var (
		modelFlag        = flag.String("model", "", "printer model to emulate: "+strings.Join(profile.Keys(), ", ")+" (required)")
		serialFlag       = flag.String("serial", "", "serial number to use (default: randomly generated)")
		accessCodeFlag   = flag.String("access-code", "", "LAN access code to use (default: randomly generated)")
		nameFlag         = flag.String("name", "", "device name advertised to clients (default: fakebambu-<model>)")
		mqttPort         = flag.Int("mqtt-port", 8883, "port for the MQTT (MQTTS) broker")
		ftpPort          = flag.Int("ftp-port", 990, "port for the FTPS file-upload server")
		discoveryPort    = flag.Int("discovery-port", 2021, "UDP port for SSDP-style LAN discovery")
		noDiscovery      = flag.Bool("no-discovery", false, "disable the LAN discovery broadcaster/responder")
		dataDir          = flag.String("data-dir", "./data", "directory to store uploaded print files")
		logLevel         = flag.String("log-level", "info", "log level: debug, info, warn, error")
		printQueueFlag   = flag.String("print-queue", "", "path to a YAML/JSON playlist of prints to emulate on a loop (optional)")
		previewPort      = flag.Int("preview-port", 8990, "port for the HTTP poster/thumbnail preview server")
		ifaceFlag        = flag.String("interface", "0.0.0.0", "network interface name (e.g. eth1) or IP address to bind all listeners to; 0.0.0.0 binds every interface")
		passivePortStart = flag.Int("ftp-passive-port-start", 50100, "first port of the 100-port FTP passive-data range; give each concurrent instance a distinct value")
	)
	flag.Parse()

	logger := newLogger(*logLevel)
	slog.SetDefault(logger)

	if *modelFlag == "" {
		fmt.Fprintln(os.Stderr, "error: -model is required")
		flag.Usage()
		os.Exit(2)
	}

	prof, err := profile.Get(strings.ToLower(*modelFlag))
	if err != nil {
		fmt.Fprintln(os.Stderr, "error:", err)
		os.Exit(2)
	}

	var printQueue *queue.Queue
	if *printQueueFlag != "" {
		printQueue, err = queue.Load(*printQueueFlag)
		if err != nil {
			fmt.Fprintln(os.Stderr, "error loading print queue:", err)
			os.Exit(2)
		}
	}

	serial := *serialFlag
	generatedSerial := serial == ""
	if generatedSerial {
		serial = identity.GenerateSerial(prof.SerialPrefix)
	}

	accessCode := *accessCodeFlag
	generatedCode := accessCode == ""
	if generatedCode {
		accessCode = identity.GenerateAccessCode()
	}

	deviceName := *nameFlag
	if deviceName == "" {
		deviceName = "fakebambu-" + prof.Key
	}

	bindIP, bindIface, err := resolveBindIP(*ifaceFlag)
	if err != nil {
		fmt.Fprintln(os.Stderr, "error:", err)
		os.Exit(2)
	}

	var ips []net.IP
	if bindIP.Equal(net.IPv4zero) {
		ips = localIPv4s()
	} else {
		ips = []net.IP{bindIP}
	}

	cert, err := certs.Generate(deviceName, ips)
	if err != nil {
		logger.Error("failed to generate TLS certificate", "error", err)
		os.Exit(1)
	}
	tlsConfig := certs.ServerTLSConfig(cert)

	st := state.New(prof, serial)

	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	printBanner(prof, serial, deviceName, accessCode, generatedSerial, generatedCode, bindIP, ips, *mqttPort, *ftpPort, *discoveryPort, *previewPort, *noDiscovery, printQueue)

	broker, err := fbmqtt.Start(fbmqtt.Config{
		BindAddr:   fmt.Sprintf("%s:%d", bindIP, *mqttPort),
		Serial:     serial,
		AccessCode: accessCode,
		TLSConfig:  tlsConfig,
		Profile:    prof,
		State:      st,
		Logger:     logger.With("service", "mqtt"),
	})
	if err != nil {
		logger.Error("failed to start MQTT broker", "error", err)
		os.Exit(1)
	}
	defer broker.Close()

	uploadDir := filepath.Join(*dataDir, "uploads")
	ftpServer, err := ftps.Start(ftps.Config{
		BindAddr:         fmt.Sprintf("%s:%d", bindIP, *ftpPort),
		AccessCode:       accessCode,
		TLSCert:          cert,
		UploadDir:        uploadDir,
		PassivePortStart: *passivePortStart,
		Logger:           logger.With("service", "ftps"),
	})
	if err != nil {
		logger.Error("failed to start FTPS server", "error", err)
		os.Exit(1)
	}
	defer ftpServer.Close()

	var announcer *discovery.Announcer
	if !*noDiscovery {
		advertiseIP := ""
		if len(ips) > 0 {
			advertiseIP = ips[0].String()
		}
		announcer, err = discovery.Start(discovery.Config{
			Serial:     serial,
			AccessCode: accessCode,
			DeviceIP:   advertiseIP,
			Profile:    prof,
			Port:       *discoveryPort,
			BindIP:     bindIP,
			Iface:      bindIface,
			Logger:     logger.With("service", "discovery"),
		})
		if err != nil {
			logger.Warn("failed to start discovery service (continuing without it)", "error", err)
		} else {
			defer announcer.Close()
		}
	}

	previewServer, err := preview.Start(fmt.Sprintf("%s:%d", bindIP, *previewPort), st, logger.With("service", "preview"))
	if err != nil {
		logger.Error("failed to start preview server", "error", err)
		os.Exit(1)
	}
	defer previewServer.Close()

	if printQueue != nil {
		go autoplay.Run(ctx, st, printQueue, uploadDir, logger.With("service", "autoplay"))
	}

	<-ctx.Done()
	logger.Info("shutting down")
}

func newLogger(level string) *slog.Logger {
	var lvl slog.Level
	switch strings.ToLower(level) {
	case "debug":
		lvl = slog.LevelDebug
	case "warn":
		lvl = slog.LevelWarn
	case "error":
		lvl = slog.LevelError
	default:
		lvl = slog.LevelInfo
	}
	return slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: lvl}))
}

// resolveBindIP interprets the -interface flag. An empty value or "0.0.0.0"
// means bind every interface: it returns the IPv4 wildcard address and a
// nil *net.Interface. Otherwise the value is accepted as either a literal
// IPv4 address or an interface name (e.g. "eth1"), resolved to that
// interface's own address -- returning both the IP (for building listener
// addresses) and the *net.Interface (needed by the discovery service to
// join its multicast group on that NIC only). Binding a specific interface
// this way is what lets multiple fakebambu instances run side by side on
// one host without their listeners colliding.
func resolveBindIP(value string) (net.IP, *net.Interface, error) {
	if value == "" || value == "0.0.0.0" {
		return net.IPv4zero, nil, nil
	}

	if ip := net.ParseIP(value); ip != nil {
		ip4 := ip.To4()
		if ip4 == nil {
			return nil, nil, fmt.Errorf("-interface %q is not an IPv4 address", value)
		}
		// Best-effort: if we can't find which local interface owns this
		// address, still bind to it -- just without a specific interface
		// for the discovery service's multicast group membership.
		iface, _ := interfaceForIP(ip4)
		return ip4, iface, nil
	}

	iface, err := net.InterfaceByName(value)
	if err != nil {
		return nil, nil, fmt.Errorf("-interface %q is not a valid IP address or interface name: %w", value, err)
	}
	ip, err := firstIPv4(iface)
	if err != nil {
		return nil, nil, fmt.Errorf("interface %q has no IPv4 address: %w", value, err)
	}
	return ip, iface, nil
}

// interfaceForIP returns the local interface that owns ip, if any.
func interfaceForIP(ip net.IP) (*net.Interface, error) {
	ifaces, err := net.Interfaces()
	if err != nil {
		return nil, err
	}
	for i := range ifaces {
		addrs, err := ifaces[i].Addrs()
		if err != nil {
			continue
		}
		for _, addr := range addrs {
			if ipnet, ok := addr.(*net.IPNet); ok && ipnet.IP.Equal(ip) {
				return &ifaces[i], nil
			}
		}
	}
	return nil, fmt.Errorf("no local interface has address %s", ip)
}

// firstIPv4 returns the first IPv4 address assigned to iface.
func firstIPv4(iface *net.Interface) (net.IP, error) {
	addrs, err := iface.Addrs()
	if err != nil {
		return nil, err
	}
	for _, addr := range addrs {
		var ip net.IP
		switch v := addr.(type) {
		case *net.IPNet:
			ip = v.IP
		case *net.IPAddr:
			ip = v.IP
		}
		if ip4 := ip.To4(); ip4 != nil {
			return ip4, nil
		}
	}
	return nil, fmt.Errorf("no IPv4 address found on interface %s", iface.Name)
}

// localIPv4s returns the non-loopback IPv4 addresses of this host, so the
// operator knows which IP to enter in Bambu Studio / Bambu Handy.
func localIPv4s() []net.IP {
	var out []net.IP
	ifaces, err := net.Interfaces()
	if err != nil {
		return out
	}
	for _, iface := range ifaces {
		if iface.Flags&net.FlagUp == 0 || iface.Flags&net.FlagLoopback != 0 {
			continue
		}
		addrs, err := iface.Addrs()
		if err != nil {
			continue
		}
		for _, addr := range addrs {
			var ip net.IP
			switch v := addr.(type) {
			case *net.IPNet:
				ip = v.IP
			case *net.IPAddr:
				ip = v.IP
			}
			if ip == nil || ip.To4() == nil {
				continue
			}
			out = append(out, ip)
		}
	}
	return out
}

func printBanner(prof profile.Profile, serial, deviceName, accessCode string, generatedSerial, generatedCode bool, bindIP net.IP, ips []net.IP, mqttPort, ftpPort, discoveryPort, previewPort int, discoveryDisabled bool, printQueue *queue.Queue) {
	fmt.Println("==============================================================")
	fmt.Println(" fakebambu - Bambu Lab printer emulator")
	fmt.Println("==============================================================")
	fmt.Printf(" Model:          %s (%s)\n", prof.Name, prof.Key)
	fmt.Printf(" Device name:    %s\n", deviceName)
	fmt.Printf(" Serial number:  %s%s\n", serial, ifStr(generatedSerial, "  (generated)"))
	fmt.Printf(" Access code:    %s%s\n", accessCode, ifStr(generatedCode, "  (generated)"))
	fmt.Println("--------------------------------------------------------------")
	if bindIP.Equal(net.IPv4zero) {
		if len(ips) == 0 {
			fmt.Println(" Listening on all interfaces (0.0.0.0) - no IPv4 address detected")
		} else {
			fmt.Println(" Listening on all interfaces (0.0.0.0); reachable at:")
			for _, ip := range ips {
				fmt.Printf("   - %s\n", ip.String())
			}
		}
	} else {
		fmt.Printf(" Listening on interface:  %s\n", bindIP)
	}
	fmt.Printf(" MQTT(S):        port %d  (user \"bblp\", password = access code)\n", mqttPort)
	fmt.Printf(" FTPS:           port %d  (implicit TLS, same credentials)\n", ftpPort)
	if discoveryDisabled {
		fmt.Println(" Discovery:      disabled")
	} else {
		fmt.Printf(" Discovery:      UDP port %d (SSDP-style, best-effort)\n", discoveryPort)
	}
	fmt.Printf(" Preview:        http://<ip>:%d/thumbnail  (poster of the active print)\n", previewPort)
	if printQueue != nil {
		fmt.Println("--------------------------------------------------------------")
		fmt.Printf(" Print queue:    %d job(s), looping forever\n", len(printQueue.Prints))
		for i, j := range printQueue.Prints {
			fmt.Printf("   %d. %-24s  %-10s  %d layers\n", i+1, j.Name, time.Duration(j.Duration), j.Layers)
		}
	}
	fmt.Println("==============================================================")
	fmt.Println(" In Bambu Studio: Add printer -> enter IP, serial and access code above.")
	fmt.Println(" Press Ctrl+C to stop.")
	fmt.Println("==============================================================")
}

func ifStr(cond bool, s string) string {
	if cond {
		return s
	}
	return ""
}