fulgens/main.go

package main

import (
	library "git.ailur.dev/ailur/fg-library/v2"

	"errors"
	"io"
	"log"
	"mime"
	"os"
	"plugin"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"compress/gzip"
	"crypto/tls"
	"database/sql"
	"encoding/json"
	"log/slog"
	"net/http"
	"net/http/httputil"
	"net/url"
	"path/filepath"

	"github.com/andybalholm/brotli"
	"github.com/go-chi/chi/v5"
	"github.com/go-playground/validator/v10"
	"github.com/google/uuid"
	"github.com/klauspost/compress/zstd"

	_ "github.com/lib/pq"
	_ "github.com/mattn/go-sqlite3"
)

type Config struct {
	Global struct {
		IP                string `json:"ip" validate:"required,ip_addr"`
		HTTPPort          string `json:"httpPort" validate:"required"`
		HTTPSPort         string `json:"httpsPort" validate:"required"`
		ServiceDirectory  string `json:"serviceDirectory" validate:"required"`
		ResourceDirectory string `json:"resourceDirectory" validate:"required"`
		Compression       struct {
			Algorithm string  `json:"algorithm" validate:"omitempty,oneof=gzip brotli zstd"`
			Level     float64 `json:"level" validate:"omitempty,min=1,max=22"`
		} `json:"compression"`
		Logging struct {
			Enabled bool   `json:"enabled"`
			File    string `json:"file" validate:"required_if=Enabled true"`
		} `json:"logging"`
		Database struct {
			Type             string `json:"type" validate:"required,oneof=sqlite postgres"`
			ConnectionString string `json:"connectionString" validate:"required_if=Type postgres"`
			Path             string `json:"path" validate:"required_if=Type sqlite"`
		} `json:"database" validate:"required"`
	} `json:"global" validate:"required"`
	Routes []struct {
		Subdomain string   `json:"subdomain" validate:"required"`
		Services  []string `json:"services"`
		Paths     []struct {
			Path  string `json:"path" validate:"required"`
			Proxy struct {
				URL         string `json:"url" validate:"required"`
				StripPrefix bool   `json:"stripPrefix"`
			} `json:"proxy" validate:"required_without=Static"`
			Static struct {
				Root             string `json:"root" validate:"required,isDirectory"`
				DirectoryListing bool   `json:"directoryListing"`
			} `json:"static" validate:"required_without=Proxy"`
		} `json:"paths"`
		HTTPS struct {
			CertificatePath string `json:"certificatePath" validate:"required"`
			KeyPath         string `json:"keyPath" validate:"required"`
		} `json:"https"`
		Compression struct {
			Algorithm string  `json:"algorithm" validate:"omitempty,oneof=gzip brotli zstd"`
			Level     float64 `json:"level" validate:"omitempty,min=1,max=22"`
		} `json:"compression"`
	} `json:"routes"`
	Services map[string]interface{} `json:"services"`
}

type Service struct {
	ServiceID       uuid.UUID
	ServiceMetadata library.Service
	Inbox           chan library.InterServiceMessage
}

type ResponseWriterWrapper struct {
	http.ResponseWriter
	io.Writer
}

type CompressionSettings struct {
	Level     int
	Algorithm string
}

func (w *ResponseWriterWrapper) WriteHeader(statusCode int) {
	w.ResponseWriter.WriteHeader(statusCode)
}

func (w *ResponseWriterWrapper) Write(p []byte) (int, error) {
	return w.Writer.Write(p)
}

func checkCompressionAlgorithm(algorithm string, handler http.Handler) http.Handler {
	switch algorithm {
	case "gzip":
		return gzipHandler(handler)
	case "brotli":
		return brotliHandler(handler)
	case "zstd":
		return zStandardHandler(handler)
	default:
		return handler
	}
}

func logger(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		next.ServeHTTP(w, r)
		slog.Info(r.Method + " " + r.URL.Path)
	})
}

func serverChanger(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Server", "Fulgens HTTP Server")
		w.Header().Set("X-Powered-By", "Go net/http")
		next.ServeHTTP(w, r)
	})
}

func gzipHandler(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
			var compressionLevel int
			var host string
			if r.Header.Get("Host") != "" {
				host = r.Header.Get("Host")
			} else {
				host = "none"
			}

			compressionSettings, ok := compression[host]
			if !ok {
				compressionLevel = int(config.Global.Compression.Level)
			} else {
				compressionLevel = compressionSettings.Level
			}

			gzipWriter, err := gzip.NewWriterLevel(w, compressionLevel)
			if err != nil {
				slog.Error("Error creating gzip writer: " + err.Error())
				next.ServeHTTP(w, r)
				return
			}
			defer func() {
				w.Header().Del("Content-Length")
				err := gzipWriter.Close()
				if errors.Is(err, http.ErrBodyNotAllowed) {
					// This is fine, all it means is that they have it cached, and we don't need to send it
					return
				} else if err != nil {
					slog.Error("Error closing gzip writer: " + err.Error())
				}
			}()
			gzipResponseWriter := &ResponseWriterWrapper{ResponseWriter: w, Writer: gzipWriter}
			if w.Header().Get("Content-Encoding") != "" {
				w.Header().Set("Content-Encoding", w.Header().Get("Content-Encoding")+", gzip")
			} else {
				w.Header().Set("Content-Encoding", "gzip")
			}
			next.ServeHTTP(gzipResponseWriter, r)
		} else {
			next.ServeHTTP(w, r)
		}
	})
}
func brotliHandler(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if strings.Contains(r.Header.Get("Accept-Encoding"), "br") {
			var compressionLevel int
			var host string
			if r.Header.Get("Host") != "" {
				host = r.Header.Get("Host")
			} else {
				host = "none"
			}

			compressionSettings, ok := compression[host]
			if !ok {
				compressionLevel = int(config.Global.Compression.Level)
			} else {
				compressionLevel = compressionSettings.Level
			}

			brotliWriter := brotli.NewWriterV2(w, compressionLevel)
			defer func() {
				w.Header().Del("Content-Length")
				err := brotliWriter.Close()
				if errors.Is(err, http.ErrBodyNotAllowed) {
					// This is fine, all it means is that they have it cached, and we don't need to send it
					return
				} else if err != nil {
					slog.Error("Error closing Brotli writer: " + err.Error())
				}
			}()
			brotliResponseWriter := &ResponseWriterWrapper{ResponseWriter: w, Writer: brotliWriter}
			if w.Header().Get("Content-Encoding") != "" {
				w.Header().Set("Content-Encoding", w.Header().Get("Content-Encoding")+", br")
			} else {
				w.Header().Set("Content-Encoding", "br")
			}
			next.ServeHTTP(brotliResponseWriter, r)
		} else {
			next.ServeHTTP(w, r)
		}
	})
}

func zStandardHandler(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if strings.Contains(r.Header.Get("Accept-Encoding"), "zstd") {
			var compressionLevel int
			var host string
			if r.Header.Get("Host") != "" {
				host = r.Header.Get("Host")
			} else {
				host = "none"
			}

			compressionSettings, ok := compression[host]
			if !ok {
				compressionLevel = int(config.Global.Compression.Level)
			} else {
				compressionLevel = compressionSettings.Level
			}

			zStandardWriter, err := zstd.NewWriter(w, zstd.WithEncoderLevel(zstd.EncoderLevelFromZstd(compressionLevel)))
			if err != nil {
				slog.Error("Error creating ZStandard writer: " + err.Error())
				next.ServeHTTP(w, r)
				return
			}
			defer func() {
				w.Header().Del("Content-Length")
				err := zStandardWriter.Close()
				if err != nil {
					if errors.Is(err, http.ErrBodyNotAllowed) {
						// This is fine, all it means is that they have it cached, and we don't need to send it
						return
					} else {
						slog.Error("Error closing ZStandard writer: " + err.Error())
					}
				}
			}()
			gzipResponseWriter := &ResponseWriterWrapper{ResponseWriter: w, Writer: zStandardWriter}
			if w.Header().Get("Content-Encoding") != "" {
				w.Header().Set("Content-Encoding", w.Header().Get("Content-Encoding")+", zstd")
			} else {
				w.Header().Set("Content-Encoding", "zstd")
			}
			next.ServeHTTP(gzipResponseWriter, r)
		} else {
			next.ServeHTTP(w, r)
		}
	})
}

func listDirectory(w http.ResponseWriter, r *http.Request, root string) {
	// Provide a directory listing
	w.WriteHeader(200)
	w.Header().Set("Content-Type", "text/html")
	_, err := w.Write([]byte("<html><body><h2>Directory listing</h2><ul>"))
	if err != nil {
		serverError(w, 500)
		slog.Error("Error writing directory listing: " + err.Error())
		return
	}
	err = filepath.Walk(filepath.Join(root, filepath.FromSlash(r.URL.Path)), func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		relPath, err := filepath.Rel(root, path)
		if err != nil {
			return err
		}
		if relPath == "." {
			return nil
		}
		_, err = w.Write([]byte("<li><a href=\"" + relPath + "\">" + info.Name() + "</a></li>"))
		if err != nil {
			serverError(w, 500)
			slog.Error("Error writing directory: " + err.Error())
			return err
		}
		return nil
	})
	if err != nil {
		serverError(w, 500)
		slog.Error("Error walking directory: " + err.Error())
		return
	}
	_, err = w.Write([]byte("</ul></body></html>"))
	if err != nil {
		serverError(w, 500)
		slog.Error("Error writing directory listing: " + err.Error())
		return
	}
}

func parseEndRange(w http.ResponseWriter, file *os.File, end string) {
	endI64, err := strconv.ParseInt(end, 10, 64)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error parsing range: " + err.Error())
		return
	}
	_, err = file.Seek(-endI64, io.SeekEnd)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error seeking file: " + err.Error())
		return
	}
	_, err = io.Copy(w, file)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error writing file: " + err.Error())
		return
	}
}

func parseBeginningRange(w http.ResponseWriter, file *os.File, beginning string) {
	beginningI64, err := strconv.ParseInt(beginning, 10, 64)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error parsing range: " + err.Error())
		return
	}
	_, err = file.Seek(beginningI64, io.SeekStart)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error seeking file: " + err.Error())
		return
	}
	_, err = io.Copy(w, file)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error writing file: " + err.Error())
		return
	}
}

func parsePartRange(w http.ResponseWriter, file *os.File, beginning, end string) {
	beginningI64, err := strconv.ParseInt(beginning, 10, 64)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error parsing range: " + err.Error())
		return
	}
	endI64, err := strconv.ParseInt(end, 10, 64)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error parsing range: " + err.Error())
		return
	}
	_, err = file.Seek(beginningI64, io.SeekStart)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error seeking file: " + err.Error())
		return
	}
	_, err = io.CopyN(w, file, endI64-beginningI64)
	if err != nil {
		serverError(w, 500)
		slog.Error("Error writing file: " + err.Error())
		return
	}
}

func newFileServer(root string, directoryListing bool) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		stat, err := os.Stat(filepath.Join(root, filepath.FromSlash(r.URL.Path)))
		if err != nil {
			serverError(w, 404)
			return
		}

		if stat.IsDir() {
			if directoryListing {
				listDirectory(w, r, root)
			} else {
				serverError(w, 403)
			}
			return
		}

		file, err := os.Open(filepath.Join(root, filepath.FromSlash(r.URL.Path)))
		if err != nil {
			serverError(w, 500)
			return
		}

		w.Header().Set("Content-Type", mime.TypeByExtension(filepath.Ext(r.URL.Path)))

		if strings.HasPrefix(r.Header.Get("Range"), "bytes=") {
			// Parse the range header. If there is an int-int, seek to the first int then return a limitedReader.
			// If there is an int-, seek to the first int and return the rest of the file.
			// If there is an -int, seek to the end of the file minus int and return the last int bytes.
			for _, item := range strings.Split(strings.TrimPrefix(r.Header.Get("Range"), "bytes="), ", ") {
				if strings.Contains(item, "-") {
					beginning := strings.Split(item, "-")[0]
					end := strings.Split(item, "-")[1]
					if beginning == "" {
						parseEndRange(w, file, end)
					} else if end == "" {
						parseBeginningRange(w, file, beginning)
					} else {
						parsePartRange(w, file, beginning, end)
					}
				} else {
					serverError(w, 416)
					return
				}
			}
		} else {
			_, err = io.Copy(w, file)
			if err != nil {
				serverError(w, 500)
				slog.Error("Error writing file: " + err.Error())
				return
			}

			err = file.Close()
			if err != nil {
				slog.Error("Error closing file: " + err.Error())
			}
		}
	})
}

func serverError(w http.ResponseWriter, status int) {
	w.Header().Set("Content-Type", "text/html")
	w.WriteHeader(status)
	_, err := w.Write([]byte("<html><body><h2>" + strconv.Itoa(status) + " " + http.StatusText(status) + "</h2><span>Fulgens HTTP Server</span></body></html>"))
	if err != nil {
		slog.Error("Error writing " + strconv.Itoa(status) + ": " + err.Error())
		return
	}
}

func hostRouter(w http.ResponseWriter, r *http.Request) {
	host := strings.Split(r.Host, ":")[0]
	router, ok := subdomains[host]
	if !ok {
		router, ok = subdomains["none"]
		if !ok {
			serverError(w, 404)
			slog.Error("No subdomain found for " + host)
		}

	}

	compressionSettings, ok := compression[host]
	if !ok {
		checkCompressionAlgorithm(config.Global.Compression.Algorithm, router).ServeHTTP(w, r)
	} else {
		checkCompressionAlgorithm(compressionSettings.Algorithm, router).ServeHTTP(w, r)
	}
}

var (
	validate          *validator.Validate
	services          = make(map[uuid.UUID]Service)
	lock              sync.RWMutex
	config            Config
	certificates      = make(map[string]*tls.Certificate)
	compression       = make(map[string]CompressionSettings)
	subdomains        = make(map[string]*chi.Mux)
	serviceSubdomains = make(map[string]string)
)

func loadTLSCertificate(certificatePath, keyPath string) (*tls.Certificate, error) {
	certificate, err := tls.LoadX509KeyPair(certificatePath, keyPath)
	if err != nil {
		return nil, err
	} else {
		return &certificate, nil
	}
}

func getTLSCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
	cert, ok := certificates[hello.ServerName]
	if !ok {
		return nil, errors.New("no certificate found")
	} else {
		return cert, nil
	}
}

func svInit(message library.InterServiceMessage) {
	// Service database initialization message
	// Check if the service has the necessary permissions
	if services[message.ServiceID].ServiceMetadata.Permissions.Database {
		// Check if we are using sqlite or postgres
		if config.Global.Database.Type == "sqlite" {
			// Open the database and return the connection
			pluginConn, err := sql.Open("sqlite3", filepath.Join(config.Global.Database.Path, message.ServiceID.String()+".db"))
			if err != nil {
				// Report an error
				services[message.ServiceID].Inbox <- library.InterServiceMessage{
					ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
					ForServiceID: message.ServiceID,
					MessageType:  1,
					SentAt:       time.Now(),
					Message:      err,
				}
			} else {
				// Report a successful activation
				services[message.ServiceID].Inbox <- library.InterServiceMessage{
					ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
					ForServiceID: message.ServiceID,
					MessageType:  2,
					SentAt:       time.Now(),
					Message: library.Database{
						DB:     pluginConn,
						DBType: library.Sqlite,
					},
				}
			}
		} else if config.Global.Database.Type == "postgres" {
			// Connect to the database
			conn, err := sql.Open("postgres", config.Global.Database.ConnectionString)
			if err != nil {
				// Report an error
				services[message.ServiceID].Inbox <- library.InterServiceMessage{
					ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
					ForServiceID: message.ServiceID,
					MessageType:  1,
					SentAt:       time.Now(),
					Message:      err,
				}
			} else {
				// Try to create the schema
				_, err = conn.Exec("CREATE SCHEMA IF NOT EXISTS \"" + message.ServiceID.String() + "\"")
				if err != nil {
					// Report an error
					services[message.ServiceID].Inbox <- library.InterServiceMessage{
						ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
						ForServiceID: message.ServiceID,
						MessageType:  1,
						SentAt:       time.Now(),
						Message:      err,
					}
				} else {
					// Create a new connection to the database
					var connectionString string
					if strings.Contains(config.Global.Database.ConnectionString, "?") {
						connectionString = config.Global.Database.ConnectionString + "&search_path=\"" + message.ServiceID.String() + "\""
					} else {
						connectionString = config.Global.Database.ConnectionString + "?search_path=\"" + message.ServiceID.String() + "\""
					}
					pluginConn, err := sql.Open("postgres", connectionString)
					if err != nil {
						// Report an error
						services[message.ServiceID].Inbox <- library.InterServiceMessage{
							ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
							ForServiceID: message.ServiceID,
							MessageType:  1,
							SentAt:       time.Now(),
							Message:      err,
						}
					} else {
						// Test the connection
						err = pluginConn.Ping()
						if err != nil {
							// Report an error
							services[message.ServiceID].Inbox <- library.InterServiceMessage{
								ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
								ForServiceID: message.ServiceID,
								MessageType:  1,
								SentAt:       time.Now(),
								Message:      err,
							}
						} else {
							// Report a successful activation
							services[message.ServiceID].Inbox <- library.InterServiceMessage{
								ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
								ForServiceID: message.ServiceID,
								MessageType:  2,
								SentAt:       time.Now(),
								Message: library.Database{
									DB:     pluginConn,
									DBType: library.Postgres,
								},
							}
						}
					}
				}
			}
		}
	} else {
		// Report an error
		services[message.ServiceID].Inbox <- library.InterServiceMessage{
			ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
			ForServiceID: message.ServiceID,
			MessageType:  1,
			SentAt:       time.Now(),
			Message:      errors.New("database access not permitted"),
		}
	}
}

func tryAuthAccess(message library.InterServiceMessage) {
	// We need to check if the service is allowed to access the Authentication service
	serviceMetadata, ok := services[message.ServiceID]
	if ok && serviceMetadata.ServiceMetadata.Permissions.Authenticate {
		// Send message to Authentication service
		service, ok := services[uuid.MustParse("00000000-0000-0000-0000-000000000004")]
		if ok {
			service.Inbox <- message
		} else if !ok {
			// Send error message
			service, ok := services[message.ServiceID]
			if ok {
				service.Inbox <- library.InterServiceMessage{
					ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
					ForServiceID: message.ServiceID,
					MessageType:  1,
					SentAt:       time.Now(),
					Message:      errors.New("authentication service not found"),
				}
			} else {
				// This should never happen
				slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
				os.Exit(1)
			}
		} else {
			// Send error message
			service, ok := services[message.ServiceID]
			if ok {
				service.Inbox <- library.InterServiceMessage{
					ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
					ForServiceID: message.ServiceID,
					MessageType:  1,
					SentAt:       time.Now(),
					Message:      errors.New("authentication service not yet available"),
				}
			} else {
				// This should never happen
				slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
				os.Exit(1)
			}
		}
	} else {
		// Send error message
		service, ok := services[message.ServiceID]
		if ok {
			service.Inbox <- library.InterServiceMessage{
				ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
				ForServiceID: message.ServiceID,
				MessageType:  1,
				SentAt:       time.Now(),
				Message:      errors.New("authentication not permitted"),
			}
		} else {
			// This should never happen
			slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
			os.Exit(1)
		}
	}
}

func tryStorageAccess(message library.InterServiceMessage) {
	// We need to check if the service is allowed to access the Blob Storage service
	serviceMetadata, ok := services[message.ServiceID]
	if ok && serviceMetadata.ServiceMetadata.Permissions.BlobStorage {
		// Send message to Blob Storage service
		service, ok := services[uuid.MustParse("00000000-0000-0000-0000-000000000003")]
		if ok {
			service.Inbox <- message
		} else if !ok {
			// Send error message
			service, ok := services[message.ServiceID]
			if ok {
				service.Inbox <- library.InterServiceMessage{
					ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
					ForServiceID: message.ServiceID,
					MessageType:  1,
					SentAt:       time.Now(),
					Message:      errors.New("blob storage service not found"),
				}
			} else {
				// This should never happen
				slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
				os.Exit(1)
			}
		} else {
			// Send error message
			service, ok := services[message.ServiceID]
			if ok {
				service.Inbox <- library.InterServiceMessage{
					ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
					ForServiceID: message.ServiceID,
					MessageType:  1,
					SentAt:       time.Now(),
					Message:      errors.New("blob storage is not yet available"),
				}
			} else {
				// This should never happen
				slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
				os.Exit(1)
			}
		}
	} else {
		// Send error message
		service, ok := services[message.ServiceID]
		if ok {
			service.Inbox <- library.InterServiceMessage{
				ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
				ForServiceID: message.ServiceID,
				MessageType:  1,
				SentAt:       time.Now(),
				Message:      errors.New("blob storage is not permitted"),
			}
		} else {
			// This should never happen
			slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
			os.Exit(1)
		}
	}
}

func tryLogger(message library.InterServiceMessage) {
	// Logger service
	service, ok := services[message.ServiceID]
	if ok {
		switch message.MessageType {
		case 0:
			// Log message
			slog.Info(service.ServiceMetadata.Name + " says: " + message.Message.(string))
		case 1:
			// Warn message
			slog.Warn(service.ServiceMetadata.Name + " warns: " + message.Message.(string))
		case 2:
			// Error message
			slog.Error(service.ServiceMetadata.Name + " complains: " + message.Message.(string))
		case 3:
			// Fatal message
			slog.Error(service.ServiceMetadata.Name + "'s dying wish: " + message.Message.(string))
			os.Exit(1)
		}
	}
}

func processInterServiceMessage(channel chan library.InterServiceMessage) {
	for {
		message := <-channel
		if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000000") {
			// Broadcast message
			for _, service := range services {
				service.Inbox <- message
			}
		} else if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000001") {
			// Service initialization service
			switch message.MessageType {
			case 0:
				// This has been deprecated, ignore it
				// Send "true" back
				services[message.ServiceID].Inbox <- library.InterServiceMessage{
					ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
					ForServiceID: message.ServiceID,
					MessageType:  0,
					SentAt:       time.Now(),
					Message:      true,
				}
			case 1:
				svInit(message)
			}
		} else if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000002") {
			tryLogger(message)
		} else if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000003") {
			tryStorageAccess(message)
		} else if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000004") {
			tryAuthAccess(message)
		} else {
			serviceMetadata, ok := services[message.ServiceID]
			if ok && serviceMetadata.ServiceMetadata.Permissions.InterServiceCommunication {
				// Send message to specific service
				service, ok := services[message.ForServiceID]
				if !ok {
					// Send error message
					service, ok := services[message.ServiceID]
					if ok {
						service.Inbox <- library.InterServiceMessage{
							ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
							ForServiceID: message.ServiceID,
							MessageType:  1,
							SentAt:       time.Now(),
							Message:      errors.New("requested service not found"),
						}
					} else {
						// This should never happen
						slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
						os.Exit(1)
					}
				}
				service.Inbox <- message
			} else {
				// Send error message
				service, ok := services[message.ServiceID]
				if ok {
					service.Inbox <- library.InterServiceMessage{
						ServiceID:    uuid.MustParse("00000000-0000-0000-0000-000000000001"),
						ForServiceID: message.ServiceID,
						MessageType:  1,
						SentAt:       time.Now(),
						Message:      errors.New("inter-service communication not permitted"),
					}
				} else {
					// This should never happen
					slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
					os.Exit(1)
				}
			}
		}
	}
}

func parseConfig(path string) Config {
	// Register the custom validators
	validate = validator.New()

	// Register the custom isDirectory validator
	err := validate.RegisterValidation("isDirectory", func(fl validator.FieldLevel) bool {
		// Check if it exists
		fileInfo, err := os.Stat(fl.Field().String())
		if err != nil {
			return false
		}

		// Check if it is a directory
		return fileInfo.IsDir()
	})

	if err != nil {
		slog.Error("Error registering custom validator: " + err.Error())
		os.Exit(1)
	}

	// Parse the configuration file
	configFile, err := os.ReadFile(path)
	if err != nil {
		slog.Error("Error reading configuration file: " + err.Error())
		os.Exit(1)
	}

	// Parse the configuration file
	var config Config
	decoder := json.NewDecoder(strings.NewReader(string(regexp.MustCompile(`(?m)^\s*//.*`).ReplaceAll(configFile, []byte("")))))
	decoder.UseNumber()
	err = decoder.Decode(&config)
	if err != nil {
		slog.Error("Error parsing configuration file: " + err.Error())
		os.Exit(1)
	}

	// Validate the configuration
	err = validate.Struct(config)
	if err != nil {
		slog.Error("Invalid configuration: " + err.Error())
		os.Exit(1)
	}

	// Check if we are logging to a file
	if config.Global.Logging != (Config{}.Global.Logging) && config.Global.Logging.Enabled {
		// Check if the log file is set
		logFilePath := config.Global.Logging.File

		// Set the log file
		logFile, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
		if err != nil {
			slog.Error("Error opening log file: " + err.Error())
			os.Exit(1)
		}

		log.SetOutput(io.MultiWriter(os.Stdout, logFile))
	}

	return config
}

func iterateThroughSubdomains() {
	for _, route := range config.Routes {
		var subdomainRouter *chi.Mux
		// Create the subdomain router
		if route.Compression.Level != 0 {
			compression[route.Subdomain] = CompressionSettings{
				Level:     int(route.Compression.Level),
				Algorithm: route.Compression.Algorithm,
			}
		} else {
			subdomainRouter = chi.NewRouter()
			subdomainRouter.NotFound(func(w http.ResponseWriter, r *http.Request) {
				serverError(w, 404)
			})
		}

		subdomains[route.Subdomain] = subdomainRouter
		subdomains[route.Subdomain].Use(logger)
		subdomains[route.Subdomain].Use(serverChanger)

		// Check the services
		if route.Services != nil {
			// Iterate through the services
			for _, service := range route.Services {
				_, ok := serviceSubdomains[strings.ToLower(service)]
				if !ok {
					serviceSubdomains[strings.ToLower(service)] = route.Subdomain
				} else {
					slog.Error("Service " + service + " has multiple subdomains")
					os.Exit(1)
				}
			}
		}

		// Iterate through the paths
		for _, path := range route.Paths {
			if path.Static.Root != "" {
				// Serve the static directory
				subdomainRouter.Handle(path.Path, http.StripPrefix(strings.TrimSuffix(path.Path, "*"), newFileServer(path.Static.Root, path.Static.DirectoryListing)))
				slog.Info("Serving static directory " + path.Static.Root + " on subdomain " + route.Subdomain + " with pattern " + path.Path)
			} else if path.Proxy.URL != "" {
				// Parse the URL
				proxyUrl, err := url.Parse(path.Proxy.URL)
				if err != nil {
					slog.Error("Error parsing URL: " + err.Error())
					os.Exit(1)
				}
				// Create the proxy
				if path.Proxy.StripPrefix {
					subdomainRouter.Handle(path.Path, http.StripPrefix(strings.TrimSuffix(path.Path, "*"), httputil.NewSingleHostReverseProxy(proxyUrl)))
				} else {
					subdomainRouter.Handle(path.Path, httputil.NewSingleHostReverseProxy(proxyUrl))
				}
			}
		}

		// Add the TLS certificate
		if route.HTTPS.CertificatePath != "" && route.HTTPS.KeyPath != "" {
			certificate, err := loadTLSCertificate(route.HTTPS.CertificatePath, route.HTTPS.KeyPath)
			if err != nil {
				slog.Error("Error loading TLS certificate: " + err.Error())
				os.Exit(1)
			}
			certificates[route.Subdomain] = certificate
		}
	}
}

func initializeService(keys []time.Time, plugins map[time.Time]string, globalOutbox chan library.InterServiceMessage) {
	for _, k := range keys {
		// Get the plugin path
		pluginPath := plugins[k]

		// Load the plugin
		servicePlugin, err := plugin.Open(pluginPath)
		if err != nil {
			slog.Error("Could not load service: " + err.Error())
			os.Exit(1)
		}

		// Load the service information
		serviceInformationSymbol, err := servicePlugin.Lookup("ServiceInformation")
		if err != nil {
			slog.Error("Service lacks necessary information: " + err.Error())
			os.Exit(1)
		}

		serviceInformation := *serviceInformationSymbol.(*library.Service)

		// Load the main function
		main, err := servicePlugin.Lookup("Main")
		if err != nil {
			slog.Error("Service lacks necessary main function: " + err.Error())
			os.Exit(1)
		}

		// Initialize the service
		var inbox = make(chan library.InterServiceMessage)
		lock.Lock()
		services[serviceInformation.ServiceID] = Service{
			ServiceID:       serviceInformation.ServiceID,
			Inbox:           inbox,
			ServiceMetadata: serviceInformation,
		}
		lock.Unlock()

		slog.Info("Activating service " + serviceInformation.Name + " with ID " + serviceInformation.ServiceID.String())

		serviceInitializationInformation := library.ServiceInitializationInformation{
			Domain:        serviceInformation.Name,
			Configuration: config.Services[strings.ToLower(serviceInformation.Name)].(map[string]interface{}),
			Outbox:        globalOutbox,
			Inbox:         inbox,
		}

		// Make finalRouter a subdomain router if necessary
		serviceSubdomain, ok := serviceSubdomains[strings.ToLower(serviceInformation.Name)]
		if ok {
			serviceInitializationInformation.Router = subdomains[serviceSubdomain]
		} else {
			if serviceInformation.ServiceID != uuid.MustParse("00000000-0000-0000-0000-000000000003") {
				slog.Warn("Service " + serviceInformation.Name + " does not have a subdomain, it will not be served")
				// Give it a blank router so it doesn't try to nil pointer dereference
				serviceInitializationInformation.Router = chi.NewRouter()
			}
		}

		// Check if they want a resource directory
		if serviceInformation.Permissions.Resources {
			serviceInitializationInformation.ResourceDir = os.DirFS(filepath.Join(config.Global.ResourceDirectory, serviceInformation.ServiceID.String()))
		}

		main.(func(library.ServiceInitializationInformation))(serviceInitializationInformation)

		// Log the service activation
		slog.Info("Service " + serviceInformation.Name + " activated with ID " + serviceInformation.ServiceID.String())
	}
}

func main() {
	// Parse the configuration file
	if len(os.Args) < 2 {
		info, err := os.Stat("config.conf")
		if err != nil {
			if errors.Is(err, os.ErrNotExist) {
				slog.Error("No configuration file provided")
				os.Exit(1)
			} else {
				slog.Error("Error reading configuration file: " + err.Error())
				os.Exit(1)
			}
		}

		if info.IsDir() {
			slog.Error("No configuration file provided")
			os.Exit(1)
		}

		config = parseConfig("config.conf")
	} else {
		config = parseConfig(os.Args[1])
	}

	// If we are using sqlite, create the database directory if it does not exist
	if config.Global.Database.Type == "sqlite" {
		err := os.MkdirAll(config.Global.Database.Path, 0755)
		if err != nil {
			slog.Error("Error creating database directory: " + err.Error())
			os.Exit(1)
		}
	}

	// Iterate through the subdomains and create the routers as well as the compression levels and service maps
	iterateThroughSubdomains()

	var globalOutbox = make(chan library.InterServiceMessage)

	// Initialize the service discovery, health-check, and logging services
	// Since these are core services, always allocate them the service IDs 0, 1, and 2
	// These are not dynamically loaded, as they are integral to the system functioning
	go processInterServiceMessage(globalOutbox)

	// Initialize all the services
	plugins := make(map[time.Time]string)
	err := filepath.Walk(config.Global.ServiceDirectory, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if info.IsDir() || filepath.Ext(path) != ".fgs" {
			return nil
		}

		// Add the plugin to the list of plugins
		if info.Name() == "storage.fgs" {
			plugins[time.Unix(0, 0)] = path
			return nil
		} else if info.Name() == "auth.fgs" {
			plugins[time.Unix(0, 1)] = path
			return nil
		}

		plugins[info.ModTime()] = path

		return nil
	})

	if err != nil {
		slog.Error("Error walking the services directory: " + err.Error())
		os.Exit(1)
	}

	// Sort the plugins by modification time, newest last
	var keys []time.Time
	for k := range plugins {
		keys = append(keys, k)
	}

	sort.Slice(keys, func(i, j int) bool {
		return keys[i].Before(keys[j])
	})

	initializeService(keys, plugins, globalOutbox)

	// Start the server
	slog.Info("Starting server on " + config.Global.IP + " with ports " + config.Global.HTTPPort + " and " + config.Global.HTTPSPort)
	go func() {
		// Create the TLS server
		server := &http.Server{
			Handler: http.HandlerFunc(hostRouter),
			Addr:    config.Global.IP + ":" + config.Global.HTTPSPort,
			TLSConfig: &tls.Config{
				GetCertificate: getTLSCertificate,
			},
		}

		// Start the TLS server
		err = server.ListenAndServeTLS("", "")
		slog.Error("Error starting HTTPS server: " + err.Error())
		os.Exit(1)
	}()

	// Start the HTTP server
	err = http.ListenAndServe(config.Global.IP+":"+config.Global.HTTPPort, http.HandlerFunc(hostRouter))
	slog.Error("Error starting server: " + err.Error())
	os.Exit(1)
}