package main

import (
	"context"
	"errors"
	"log"
	"os"

	"personalwebsite/apps"
	blogwriter "personalwebsite/apps/BlogWriter"
	"personalwebsite/apps/blogviewer"
	"personalwebsite/apps/finder"
	imgviewer "personalwebsite/apps/img-viewer"
	"personalwebsite/apps/personalprops"
	"personalwebsite/routes"
	"personalwebsite/wde"
	"personalwebsite/webfilesystem"

	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

func main() {
	if err := godotenv.Load(); err != nil {
		println("No .env file found")
	}

	mongoConnect, err := FindEnv("MONGO_CONNECT")
	if err != nil {
		panic(err.Error())
	}

	dBName, err := FindEnv("DATABASE")
	if err != nil {
		panic(err.Error())
	}

	webFsCollection, err := FindEnv("COLLECTION_WEBFS")
	if err != nil {
		panic(err.Error())
	}

	clientOptions := options.Client().ApplyURI(mongoConnect)
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = client.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}

	webfs := webfilesystem.NewWebFileSystem(client, dBName, webFsCollection)
	appsStorage := apps.NewApplicationsStorage(map[string]apps.WebDEApplication{}, webfs)
	// router := gin.New()
	// router.Use(location.Default())
	// router.LoadHTMLGlob("templates/**/*")
	// router.Static("/res", "resources")
	// // Set a lower memory limit for multipart forms (default is 32 MiB)
	// router.MaxMultipartMemory = 8 << 20 // 8 MiB

	// router.GET("/", func(ctx *gin.Context) {
	// 	ctx.HTML(http.StatusOK, "index.tmpl", gin.H{})
	// })

	webde := wde.NewWDE(webfs)

	//TODO Split to different apps init for private and public?
	persPropsApp := personalprops.NewPersPropsApp(webfs)
	finderApp := finder.NewFinderApplication(webfs)
	imgViewerApp := imgviewer.NewImgViewerApp(webfs)
	blogViewerApp := blogviewer.NewBlogViewerApp(webfs)
	blogWriterApp := blogwriter.NewBlogWriterApp(webfs)
	appsStorage.Apps["personal-properties"] = persPropsApp
	appsStorage.Apps["finder"] = finderApp
	appsStorage.Apps["img-viewer"] = imgViewerApp
	appsStorage.Apps[blogViewerApp.GetAppID()] = blogViewerApp
	appsStorage.Apps["BlogWriter"] = blogWriterApp

	go routes.PublicRoutes(webfs, webde, appsStorage)
	routes.PrivateRoutes(webfs, webde, appsStorage)

	// system := router.Group("system")
	// {
	// 	libsGroup := system.Group("libs")
	// 	{
	// 		imgLibGroup := libsGroup.Group("img")
	// 		{
	// 			imgLib := libs.NewImgLib(webfs)
	// 			imgLib.PublicRoutes(imgLibGroup)
	// 		}

	// 		catLibGroup := libsGroup.Group("cat")
	// 		{
	// 			catLib := libs.NewCatLib(webfs)
	// 			catLib.PublicRoutes(catLibGroup)
	// 		}

	// 		appsStorageGroup := libsGroup.Group("apps")
	// 		{
	// 			appsStorage.Route(appsStorageGroup)
	// 		}
	// 	}

	// 	wdeGroup := system.Group("wde")
	// 	{
	// 		routewde.PublicRoutes(wdeGroup, webde)
	// 	}
	// 	apps := system.Group("applications") //TODO to libs
	// 	{
	// 		apps.GET("/:appid/:method", func(ctx *gin.Context) {
	// 			appId := ctx.Param("appid")
	// 			method := ctx.Param("method")

	// 			app, isExist := appsStorage.Apps[appId]
	// 			if !isExist {
	// 				ctx.Status(http.StatusNoContent)
	// 				return
	// 			}
	// 			switch method {
	// 			case "getmanifest":
	// 				ctx.JSON(http.StatusOK, app.GetManifest())
	// 			case "app.js":
	// 				ctx.File("resources/sys/" + appId + "/" + appId + ".js")
	// 			case "app.css":
	// 				ctx.File("resources/sys/" + appId + "/" + appId + ".css")
	// 			default:
	// 				ctx.Status(http.StatusBadRequest)
	// 			}
	// 		})
	// 	}
	// }

	// fs := router.Group("fs")
	// {
	// fsGroup := systemGroup.Group("fs")
	// {
	// 	webfs.PublicRoutes(fsGroup)
	// }
	// }
	// app := router.Group("app")
	// {
	// 	persPropApp := app.Group("AboutMe")
	// 	{
	// 		persPropsApp.Route(persPropApp)
	// 	}
	// 	finderAppRoute := app.Group("Finder")
	// 	{
	// 		finderApp.Routes(finderAppRoute)
	// 	}
	// 	imgViewerRoute := app.Group("img-viewer")
	// 	{
	// 		imgViewerApp.Route(imgViewerRoute)
	// 	}
	// 	blogViewerRoute := app.Group("blog-viewer")
	// 	{
	// 		blogViewerApp.Route(blogViewerRoute)
	// 	}

	// 	router.Use(cors.New(cors.Config{
	// 		AllowAllOrigins: true,
	// 		// AllowOrigins:     []string{"http://localhost:8080", "http://localhost:9090"},
	// 		// AllowMethods:     []string{"PUT", "PATCH"},
	// 		// AllowHeaders:     []string{"Origin"},
	// 		ExposeHeaders:    []string{"Content-Length"},
	// 		AllowCredentials: true,
	// 		// AllowOriginFunc: func(origin string) bool {
	// 		// 	return origin == "https://github.com"
	// 		// },
	// 		MaxAge: 12 * time.Hour,
	// 	}))
	// 	err = router.Run(":8080")
	// 	if err != nil {
	// 		log.Panicf("error: %s", err)
	// 	}
	// }
}

// func index(c *gin.Context) {
// 	c.HTML(http.StatusOK, "base.html", nil)
// }

func FindEnv(parameter string) (string, error) {
	path, exists := os.LookupEnv(parameter)

	if exists {
		println("[ENV] Requsted " + parameter + " = " + path) //FIXME Only in Debug log
		return path, nil
	} else {
		panic("[ENV] Requsted " + parameter + " not found")
		return "", errors.New("env parameter not found")
	}
}