package routes

import (
	"errors"
	"log/slog"
	"net/http"
	"orbits-server/internal/server/api/response"
	"orbits-server/internal/server/bootstrap"
	"orbits-server/internal/server/database"
	"path/filepath"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

func RegisterFileRoutes(file *gin.RouterGroup, env bootstrap.Environment, db *gorm.DB) {
	// prefix: file
	// for example: /file/<file-name>

	// file download route / display contents
	file.GET("/:filename", func(c *gin.Context) {
		fileParam := c.Param("filename")
		p := filepath.Join(env.ContentDirectory, fileParam)

		c.File(p)
	})

	// upload route
	file.POST("/upload", func(c *gin.Context) {
		f, err := c.FormFile("file")
		if err != nil {
			slog.Debug("no file or file headers provided on the request", "error", err)
			c.JSON(http.StatusBadRequest, response.BasicResponse{
				Msg: "a file is required",
			})
			return
		}

		readerStream, err := f.Open()
		if err != nil {
			slog.Error("failed to a reader stream")
			c.JSON(http.StatusInternalServerError, response.BasicResponse{
				Msg: response.IntErrMes,
			})
			return
		}
		defer readerStream.Close()

		fileRecord, err := database.BuildFileRecord(readerStream, f.Filename, env.ContentDirectory)
		if err != nil {
			slog.Error("failed to enroll file to the database", "error", err)
			c.JSON(http.StatusInternalServerError, response.BasicResponse{
				Msg: response.IntErrMes,
			})
			return
		}

		if err := database.CreateFile(db, &fileRecord); err != nil {
			if errors.Is(err, gorm.ErrDuplicatedKey) {
				slog.Debug("discarding file, its a checksum duplicate", "error", err)
				c.JSON(http.StatusConflict, response.BasicResponse{
					Msg: "file already exists",
				})
			} else {
				// log the failure to the std
				slog.Error("failed to insert filedata to the database", "error", err)
				c.JSON(http.StatusInternalServerError, response.BasicResponse{
					Msg: response.IntErrMes,
				})
			}
			return
		}

		// save to filesystem after everything has given a green light
		if err := c.SaveUploadedFile(f, fileRecord.FilePath); err != nil {
			slog.Error("failed to save to disk, rolling back database", "error", err)

			// rollback db if the write has failed
			err = database.DeleteFileByID(db, fileRecord.ID)
			if err != nil {
				slog.Error("failed to remove the database record", "error", err)
			}

			// give the response to the client
			c.JSON(http.StatusInternalServerError, response.BasicResponse{
				Msg: response.IntErrMes,
			})
			return
		}
		slog.Info("saved file to local filesystem and database")

		c.JSON(http.StatusCreated, response.BasicResponse{
			Msg:  "file has succesfully been uploaded",
			Data: fileRecord,
		})
	})

	// delete route
	file.DELETE("/:filename", func(c *gin.Context) {
		fileParam := c.Param("filename")
		fileRecord, err := database.FindFileByName(db, fileParam)
		if err != nil {
			slog.Error("file not found", "error", err)
			c.JSON(http.StatusNotFound, response.BasicResponse{
				Msg: "file was not found",
			})
			return
		}

		slog.Info("received a delete request for a file", "file", fileRecord, "filename", fileParam)
	})

	// define a route to check what is registered
	file.GET("/available", func(c *gin.Context) {
		files, err := database.ListFiles(db)
		if err != nil {
			slog.Error("failed to retrieve available files", "error", err)
			c.JSON(http.StatusInternalServerError, response.BasicResponse{
				Msg: response.IntErrMes,
			})
			return
		}

		c.JSON(http.StatusOK, response.BasicResponse{
			Msg:  response.OkMes,
			Data: files,
		})
	})
}