package main

import (
	"bytes"
	"database/sql"
	"fmt"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"time"

	_ "github.com/mattn/go-sqlite3"

	"fn-registry/registry"
)

func cmdRun(args []string) {
	if len(args) == 0 {
		fmt.Fprintln(os.Stderr, "usage: fn run <id_or_name> [args...]")
		os.Exit(1)
	}

	idOrName := args[0]
	passArgs := args[1:]

	registryRoot := root()
	dbPath := filepath.Join(registryRoot, dbName)

	db, err := registry.Open(dbPath)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error: cannot open registry: %v\n", err)
		os.Exit(1)
	}
	defer db.Close()

	fn, err := resolveFunction(db, idOrName)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}

	if fn.FilePath == "" {
		fmt.Fprintf(os.Stderr, "error: %s has no file_path in registry\n", fn.ID)
		os.Exit(1)
	}

	absPath := filepath.Join(registryRoot, fn.FilePath)
	if _, err := os.Stat(absPath); os.IsNotExist(err) {
		fmt.Fprintf(os.Stderr, "error: file not found: %s\n", absPath)
		os.Exit(1)
	}

	cmd, err := buildCommand(fn, db, registryRoot, absPath, passArgs)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}

	// When fn run executes a scoped `go test -run`, mirror its output into a
	// buffer so we can detect a "no tests to run" result — which go test reports
	// with exit 0 and would otherwise be a silent false-green (e.g. the extracted
	// unit_tests names drifted from the code). See issue 0167.
	guardGoTest := fn.Lang == "go" && isGoTestRun(cmd)
	var outBuf bytes.Buffer
	if guardGoTest {
		cmd.Stdout = io.MultiWriter(os.Stdout, &outBuf)
		cmd.Stderr = io.MultiWriter(os.Stderr, &outBuf)
	} else {
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
	}
	cmd.Stdin = os.Stdin

	fmt.Fprintf(os.Stderr, "[fn run] %s (%s/%s) %s\n", fn.ID, fn.Lang, fn.Kind, strings.Join(passArgs, " "))

	t0 := time.Now()
	runErr := cmd.Run()
	durationMs := time.Since(t0).Milliseconds()

	// A scoped go test that matched zero tests is a false-green: treat as failure.
	if guardGoTest && runErr == nil && strings.Contains(outBuf.String(), "no tests to run") {
		fmt.Fprintf(os.Stderr, "\n[fn run] error: -run no encontro ningun test para %s — los nombres de test extraidos no existen en el codigo; corre 'fn index'\n", fn.ID)
		logFnRunTelemetry(registryRoot, fn.ID, durationMs, false, "no_tests_run")
		os.Exit(1)
	}

	exitCode := 0
	errClass := ""
	if runErr != nil {
		if exitErr, ok := runErr.(*exec.ExitError); ok {
			exitCode = exitErr.ExitCode()
			errClass = fmt.Sprintf("exit_%d", exitCode)
		} else {
			exitCode = 1
			errClass = "spawn_error"
		}
	}
	logFnRunTelemetry(registryRoot, fn.ID, durationMs, exitCode == 0, errClass)

	if runErr != nil {
		if errClass == "spawn_error" {
			fmt.Fprintf(os.Stderr, "error: %v\n", runErr)
		}
		os.Exit(exitCode)
	}
}

// logFnRunTelemetry inserts a row into call_monitor.operations.db.calls if
// the database is present. No-op silently otherwise — never blocks the run.
func logFnRunTelemetry(registryRoot, functionID string, durationMs int64, success bool, errClass string) {
	callDB := filepath.Join(registryRoot, "projects", "fn_monitoring", "apps", "call_monitor", "operations.db")
	if _, err := os.Stat(callDB); err != nil {
		return
	}
	conn, err := sql.Open("sqlite3", callDB+"?_journal_mode=WAL&_busy_timeout=100")
	if err != nil {
		return
	}
	defer conn.Close()
	sessionID := os.Getenv("CLAUDE_SESSION_ID")
	successInt := 0
	if success {
		successInt = 1
	}
	_, _ = conn.Exec(
		`INSERT INTO calls (session_id, function_id, tool_used, args_hash, duration_ms, success, error_class, error_snippet, ts)
		 VALUES (?, ?, 'fn_run_cli', '', ?, ?, ?, '', CAST(strftime('%s','now') AS INTEGER))`,
		sessionID, functionID, durationMs, successInt, errClass,
	)
}

func resolveFunction(db *registry.DB, idOrName string) (*registry.Function, error) {
	fn, err := db.GetFunction(idOrName)
	if err == nil {
		return fn, nil
	}

	fns, err := db.GetFunctionsByName(idOrName)
	if err != nil {
		return nil, fmt.Errorf("lookup failed: %w", err)
	}
	if len(fns) == 0 {
		return nil, fmt.Errorf("function %q not found (tried as ID and name)", idOrName)
	}
	if len(fns) == 1 {
		return &fns[0], nil
	}

	var b strings.Builder
	fmt.Fprintf(&b, "ambiguous name %q — found %d matches:\n", idOrName, len(fns))
	for _, f := range fns {
		fmt.Fprintf(&b, "  %s  (%s/%s)\n", f.ID, f.Lang, f.Kind)
	}
	fmt.Fprintf(&b, "use the full ID to disambiguate")
	return nil, fmt.Errorf("%s", b.String())
}

func buildCommand(fn *registry.Function, db *registry.DB, registryRoot, absPath string, args []string) (*exec.Cmd, error) {
	switch fn.Lang {
	case "go":
		return buildGoCommand(fn, db, registryRoot, absPath, args)
	case "py":
		return buildPyRunnerCommand(fn, db, registryRoot, args)
	case "bash":
		return buildBashCommand(absPath, args)
	case "ts":
		return buildTsCommand(registryRoot, absPath, args)
	case "cpp":
		return buildCppCommand(fn, registryRoot, absPath, args)
	default:
		return nil, fmt.Errorf("unsupported lang %q for execution", fn.Lang)
	}
}

func buildGoCommand(fn *registry.Function, db *registry.DB, registryRoot, absPath string, args []string) (*exec.Cmd, error) {
	dir := filepath.Dir(absPath)
	env := append(os.Environ(), "CGO_ENABLED=1")

	// If directory has main.go → go run . (pipelines and standalone executables)
	mainGo := filepath.Join(dir, "main.go")
	if _, err := os.Stat(mainGo); err == nil {
		cmdArgs := append([]string{"run", "."}, args...)
		cmd := exec.Command("go", cmdArgs...)
		cmd.Dir = dir
		cmd.Env = env
		return cmd, nil
	}

	// Library code with tests → go test, but scoped to THIS function's tests via
	// -run, so a flaky test of a sibling function in the same package does not
	// break `fn run`. Test names come from the indexer-extracted unit_tests table
	// (parsed from the real .go, reliable), never the .md frontmatter (can drift).
	// The cmdRun guard fails the run if -run matches zero tests, preventing a
	// silent "no tests to run" false-green. See issue 0167.
	if fn.Tested && fn.TestFilePath != "" {
		testAbs := filepath.Join(registryRoot, fn.TestFilePath)
		if _, err := os.Stat(testAbs); err == nil {
			relPkg, _ := filepath.Rel(registryRoot, dir)
			pkgPath := "./" + filepath.ToSlash(relPkg)
			cmdArgs := []string{"test", "-v", "-count=1", "-tags", "fts5"}
			if names := goTestNames(db, fn.ID); len(names) > 0 {
				cmdArgs = append(cmdArgs, "-run", "^("+strings.Join(names, "|")+")$")
			}
			cmdArgs = append(cmdArgs, pkgPath)
			cmdArgs = append(cmdArgs, args...)
			cmd := exec.Command("go", cmdArgs...)
			cmd.Dir = registryRoot
			cmd.Env = env
			return cmd, nil
		}
	}

	// No tests: go vet (compilation check)
	relPkg, _ := filepath.Rel(registryRoot, dir)
	pkgPath := "./" + filepath.ToSlash(relPkg)
	cmdArgs := []string{"vet", "-tags", "fts5", pkgPath}
	cmd := exec.Command("go", cmdArgs...)
	cmd.Dir = registryRoot
	cmd.Env = env
	fmt.Fprintf(os.Stderr, "[fn run] %s is library code without tests — running go vet\n", fn.ID)
	return cmd, nil
}

// goTestNames returns the top-level Go test function names registered for fn in
// the indexer-extracted unit_tests table. These drive `go test -run` so that
// `fn run` only executes the function's own tests, isolating it from flaky tests
// of sibling functions in the same package. Returns nil if none are known (db is
// nil, lookup fails, or no tests extracted), in which case the caller falls back
// to running the whole package.
func goTestNames(db *registry.DB, functionID string) []string {
	if db == nil {
		return nil
	}
	uts, err := db.GetUnitTestsByFunction(functionID)
	if err != nil {
		return nil
	}
	var names []string
	for _, ut := range uts {
		if ut.Name != "" {
			names = append(names, ut.Name)
		}
	}
	return names
}

// isGoTestRun reports whether cmd is a `go test ... -run ...` invocation, used to
// enable the zero-tests-matched guard in cmdRun.
func isGoTestRun(cmd *exec.Cmd) bool {
	var hasTest, hasRun bool
	for _, a := range cmd.Args {
		switch a {
		case "test":
			hasTest = true
		case "-run":
			hasRun = true
		}
	}
	return hasTest && hasRun
}


func buildBashCommand(absPath string, args []string) (*exec.Cmd, error) {
	cmdArgs := append([]string{absPath}, args...)
	cmd := exec.Command("bash", cmdArgs...)
	cmd.Dir = filepath.Dir(absPath)
	return cmd, nil
}

func buildTsCommand(registryRoot, absPath string, args []string) (*exec.Cmd, error) {
	tsxBin := filepath.Join(registryRoot, "frontend", "node_modules", ".bin", "tsx")
	if _, err := os.Stat(tsxBin); os.IsNotExist(err) {
		return nil, fmt.Errorf("tsx not found — run: cd frontend && pnpm add -D tsx")
	}

	cmdArgs := append([]string{absPath}, args...)
	cmd := exec.Command(tsxBin, cmdArgs...)
	cmd.Dir = filepath.Dir(absPath)
	return cmd, nil
}
