package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"net/http"
	"os"
	"personalwebsite/fileuploading"
	"personalwebsite/routewde"
	"personalwebsite/wde"
	"personalwebsite/webfilesystem"
	"personalwebsite/websiteapp"
	"personalwebsite/websiteapp/blogviewer"
	"personalwebsite/websiteapp/finder"
	imgviewer "personalwebsite/websiteapp/img-viewer"
	"personalwebsite/websiteapp/personalprops"

	"github.com/gin-gonic/gin"
	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"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)
	}

	router := gin.New()
	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{})
	})

	webfs := webfilesystem.NewWebFileSystem(client, dBName, webFsCollection)
	webde := wde.NewWDE(webfs)
	fileUploading := fileuploading.NewFileUploading(webfs)

	persPropsApp := personalprops.NewPersPropsApp(webfs)
	// finderApp := finder.FinderApplication{}
	finderApp := finder.NewFinderApplication(webfs)
	imgViewerApp := imgviewer.NewImgViewerApp(webfs)
	blogViewerApp := blogviewer.NewBlogViewerApp(webfs)
	appsStorage := websiteapp.ApplicationsStorage{
		Apps: map[string]websiteapp.WebDEApplication{},
	}
	appsStorage.Apps["personal-properties"] = &persPropsApp
	appsStorage.Apps["finder"] = finderApp
	appsStorage.Apps["img-viewer"] = &imgViewerApp
	appsStorage.Apps["blog-viewer"] = blogViewerApp

	router.POST("/upload", func(c *gin.Context) {
		// single file
		file, _ := c.FormFile("file")
		// log.Println(file.Filename)

		// Upload the file to specific dst.
		dst := "./test-img/" + file.Filename
		c.SaveUploadedFile(file, dst)

		fileUploading.CreateMiniatures("./test-img/", file.Filename)

		// webfs.CreateFile(&img, "/home/user/")

		c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
	})

	router.GET("/testimg", func(c *gin.Context) {

		// c.Data(200, "image/jpeg", data)
	})

	system := router.Group("system")
	{
		imgLibGroup := system.Group("imglib")
		{
			imgLibGroup.GET("get", func(ctx *gin.Context) {
				path := ctx.Query("path")
				if path == "" {
					ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
					return
				}
				min := ctx.Query("min")

				file, err := webfs.Read(path)
				if err != nil {
					ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
					return
				}

				img, err := wde.ReadImage(file)
				if err != nil {
					ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
					return
				}

				if min == "min32" {
					ctx.Data(http.StatusOK, "image/jpeg", []byte(img.Miniature32))
				} else {
					ctx.Data(http.StatusOK, "image/jpeg", []byte(img.Data))
				}

			})
		}
		wdeGroup := system.Group("wde")
		{
			routewde.Route(wdeGroup, webde)
		}
		apps := system.Group("applications")
		{
			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)
				}
			})
		}

		websiteapp.Route(apps.Group("/storage"), &appsStorage)
	}

	fs := router.Group("fs")
	{
		fs.GET("writeFile", func(ctx *gin.Context) {
			parentPath := ctx.Query("parentPath")
			if parentPath == "" {
				ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
				return
			}
			file := webfilesystem.WebFSFile{
				MongoId: primitive.NewObjectID(),
				Name:    "pp",
				Type:    "test",
				Data:    nil,
			}
			err := webfs.CreateFile(&file, parentPath)
			if err != nil {
				ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
				return
			}

			ctx.JSON(http.StatusOK, "OK")
		})
		fs.GET("createDir", func(ctx *gin.Context) {
			path := ctx.Query("path")
			if path == "" {
				ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
				return
			}

			err := webfs.CreateDirectory(path)
			if err != nil {
				ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
				return
			}

			ctx.JSON(http.StatusOK, "OK")
		})

		fs.GET("list", func(ctx *gin.Context) {
			path := ctx.Query("path")
			if path == "" {
				ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
				return
			}

			files, err := webfs.List(path)
			if err != nil {
				ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
				return
			}

			ctx.JSON(http.StatusOK, &files)
		})

		fs.GET("read", func(ctx *gin.Context) {
			path := ctx.Query("path")
			if path == "" {
				ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
				return
			}

			file, err := webfs.Read(path)
			if err != nil {
				ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
				return
			}

			ctx.JSON(http.StatusOK, &file)
		})
	}
	app := router.Group("application")
	{
		persPropApp := app.Group("personal-properties")
		{
			persPropApp.GET("render", func(ctx *gin.Context) {
				isMobileParam := ctx.Query("isMobile")
				isMobile := isMobileParam == "true"
				ginH, err := persPropsApp.Render()
				if err != nil {
					ctx.JSON(http.StatusInternalServerError, "TODO") //TODO
				}
				if isMobile {
					ctx.HTML(http.StatusOK, "personal-properties/mobile-app.tmpl", ginH)
				} else {
					ctx.HTML(http.StatusOK, "personal-properties/app.tmpl", ginH)
				}
			})
		}
		finderAppRoute := app.Group("finder")
		{
			finderAppRoute.GET("render", func(ctx *gin.Context) {
				isMobileParam := ctx.Query("isMobile")
				isMobile := isMobileParam == "true"
				if isMobile {
					ctx.HTML(http.StatusOK, "finder/mobile-app.tmpl", finderApp.Render(isMobile))
				} else {
					ctx.HTML(http.StatusOK, "finder/app.tmpl", finderApp.Render(isMobile))
				}

			})
			finderAppRoute.GET("renderMobileDesktop", func(ctx *gin.Context) {
				ctx.HTML(http.StatusOK, "finder/mobile-desktop.tmpl", gin.H{})
			})
			finderAppRoute.GET("renderDesktop", func(ctx *gin.Context) {
				path := ctx.Query("path")
				if path == "" {
					ctx.JSON(http.StatusBadRequest, "no path provided")
					return
				}
				ctx.HTML(http.StatusOK, "finder/desktop.tmpl", gin.H{})
			})
		}
		imgViewerRoute := app.Group("img-viewer")
		{
			imgViewerRoute.GET("render", func(ctx *gin.Context) {
				isMobileParam := ctx.Query("isMobile")
				isMobile := isMobileParam == "true"
				path := ctx.Query("path")
				if path == "" {
					ctx.JSON(http.StatusBadRequest, "no path provided")
					return
				}
				ginH, err := imgViewerApp.Render(path, isMobile)
				if err != nil {
					ctx.JSON(http.StatusInternalServerError, "TODO")
					return
				}
				if isMobile {
					ctx.HTML(http.StatusOK, "img-viewer/mobile-app.tmpl", ginH)
				} else {
					ctx.HTML(http.StatusOK, "img-viewer/app.tmpl", ginH)
				}

			})
		}
		blogViewerRoute := app.Group("blog-viewer")
		{
			blogViewerRoute.GET("writeMockBlog", func(ctx *gin.Context) {
				path := ctx.Query("path")
				if path == "" {
					ctx.JSON(http.StatusBadRequest, "no path provided")
					return
				}
				blogViewerApp.WriteMock(path)
				ctx.JSON(http.StatusOK, "OK")
			})

			blogViewerRoute.GET("render", func(ctx *gin.Context) {
				isMobileParam := ctx.Query("isMobile")
				path := ctx.Query("path")
				if path == "" {
					ctx.JSON(http.StatusBadRequest, "no path provided")
					return
				}

				isMobile := isMobileParam == "true"
				ginH, err := blogViewerApp.Render(path, isMobile)
				if err != nil {
					ctx.JSON(http.StatusInternalServerError, "TODO")
					return
				}

				if isMobile {
					ctx.HTML(http.StatusOK, "blog-viewer/mobile-app.tmpl", ginH)
				} else {
					ctx.HTML(http.StatusOK, "blog-viewer/app.tmpl", ginH)
				}

			})
		}
	}
	router.GET("/test", func(ctx *gin.Context) {
		ctx.HTML(200, "kek/kek.tmpl", gin.H{})
	})

	if err := router.Run(":8080"); 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")
	}
}