package watchers

import (
	"fmt"
	"sync"

	"Moonshark/routers"
	"Moonshark/runner"
	"Moonshark/utils/logger"
)

// Global watcher manager instance with explicit creation
var (
	globalManager     *WatcherManager
	globalManagerOnce sync.Once
)

// GetWatcherManager returns the global watcher manager, creating it if needed
func GetWatcherManager() *WatcherManager {
	globalManagerOnce.Do(func() {
		globalManager = NewWatcherManager(DefaultPollInterval)
	})
	return globalManager
}

// ShutdownWatcherManager closes the global watcher manager if it exists
func ShutdownWatcherManager() {
	if globalManager != nil {
		globalManager.Close()
		globalManager = nil
	}
}

// WatchLuaRouter sets up a watcher for a LuaRouter's routes directory
func WatchLuaRouter(router *routers.LuaRouter, runner *runner.Runner, routesDir string) (*DirectoryWatcher, error) {
	manager := GetWatcherManager()

	runnerRefresh := func() error {
		logger.Debug("Refreshing LuaRunner state due to file change")
		runner.NotifyFileChanged("")
		return nil
	}

	combinedCallback := combineCallbacks(router.Refresh, runnerRefresh)

	config := DirectoryWatcherConfig{
		Dir:       routesDir,
		Callback:  combinedCallback,
		Recursive: true,
	}

	watcher, err := manager.WatchDirectory(config)
	if err != nil {
		return nil, fmt.Errorf("failed to watch directory: %w", err)
	}

	logger.Info("Started watching Lua routes directory: %s", routesDir)
	return watcher, nil
}

// WatchLuaModules sets up watchers for Lua module directories
func WatchLuaModules(luaRunner *runner.Runner, libDirs []string) ([]*DirectoryWatcher, error) {
	manager := GetWatcherManager()
	watchers := make([]*DirectoryWatcher, 0, len(libDirs))

	for _, dir := range libDirs {
		dirCopy := dir

		callback := func() error {
			logger.Debug("Detected changes in Lua module directory: %s", dirCopy)

			if err := luaRunner.RefreshStates(); err != nil {
				logger.Warning("Error reloading modules: %v", err)
			}

			return nil
		}

		config := DirectoryWatcherConfig{
			Dir:       dir,
			Callback:  callback,
			Recursive: true,
		}

		watcher, err := manager.WatchDirectory(config)
		if err != nil {
			for _, w := range watchers {
				manager.UnwatchDirectory(w.dir)
			}
			return nil, fmt.Errorf("failed to watch directory %s: %w", dir, err)
		}

		watchers = append(watchers, watcher)
		logger.Info("Started watching Lua modules directory: %s", dir)
	}

	return watchers, nil
}

// combineCallbacks creates a single callback function from multiple callbacks
func combineCallbacks(callbacks ...func() error) func() error {
	return func() error {
		for _, callback := range callbacks {
			if err := callback(); err != nil {
				return err
			}
		}
		return nil
	}
}