package commands

import (
	"cmp"
	"flag"
	"fmt"
	"log"
	"net"
	"os"
	"os/exec"
	"os/signal"
	"path/filepath"
	"strings"
	"sync"
	"syscall"
	"time"

	"github.com/fsnotify/fsnotify"
)

const devUsage = `Start a development server with hot reload

Usage:
  congo dev [flags]

Flags:
  --port <port>      Override server port (default: 5000)
  --no-watch         Disable file watching (just run once)

The server runs with ENV=development. Go and template files are watched
for changes — the server rebuilds and restarts automatically.
Press Ctrl+C to stop.
`

func Dev() {
	fs := flag.NewFlagSet("dev", flag.ExitOnError)
	fs.Usage = func() { fmt.Print(devUsage) }

	port := fs.String("port", "", "Override server port")
	noWatch := fs.Bool("no-watch", false, "Disable file watching")

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

	dir := findAppDir()

	env := append(os.Environ(), "ENV=development")
	if *port != "" {
		env = append(env, "PORT="+*port)
	}

	listenPort := cmp.Or(*port, os.Getenv("PORT"), "5000")

	// Check for port conflicts before starting.
	if conn, err := net.Dial("tcp", "localhost:"+listenPort); err == nil {
		conn.Close()
		log.Fatalf("Port %s is already in use. Try:\n  congo dev --port <other-port>", listenPort)
	}

	if *noWatch {
		fmt.Printf("Starting development server from ./%s\n", dir)
		fmt.Printf("  http://localhost:%s\n\n", listenPort)
		cmd := exec.Command("go", "run", "./"+dir)
		cmd.Env = env
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		cmd.Stdin = os.Stdin
		if err := cmd.Run(); err != nil {
			if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 2 {
				fmt.Fprintf(os.Stderr, "\nBuild failed. Check the errors above.\n")
			}
			os.Exit(1)
		}
		return
	}

	d := &devServer{
		dir:  dir,
		env:  env,
		port: listenPort,
	}
	d.run()
}

// devServer manages the build-watch-restart loop.
type devServer struct {
	dir  string
	env  []string
	port string

	mu  sync.Mutex
	cmd *exec.Cmd
}

func (d *devServer) run() {
	fmt.Printf("Starting development server from ./%s\n", d.dir)
	fmt.Printf("  http://localhost:%s\n\n", d.port)

	// Initial build + start
	d.buildAndStart()

	// Set up file watcher
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		log.Fatalf("Could not start file watcher: %v", err)
	}
	defer watcher.Close()

	d.watchDirs(watcher)

	// Handle Ctrl+C
	sigCh := make(chan os.Signal, 1)
	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)

	// Debounce timer for file changes
	var timer *time.Timer
	debounce := 500 * time.Millisecond

	for {
		select {
		case event, ok := <-watcher.Events:
			if !ok {
				return
			}
			if !isRelevantChange(event) {
				continue
			}

			// Watch newly created directories
			if event.Has(fsnotify.Create) {
				if info, err := os.Stat(event.Name); err == nil && info.IsDir() {
					d.addWatchDir(watcher, event.Name)
				}
			}

			if timer != nil {
				timer.Stop()
			}
			timer = time.AfterFunc(debounce, func() {
				fmt.Printf("\n[dev] Change detected: %s\n", event.Name)
				d.buildAndStart()
			})

		case err, ok := <-watcher.Errors:
			if !ok {
				return
			}
			log.Printf("[dev] Watcher error: %v", err)

		case <-sigCh:
			fmt.Println("\nShutting down...")
			d.stop()
			return
		}
	}
}

// buildAndStart compiles the app and starts the new process.
// If the build fails, the old process keeps running.
func (d *devServer) buildAndStart() {
	d.mu.Lock()
	defer d.mu.Unlock()

	binPath := filepath.Join(os.TempDir(), "congo-dev-"+filepath.Base(d.dir))

	// Build
	build := exec.Command("go", "build", "-o", binPath, "./"+d.dir)
	build.Env = d.env
	build.Stdout = os.Stdout
	build.Stderr = os.Stderr
	if err := build.Run(); err != nil {
		fmt.Fprintf(os.Stderr, "\n[dev] Build failed. Fix the errors above — will retry on next change.\n\n")
		return
	}

	// Stop old process
	d.stopProcess()

	// Start new process
	cmd := exec.Command(binPath)
	cmd.Env = d.env
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.SysProcAttr = processGroupAttr()

	if err := cmd.Start(); err != nil {
		log.Printf("[dev] Failed to start: %v", err)
		return
	}

	d.cmd = cmd
	fmt.Printf("[dev] Server running (pid %d)\n\n", cmd.Process.Pid)

	// Wait in background to reap the process
	go cmd.Wait()
}

// stopProcess terminates the running server process and its children.
func (d *devServer) stopProcess() {
	if d.cmd == nil || d.cmd.Process == nil {
		return
	}
	// Kill the process group (server + any children)
	killProcessGroup(d.cmd.Process.Pid, syscall.SIGTERM)
	done := make(chan struct{})
	go func() {
		d.cmd.Wait()
		close(done)
	}()
	select {
	case <-done:
	case <-time.After(3 * time.Second):
		killProcessGroup(d.cmd.Process.Pid, syscall.SIGKILL)
		<-done
	}
	d.cmd = nil
}

func (d *devServer) stop() {
	d.mu.Lock()
	defer d.mu.Unlock()
	d.stopProcess()
}

// watchDirs adds all directories containing Go/template files to the watcher.
func (d *devServer) watchDirs(watcher *fsnotify.Watcher) {
	filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return nil
		}
		// Skip hidden dirs, build dirs, node_modules
		name := info.Name()
		if info.IsDir() && (strings.HasPrefix(name, ".") || name == "node_modules" || name == "build" || name == "vendor") {
			return filepath.SkipDir
		}
		if info.IsDir() {
			watcher.Add(path)
		}
		return nil
	})
}

// addWatchDir adds a new directory and its children to the watcher.
func (d *devServer) addWatchDir(watcher *fsnotify.Watcher, dir string) {
	filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return nil
		}
		name := info.Name()
		if info.IsDir() && (strings.HasPrefix(name, ".") || name == "node_modules" || name == "build" || name == "vendor") {
			return filepath.SkipDir
		}
		if info.IsDir() {
			watcher.Add(path)
		}
		return nil
	})
}

// isRelevantChange returns true if the file event should trigger a rebuild.
func isRelevantChange(event fsnotify.Event) bool {
	if !event.Has(fsnotify.Write) && !event.Has(fsnotify.Create) && !event.Has(fsnotify.Remove) {
		return false
	}
	ext := filepath.Ext(event.Name)
	switch ext {
	case ".go", ".html", ".tmpl":
		return true
	}
	return false
}

// findAppDir locates the app directory containing main.go.
// Checks common names, then falls back to root.
func findAppDir() string {
	for _, dir := range []string{"web", "app", "api", "cmd"} {
		if _, err := os.Stat(filepath.Join(dir, "main.go")); err == nil {
			return dir
		}
	}
	if _, err := os.Stat("main.go"); err == nil {
		return "."
	}
	log.Fatal("No main.go found in web/, app/, api/, cmd/, or root.\nRun 'congo init <name>' to create a project.")
	return ""
}