Moonshark/core/moonshark.go

package core

import (
	"context"
	"errors"
	"fmt"
	"os"
	"time"

	"Moonshark/core/http"
	"Moonshark/core/routers"
	"Moonshark/core/runner"
	"Moonshark/core/sessions"
	"Moonshark/core/utils/config"
	"Moonshark/core/utils/logger"
	"Moonshark/core/watchers"
)

// Moonshark represents the server and all its dependencies
type Moonshark struct {
	Config       *config.Config
	LuaRouter    *routers.LuaRouter
	StaticRouter *routers.StaticRouter
	LuaRunner    *runner.Runner
	HTTPServer   *http.Server

	// Clean-up functions for watchers
	cleanupFuncs []func() error
}

// dirExists checks if a directory exists without creating it
func dirExists(path string) bool {
	info, err := os.Stat(path)
	if err != nil {
		return false
	}
	return info.IsDir()
}

// NewMoonshark creates a new Moonshark server instance
func NewMoonshark(configPath string) (*Moonshark, error) {
	server := &Moonshark{}

	if err := server.loadConfig(configPath); err != nil {
		return nil, err
	}

	server.setupLogging()

	if err := server.initRouters(); err != nil {
		return nil, err
	}

	if err := server.initRunner(); err != nil {
		return nil, err
	}

	if err := server.setupWatchers(); err != nil {
		logger.Warning("Error setting up watchers: %v", err)
	}

	server.HTTPServer = http.New(
		server.LuaRouter,
		server.StaticRouter,
		server.LuaRunner,
		server.Config.Server.HTTPLogging,
		server.Config.Server.Debug,
		server.Config.Dirs.Override,
		server.Config,
	)

	return server, nil
}

// loadConfig loads the configuration file
func (s *Moonshark) loadConfig(configPath string) error {
	var err error

	s.Config, err = config.Load(configPath)
	if err != nil {
		logger.Warning("Wipeout! Couldn't load config file: %v", err)
		logger.Warning("Rolling with the default setup")
		s.Config = config.New()
	}

	return nil
}

// setupLogging configures the logger based on config settings
func (s *Moonshark) setupLogging() {
	switch s.Config.Server.LogLevel {
	case "warn":
		logger.SetLevel(logger.LevelWarning)
	case "error":
		logger.SetLevel(logger.LevelError)
	case "server":
		logger.SetLevel(logger.LevelServer)
	case "fatal":
		logger.SetLevel(logger.LevelFatal)
	default:
		logger.SetLevel(logger.LevelInfo)
	}

	if s.Config.Server.Debug {
		logger.EnableDebug() // Force debug logs regardless of level
		logger.Debug("Debug mode is ready to party, bro")
	}
}

// initRouters initializes the Lua and static routers
func (s *Moonshark) initRouters() error {
	if !dirExists(s.Config.Dirs.Routes) {
		logger.Fatal("Routes directory doesn't exist: %s", s.Config.Dirs.Routes)
		return fmt.Errorf("routes directory doesn't exist: %s", s.Config.Dirs.Routes)
	}

	// Initialize Lua router for dynamic routes
	var err error
	s.LuaRouter, err = routers.NewLuaRouter(s.Config.Dirs.Routes)
	if err != nil {
		// Check if this is a compilation warning or a more serious error
		if errors.Is(err, routers.ErrRoutesCompilationErrors) {
			// Some routes failed to compile, but router is still usable
			logger.Warning("Some Lua routes failed to compile. Check logs for details.")

			// Log details about each failed route
			if failedRoutes := s.LuaRouter.ReportFailedRoutes(); len(failedRoutes) > 0 {
				for _, re := range failedRoutes {
					logger.Error("Route %s %s failed to compile: %v", re.Method, re.Path, re.Err)
				}
			}
		} else {
			// More serious error that prevents router initialization
			return fmt.Errorf("failed to initialize Lua router: %v", err)
		}
	}
	logger.Info("Lua router is stoked and riding routes from %s", s.Config.Dirs.Routes)

	if dirExists(s.Config.Dirs.Static) {
		s.StaticRouter, err = routers.NewStaticRouter(s.Config.Dirs.Static)
		if err != nil {
			return fmt.Errorf("failed to initialize static router: %v", err)
		}
		logger.Info("Static router catching waves with files from %s", s.Config.Dirs.Static)
		s.StaticRouter.EnableDebugLog()
	} else {
		logger.Warning("Static directory doesn't exist: %s - static file serving disabled", s.Config.Dirs.Static)
	}

	return nil
}

// initRunner initializes the Lua runner
func (s *Moonshark) initRunner() error {
	if !dirExists(s.Config.Dirs.Override) {
		logger.Warning("Override directory doesn't exist: %s", s.Config.Dirs.Override)
		s.Config.Dirs.Override = ""
	}

	for _, dir := range s.Config.Dirs.Libs {
		if !dirExists(dir) {
			logger.Warning("Lib directory doesn't exist: %s", dir)
		}
	}

	sessionManager := sessions.GlobalSessionManager
	sessionManager.SetCookieOptions(
		"MoonsharkSID", // name
		"/",            // path
		"",             // domain
		false,          // secure
		true,           // httpOnly
		86400,          // maxAge (1 day)
	)

	runnerOpts := []runner.RunnerOption{
		runner.WithPoolSize(s.Config.Runner.PoolSize),
		runner.WithLibDirs(s.Config.Dirs.Libs...),
	}

	var err error
	s.LuaRunner, err = runner.NewRunner(runnerOpts...)
	if err != nil {
		return fmt.Errorf("failed to initialize Lua runner: %v", err)
	}

	logger.Server("Lua runner waxing up with a pool size of %d", s.Config.Runner.PoolSize)
	return nil
}

// setupWatchers initializes and starts all configured file watchers
func (s *Moonshark) setupWatchers() error {
	manager := watchers.GetWatcherManager()

	// Set up watcher for Lua routes
	routeWatcher, err := watchers.WatchLuaRouter(s.LuaRouter, s.LuaRunner, s.Config.Dirs.Routes)
	if err != nil {
		logger.Warning("Failed to watch routes directory: %v", err)
	} else {
		routesDir := routeWatcher.GetDir()
		s.cleanupFuncs = append(s.cleanupFuncs, func() error {
			return manager.UnwatchDirectory(routesDir)
		})
	}

	// Set up watchers for Lua modules libraries
	moduleWatchers, err := watchers.WatchLuaModules(s.LuaRunner, s.Config.Dirs.Libs)
	if err != nil {
		logger.Warning("Failed to watch Lua module directories: %v", err)
	} else {
		for _, watcher := range moduleWatchers {
			dirPath := watcher.GetDir()
			s.cleanupFuncs = append(s.cleanupFuncs, func() error {
				return manager.UnwatchDirectory(dirPath)
			})
		}
		logger.Info("File watchers active for %d Lua module directories", len(moduleWatchers))
	}

	return nil
}

// Start starts the HTTP server
func (s *Moonshark) Start() error {
	logger.Server("Surf's up on port %d!", s.Config.Server.Port)

	go func() {
		if err := s.HTTPServer.ListenAndServe(fmt.Sprintf(":%d", s.Config.Server.Port)); err != nil {
			if err.Error() != "http: Server closed" {
				logger.Error("Server error: %v", err)
			}
		}
	}()

	return nil
}

// Shutdown gracefully shuts down the server
func (s *Moonshark) Shutdown() error {
	logger.Server("Shutting down server...")

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	if err := s.HTTPServer.Shutdown(ctx); err != nil {
		logger.Error("Server shutdown error: %v", err)
		return err
	}

	for _, cleanup := range s.cleanupFuncs {
		if err := cleanup(); err != nil {
			logger.Warning("Cleanup error: %v", err)
		}
	}

	s.LuaRunner.Close()

	logger.Server("Server stopped")
	return nil
}