package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"syscall"

	"git.send.nrw/sendnrw/raccws/racc_common"
	"git.send.nrw/sendnrw/raccws/racc_filebrowser"
	"git.send.nrw/sendnrw/raccws/racc_httpstatus"
	"git.send.nrw/sendnrw/raccws/racc_logging"
	"git.send.nrw/sendnrw/raccws/racc_middleware"
	"git.send.nrw/sendnrw/raccws/racc_session"
	"git.send.nrw/sendnrw/raccws/racc_sysauth"
	"git.send.nrw/sendnrw/raccws/racc_template"
)

var DefaultAppPath string = "/"
var DefaultLogNumber int = 500

var CORE_SESSIONFILE string = "serversessions.json"
var CORE_SERVERLOG string = "serverlog.json"
var CORE_RELPATH string = "./"

func DefaultRoute(w http.ResponseWriter, r *http.Request) {
	//fmt.Println(r.URL.Path)
	if r.URL.Path == "/" {
		http.Redirect(w, r, DefaultAppPath, http.StatusMovedPermanently)
	}
	fileInfo, err := os.Stat(CORE_RELPATH + r.URL.Path)
	if os.IsNotExist(err) {
		racc_httpstatus.Default404(w, r)
		return
	}
	if !fileInfo.IsDir() {
		http.ServeFile(w, r, CORE_RELPATH+r.URL.Path)
		return
	} else {
		racc_httpstatus.Default404(w, r)
		return
	}

}

func prepareExit() {
	fmt.Println("Running exit tasks...")
	// Hier können Sie Ihre Aufräumarbeiten ausführen
	SaveFile(CORE_SESSIONFILE, &racc_session.SessionStore)
	SaveFile(CORE_SERVERLOG, racc_logging.GetLastXitems(DefaultLogNumber))
	fmt.Println("Exit completed.")
}

func main() {
	/*  */
	//app_adinfo.MakeDefault()
	/*  */
	/*server_port := flag.String("port", "8080", "Port to be used for http server")
	server_mode := flag.String("mode", "http", "Security mode the server should run (http/https)")
	server_tls_key := flag.String("key", "private.key", "Private key file")
	server_tls_cert := flag.String("cert", "public.crt", "Public cert file")
	flag.Parse()*/

	HTTP_PORT := racc_common.GetENV("HTTP_PORT", "8080")
	HTTP_TLS := racc_common.GetENV("HTTP_TLS", "0")
	HTTP_TLS_PRIVATEKEY := racc_common.GetENV("HTTP_TLS_PRIVATEKEY", "")
	HTTP_TLS_CERTIFICATE := racc_common.GetENV("HTTP_TLS_CERTIFICATE", "")

	CORE_SESSIONFILE = racc_common.GetENV("CORE_SESSIONFILE", "serversessions.json")
	CORE_SERVERLOG = racc_common.GetENV("CORE_SERVERLOG", "serverlog.json")
	CORE_RELPATH = racc_common.GetENV("CORE_RELPATH", "./")

	/* Print actual settings */
	fmt.Println("----------")
	fmt.Println("Service configured with settings:")
	fmt.Println("----------")
	fmt.Println("HTTP-PORT: "+HTTP_PORT, "HTTP_TLS: "+HTTP_TLS, "HTTP_TLS_PRIVATEKEY: "+HTTP_TLS_PRIVATEKEY, "HTTP_TLS_CERTIFICATE: "+HTTP_TLS_CERTIFICATE)
	fmt.Println("CORE_SESSIONFILE: "+CORE_SESSIONFILE, "CORE_SERVERLOG: "+CORE_SERVERLOG, "CORE_RELPATH: "+CORE_RELPATH)
	fmt.Println("----------")

	// Signal-Kanal einrichten
	stop := make(chan os.Signal, 1)
	signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)

	// Goroutine, die auf Signale wartet
	go func() {
		<-stop
		fmt.Println("Received stop signal")
		prepareExit()
		os.Exit(0)
	}()

	// Hauptprogramm
	fmt.Println("Program is running. Press Ctrl+C to exit.")

	/* Load Infrastructure */
	/* Load Server-Log */
	LoadFile(CORE_SERVERLOG, &racc_logging.LogBook)
	/* Load Session-Data */
	LoadFile(CORE_SESSIONFILE, &racc_session.SessionStore)

	/* Router-Definition */
	mainRouter := http.NewServeMux()
	defaultRouter := http.NewServeMux()
	apiRouter := http.NewServeMux()
	portalRouter := http.NewServeMux()
	//adminRouter := http.NewServeMux()
	userRouter := http.NewServeMux()

	/* Main-Router-Middleware */
	mainMiddlewareStack := racc_middleware.CreateStack(
		racc_session.SessionMiddleware,
	)

	/* Admin-Router-Middleware */
	defaultMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)
	apiMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging, racc_sysauth.BearerAuthMiddleware("auth_bearer.json"))
	portalMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging, racc_template.RenderApplicationTemplate("html-templates/application_1.html", nil))
	//adminMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging, racc_sysauth.BasicAuthMiddleware("auth_basic_admin.json"))
	userMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)
	//appDemoMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)
	appFileMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)
	//appDynDNSMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)

	/* Main-Router-Routen */
	mainRouter.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
	mainRouter.Handle("/api/", apiMiddlewareStack(http.StripPrefix("/api", apiRouter)))
	mainRouter.Handle("/portal/", portalMiddlewareStack(http.StripPrefix("/portal", portalRouter)))
	//mainRouter.Handle("/admin/", adminMiddlewareStack(http.StripPrefix("/admin", app_admin.Main())))
	mainRouter.Handle("/user/", userMiddlewareStack(http.StripPrefix("/user", userRouter)))
	//mainRouter.Handle("/demo/", appDemoMiddlewareStack(http.StripPrefix("/demo", app_demo.Main())))
	mainRouter.Handle("/files/", appFileMiddlewareStack(http.StripPrefix("/files", racc_filebrowser.Router())))
	//mainRouter.Handle("/dns/", appDynDNSMiddlewareStack(http.StripPrefix("/dns", app_dyndns.Main())))

	/* Default-Route (Should stay here forever) */
	mainRouter.Handle("/", defaultMiddlewareStack(http.StripPrefix("", defaultRouter)))
	defaultRouter.HandleFunc("/", DefaultRoute)

	/* Sub-Router-Routen */
	//adminRouter.HandleFunc("/sessions", app_admin.adminSessionHandler)
	apiRouter.HandleFunc("/", HttpSaveFile(CORE_SERVERLOG, &racc_logging.LogBook))
	/*  */
	server := http.Server{
		Addr:    ":" + HTTP_PORT,
		Handler: mainMiddlewareStack(mainRouter),
	}

	/*  */
	fmt.Println("Server listening on port :" + HTTP_PORT)
	if HTTP_TLS == "0" {
		fmt.Println("Protocol is http (insecure)")
		StopServer(server.ListenAndServe())
	}
	if HTTP_TLS == "1" {
		fmt.Println("Protocol is https (secure)")
		StopServer(server.ListenAndServeTLS(HTTP_TLS_CERTIFICATE, HTTP_TLS_PRIVATEKEY))
	}

}

func StopServer(e error) {
	fmt.Println("Stopping server...")
	prepareExit()
	fmt.Println("Server stopped!")
}

func HttpSaveFile(xfile string, a any) racc_httpstatus.App {
	return func(next_w http.ResponseWriter, next_r *http.Request) {
		file, _ := os.Create(xfile)
		encoder := json.NewEncoder(file)
		err := encoder.Encode(a)
		if err != nil {
			fmt.Println("Error encoding JSON:", err)
		}
		file.Close()
	}
}

func SaveFile(xfile string, a any) {
	file, _ := os.Create(xfile)
	encoder := json.NewEncoder(file)
	err := encoder.Encode(a)
	if err != nil {
		fmt.Println("Error encoding JSON:", err)
	}
	file.Close()
	fmt.Println("Saved content to: ", xfile)
}

func HttpLoadFile(xfile string, a any) racc_httpstatus.App {
	return func(next_w http.ResponseWriter, next_r *http.Request) {
		if _, err := os.Stat(xfile); os.IsNotExist(err) {
			fmt.Println("Speicherdatei nicht gefunden, neue Map wird erstellt")
		} else {
			file, _ := os.Open(xfile)
			decoder := json.NewDecoder(file)
			err := decoder.Decode(a)
			if err != nil {
				fmt.Println("Fehler in JSON-Datei:", err)
			}
			file.Close()
		}
	}
}

func LoadFile(xfile string, a any) {
	if _, err := os.Stat(xfile); os.IsNotExist(err) {
		fmt.Println("Speicherdatei nicht gefunden, neue Map wird erstellt")
	} else {
		file, _ := os.Open(xfile)
		decoder := json.NewDecoder(file)
		err := decoder.Decode(a)
		if err != nil {
			fmt.Println("Fehler in JSON-Datei:", err)
		}
		file.Close()
	}
	fmt.Println("Loaded content from: ", xfile)
}