builderInit.go

package client

import (
	"path/filepath"
	"strings"
	"time"

	"github.com/tinywasm/gobuild"
)

// builderWasmInit configures 3 builders for WASM compilation modes
func (w *WasmClient) builderWasmInit() {
	sourceDir := filepath.Join(w.AppRootDir, w.Config.SourceDir())
	outputDir := filepath.Join(w.AppRootDir, w.Config.OutputDir())
	mainInputFileRelativePath := filepath.Join(sourceDir, w.MainInputFile)

	// Base configuration shared by all builders
	// The baseConfig is no longer used directly for builderSizeLarge, but its fields are replicated.
	// The other builders (Medium, Small) will still use a derived config from this base.
	baseConfig := gobuild.Config{
		AppRootDir:                w.AppRootDir, // CRITICAL: Set working directory for go.mod resolution
		MainInputFileRelativePath: mainInputFileRelativePath,
		OutName:                   w.OutputName, // Output will be {OutputName}.wasm
		Extension:                 ".wasm",
		OutFolderRelativePath:     outputDir,
		Logger:                    nil,
		Timeout:                   60 * time.Second, // 1 minute for all modes
		Callback:                  w.Callback,
	}

	// Configure Coding builder (Go standard)
	codingConfig := baseConfig
	codingConfig.Command = "go"
	codingConfig.Env = []string{"GOOS=js", "GOARCH=wasm"}
	// Append custom env from Config if provided
	if len(w.Config.Env) > 0 {
		codingConfig.Env = append(codingConfig.Env, w.Config.Env...)
	}
	codingConfig.CompilingArguments = func() []string {
		args := []string{"-tags", "dev"}
		if w.CompilingArguments != nil {
			args = append(args, w.CompilingArguments()...)
		}
		args = append(args, "-p", "1")
		return args
	}
	w.builderSizeLarge = gobuild.New(&codingConfig)

	// Configure Debug builder (TinyGo debug-friendly)
	debugConfig := baseConfig
	debugConfig.Command = "tinygo"
	if len(w.Config.Env) > 0 {
		debugConfig.Env = w.Config.Env
	}
	debugConfig.CompilingArguments = func() []string {
		args := []string{"-target", "wasm", "-opt=1"} // Keep debug symbols
		if w.CompilingArguments != nil {
			args = append(args, w.CompilingArguments()...)
		}
		args = append(args, "-p", "1") // Add -p 1
		return args
	}
	w.builderSizeMedium = gobuild.New(&debugConfig)

	// Configure Production builder (TinyGo optimized)
	prodConfig := baseConfig
	prodConfig.Command = "tinygo"
	if len(w.Config.Env) > 0 {
		prodConfig.Env = w.Config.Env
	}
	prodConfig.CompilingArguments = func() []string {
		args := []string{"-target", "wasm", "-opt=z", "-no-debug", "-panic=trap"}
		if w.CompilingArguments != nil {
			args = append(args, w.CompilingArguments()...)
		}
		args = append(args, "-p", "1")
		return args
	}
	w.builderSizeSmall = gobuild.New(&prodConfig)

	// Sync active builder with current mode (don't always reset to Large)
	// This is important when builderWasmInit is called after loadMode() (e.g., from SetAppRootDir)
	switch w.CurrentSizeMode {
	case w.buildMediumSizeShortcut: // "M"
		w.activeSizeBuilder = w.builderSizeMedium
	case w.buildSmallSizeShortcut: // "S"
		w.activeSizeBuilder = w.builderSizeSmall
	default: // "L" or empty
		w.activeSizeBuilder = w.builderSizeLarge
	}
}

// UpdateCurrentBuilder sets the activeSizeBuilder based on mode and cancels ongoing operations
func (w *WasmClient) UpdateCurrentBuilder(mode string) {
	// 1. Cancel any ongoing compilation
	if w.activeSizeBuilder != nil {
		w.activeSizeBuilder.Cancel()
	}

	// 2. Update current mode tracking
	w.CurrentSizeMode = mode

	// 3. Set activeSizeBuilder based on mode
	switch mode {
	case w.buildLargeSizeShortcut: // "L"
		w.activeSizeBuilder = w.builderSizeLarge
	case w.buildMediumSizeShortcut: // "M"
		w.activeSizeBuilder = w.builderSizeMedium
	case w.buildSmallSizeShortcut: // "S"
		w.activeSizeBuilder = w.builderSizeSmall
	default:
		w.activeSizeBuilder = w.builderSizeLarge // fallback to coding mode
	}
}

// OutputRelativePath returns the RELATIVE path to the final output file
// eg: "deploy/edgeworker/app.wasm" (relative to AppRootDir)
// This is used by file watchers to identify output files that should be ignored.
// The returned path always uses forward slashes (/) for consistency across platforms.
func (w *WasmClient) OutputRelativePath() string {
	// FinalOutputPath() returns absolute path like: /tmp/test/deploy/edgeworker/app.wasm
	// We need to extract the relative portion: deploy/edgeworker/app.wasm
	fullPath := w.activeSizeBuilder.FinalOutputPath()

	// Remove AppRootDir prefix to get relative path
	if strings.HasPrefix(fullPath, w.AppRootDir) {
		relPath := strings.TrimPrefix(fullPath, w.AppRootDir)
		// Remove leading separator (/ or \)
		relPath = strings.TrimPrefix(relPath, string(filepath.Separator))
		relPath = strings.TrimPrefix(relPath, "/")  // Handle Unix paths
		relPath = strings.TrimPrefix(relPath, "\\") // Handle Windows paths
		// Normalize to forward slashes for consistency (replace all backslashes)
		return strings.ReplaceAll(relPath, "\\", "/")
	}

	// Fallback: construct from config values (which are already relative)
	// Normalize to forward slashes for consistency
	result := filepath.Join(w.Config.OutputDir(), w.OutputName+".wasm")
	return strings.ReplaceAll(result, "\\", "/")
}