package api_handlers

import (
	"context"
	"net/http"
	"sort"

	"git.agecem.com/agecem/agecem-org/config"
	"git.agecem.com/agecem/agecem-org/media"
	"git.agecem.com/agecem/agecem-org/models"
	"github.com/labstack/echo/v4"
	"github.com/minio/minio-go/v7"
	"github.com/spf13/viper"
)

// API Handlers

// HandleV1 affiche les routes accessibles.
// Les routes sont triées selon .Path, pour les rendre plus facilement navigables.
func HandleV1(c echo.Context) error {
	routes := c.Echo().Routes()
	sort.Slice(routes, func(i, j int) bool { return routes[i].Path < routes[j].Path })
	return c.JSON(http.StatusOK, routes)
}

// HandleV1Seed créé des buckets dans minio selon la liste de buckets dans server.documents.buckets
// Les buckets sont créés avec paramètres par défaut, et sont ensuite visible dans /v1/bucket.
func HandleV1Seed(c echo.Context) error {
	var response models.V1SeedResponse

	mediaClient, err := media.NewMediaClientFromViper()
	if err != nil {
		response.StatusCode = http.StatusInternalServerError
		response.Message = "Error during media.NewMediaClientFromViper()"
		response.Error = err.Error()

		return c.JSON(response.StatusCode, response)
	}

	new_buckets, err := mediaClient.Seed()
	response.Data.Buckets = new_buckets
	if err != nil {
		response.StatusCode = http.StatusInternalServerError
		response.Message = "Error during mediaClient.Seed()"
		response.Error = err.Error()

		return c.JSON(response.StatusCode, response)
	}

	if len(new_buckets) == 0 {
		response.Message = "All buckets already exist"

	} else {
		response.Message = "Buckets successfully created"
	}

	response.StatusCode = http.StatusOK

	return c.JSON(response.StatusCode, response)
}

// HandleV1BucketList affiche les buckets permis par server.documents.buckets, qui existent.
func HandleV1BucketList(c echo.Context) error {
	var response models.V1BucketListResponse

	var cfg config.Config
	if err := viper.Unmarshal(&cfg); err != nil {
		response.StatusCode = http.StatusInternalServerError
		response.Message = "Error during viper.Unmarshal"
		// response.Error = err.Error()

		return c.JSON(response.StatusCode, response)
	}

	mediaClient, err := media.NewMediaClientFromViper()
	if err != nil {
		response.StatusCode = http.StatusInternalServerError
		response.Message = "Error during media.NewMediaClientFromViper()"
		// response.Error = err.Error()

		return c.JSON(response.StatusCode, response)
	}

	var buckets = make(map[string]string)

	for bucket_name, bucket_display_name := range cfg.Server.Documents.Buckets {
		exists, err := mediaClient.MinioClient.BucketExists(context.Background(), bucket_name)
		if err != nil {
			response.StatusCode = http.StatusInternalServerError
			response.Message = "Error during minio#BucketExists"
			// response.Error = err.Error()

			return c.JSON(response.StatusCode, response)
		}

		if exists {
			buckets[bucket_name] = bucket_display_name
		}
	}

	response.StatusCode = http.StatusOK
	response.Message = "Buckets list successful"
	response.Data.Buckets = buckets

	return c.JSON(response.StatusCode, response)
	//return c.JSON(response.StatusCode, response.Data.Buckets)
}

func HandleV1BucketRead(c echo.Context) error {
	var response models.V1BucketReadResponse

	var cfg config.Config
	if err := viper.Unmarshal(&cfg); err != nil {
		response.StatusCode = http.StatusInternalServerError
		response.Error = err.Error()

		return c.JSON(response.StatusCode, response)
	}

	bucket := c.Param("bucket")

	allowed := false
	for bucket_allowed := range cfg.Server.Documents.Buckets {
		if bucket == bucket_allowed {
			allowed = true
		}
	}

	if !allowed {
		/* TODO models.NotFoundResponse
		response.StatusCode = http.StatusNotFound
		response.Message = "Not Found"

		return c.JSON(response.StatusCode, response)
		*/
		return c.JSON(http.StatusNotFound, map[string]string{"message": "Not Found"})
	}

	ctx, cancel := context.WithCancel(context.Background())

	defer cancel()

	mediaClient, err := media.NewMediaClientFromViper()
	if err != nil {
		response.StatusCode = http.StatusInternalServerError
		response.Message = "Error during media.NewMediaClientFromViper()"
		response.Error = err.Error()

		return c.JSON(response.StatusCode, response)
	}

	exists, err := mediaClient.MinioClient.BucketExists(ctx, bucket)
	if err != nil {
		response.StatusCode = http.StatusInternalServerError
		response.Message = "Error during minio#BucketExists"
		response.Error = err.Error()

		return c.JSON(response.StatusCode, response)
	}

	if !exists {
		// TODO models.NotFoundResponse
		return c.JSON(http.StatusNotFound, map[string]string{"message": "Not Found"})
	}

	objectCh := mediaClient.MinioClient.ListObjects(ctx, bucket, minio.ListObjectsOptions{})
	for object := range objectCh {
		if object.Err != nil {
			response.StatusCode = http.StatusInternalServerError
			response.Message = "Error during minio#ListObjects"
			//TODO make sure this is safe
			//response.Error = object.Err.Error()

			return c.JSON(response.StatusCode, response)
		}

		response.Data.Keys = append(response.Data.Keys, object.Key)
	}

	response.StatusCode = http.StatusOK
	response.Message = "V1BucketRead ok"

	return c.JSON(response.StatusCode, response)
}

// HandleV1DocumentCreate permet d'ajouter un object dans un bucket, par multipart/form-data
func HandleV1DocumentCreate(c echo.Context) error {
	var cfg config.Config
	if err := viper.Unmarshal(&cfg); err != nil {
		return c.JSON(http.StatusInternalServerError, map[string]string{
			"error": err.Error(),
		})
	}

	bucket := c.Param("bucket")

	form_file, err := c.FormFile("document")
	if err != nil {
		return c.JSON(http.StatusBadRequest, map[string]interface{}{
			"message": "Error during HandleV1DocumentCreate's echo#Context.FormFile",
			"error":   err,
		})
	}

	allowed := false
	for bucket_allowed := range cfg.Server.Documents.Buckets {
		if bucket == bucket_allowed {
			allowed = true
		}
	}

	if !allowed {
		return c.JSON(http.StatusNotFound, map[string]string{"message": "Not Found"})
	}

	ctx, cancel := context.WithCancel(context.Background())

	defer cancel()

	mediaClient, err := media.NewMediaClientFromViper()
	if err != nil {
		return c.JSON(http.StatusInternalServerError, map[string]string{
			"message": "Error during media.NewMediaClientFromViper()",
			"error":   err.Error(),
		})
	}

	src, err := form_file.Open()
	if err != nil {
		return err
	}
	defer src.Close()

	/*
		reg, err := regexp.Compile("[^.a-zA-Z0-9_-]+")
		if err != nil {
			return c.Render(http.StatusInternalServerError, "documentation-html", nil)
		}

		filename_processed := reg.ReplaceAllString(form_file.Filename, "")
	*/

	info, err := mediaClient.MinioClient.PutObject(ctx, bucket, form_file.Filename, src, form_file.Size, minio.PutObjectOptions{
		ContentType: form_file.Header.Get("Content-Type"),
	})
	if err != nil {
		return c.JSON(http.StatusInternalServerError, map[string]string{
			"message": "Error during minio#PutObject",
		})
	}

	return c.JSON(http.StatusOK, map[string]interface{}{
		"message": "ok",
		"info": map[string]interface{}{
			"bucket": info.Bucket,
			"key":    info.Key,
			"size":   info.Size,
		},
	})
}

// HandleV1DocumentRead permet de lire le contenu d'un fichier et protentiellement de le télécharger
func HandleV1DocumentRead(c echo.Context) error {
	var cfg config.Config
	if err := viper.Unmarshal(&cfg); err != nil {
		return c.JSON(http.StatusInternalServerError, map[string]string{
			"error": err.Error(),
		})
	}

	bucket := c.Param("bucket")
	document := c.Param("document")

	allowed := false
	for bucket_allowed := range cfg.Server.Documents.Buckets {
		if bucket == bucket_allowed {
			allowed = true
		}
	}

	if !allowed {
		return c.JSON(http.StatusNotFound, map[string]string{"message": "Not Found"})
	}

	ctx, cancel := context.WithCancel(context.Background())

	defer cancel()

	mediaClient, err := media.NewMediaClientFromViper()
	if err != nil {
		return c.JSON(http.StatusInternalServerError, map[string]string{
			"message": "Error during media.NewMediaClientFromViper()",
			"error":   err.Error(),
		})
	}

	bucket_exists, err := mediaClient.MinioClient.BucketExists(ctx, bucket)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, "Error during minio#BucketExists")
	}

	if !bucket_exists {
		return c.JSON(http.StatusNotFound, map[string]string{"message": "Not Found"})
	}

	document_info, err := mediaClient.MinioClient.StatObject(ctx, bucket, document, minio.StatObjectOptions{})

	if err != nil {
		if err.Error() == "The specified key does not exist." {

			return c.JSON(http.StatusNotFound, map[string]string{"message": "Not Found"})
		}

		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
			"message": "Error during minio#StatObject",
		})
	}

	_ = document_info

	document_object, err := mediaClient.MinioClient.GetObject(ctx, bucket, document, minio.GetObjectOptions{})
	if err != nil {
		return c.JSON(http.StatusInternalServerError, map[string]string{
			"message": "Error during minio#GetObject",
		})
	}

	defer document_object.Close()

	return c.Stream(http.StatusOK, document_info.ContentType, document_object)
}

// HandleV1DocumentUpdate permet de mettre à jour certains champs d'un object, comme le Content-Type ou le Filename
func HandleV1DocumentUpdate(c echo.Context) error {
	return c.JSON(http.StatusNotImplemented, map[string]string{
		"message": "Not Implemented",
	})
}

// HandleV1DocumentDelete permet de supprimer un object
func HandleV1DocumentDelete(c echo.Context) error {
	var cfg config.Config
	if err := viper.Unmarshal(&cfg); err != nil {
		return c.JSON(http.StatusInternalServerError, map[string]string{
			"error": err.Error(),
		})
	}
	bucket := c.Param("bucket")
	document := c.Param("document")

	allowed := false
	for bucket_allowed := range cfg.Server.Documents.Buckets {
		if bucket == bucket_allowed {
			allowed = true
		}
	}

	if !allowed {
		/*
			return c.JSON(http.StatusBadRequest, map[string]string{
				"message": "Bucket is not allowed in server.documents.buckets",
			})
		*/
		return c.JSON(http.StatusNotFound, map[string]string{"message": "Not Found"})
	}

	ctx, cancel := context.WithCancel(context.Background())

	defer cancel()

	mediaClient, err := media.NewMediaClientFromViper()
	if err != nil {
		return c.JSON(http.StatusInternalServerError, map[string]string{
			"message": "Error during media.NewMediaClientFromViper()",
			"error":   err.Error(),
		})
	}

	bucket_exists, err := mediaClient.MinioClient.BucketExists(ctx, bucket)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, "Error during minio#BucketExists")
	}

	if !bucket_exists {
		return c.JSON(http.StatusNotFound, map[string]string{"message": "Not Found"})
	}

	document_info, err := mediaClient.MinioClient.StatObject(ctx, bucket, document, minio.StatObjectOptions{})
	if err != nil {
		if err.Error() == "The specified key does not exist." {

			return c.JSON(http.StatusNotFound, map[string]string{"message": "Not Found"})
		}

		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
			"message": "Error during minio#StatObject",
		})
	}

	//TODO Add error validation
	_ = document_info

	err = mediaClient.MinioClient.RemoveObject(ctx, bucket, document, minio.RemoveObjectOptions{})
	if err != nil {
		return c.JSON(http.StatusInternalServerError, map[string]string{
			"message": "Error during minio#RemoveObject",
		})
	}

	return c.JSON(http.StatusOK, map[string]string{
		"message": "Document deleted",
	})
}