package upload

import (
	"clapclap/internal/apperr"
	"clapclap/internal/dtos"
	"clapclap/internal/env"
	"clapclap/internal/ginctx"
	"errors"
	"fmt"
	"strings"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/gin-gonic/gin"
)

func ErrorHandlingWebhook(c *gin.Context) {
	c.Next()

	if c.IsAborted() {
		s3ic, err := ginctx.GetS3(c, "s3-internal")
		if err != nil {
			return
		}

		eventObj, err := ginctx.GetS3EventObj(c, "S3EventObjects")
		if err != nil {
			return
		}

		for _, obj := range eventObj {
			fmt.Println(obj.Key)
			err := DeleteS3Object(c.Request.Context(), s3ic, obj.Bucket, obj.Key)
			if err != nil {
				continue
			}
		}

	}
}

func ErrorHandling(c *gin.Context) {
	c.Next()

	if c.IsAborted() {
		s3ic, err := ginctx.GetS3(c, "s3-internal")
		if err != nil {
			return
		}

		uploadInfos, err := ginctx.GetMedia(c, "uploadInfos")
		if err != nil {
			return
		}

		bucketName := env.C.BUCKET_NAME

		fmt.Println(uploadInfos.ObjKey)
		DeleteS3Object(c.Request.Context(), s3ic, bucketName, uploadInfos.ObjKey)
	}
}

func GetPresignedUploadUrl(c *gin.Context) {
	objectKey := c.GetString("s3ObjectKey")
	if objectKey == "" {
		apperr.AbortWithError(c, apperr.NewInternalServerError(errors.New("GetPresignedUrl: no object key")))
		return
	}

	s3c, err := ginctx.GetS3(c, "s3")
	if err != nil {
		apperr.AbortWithError(c, apperr.NewInternalServerError(err, "Failed to connect to storage service"))
		return
	}

	req, err := ginctx.GetDto[dtos.UploadFile](c)
	if err != nil {
		apperr.AbortWithError(c, apperr.NewValidationError(err))
		return
	}

	postReq, err := GeneratePresignedUrl(c.Request.Context(), req.ContentType, s3c, objectKey)
	if err != nil {
		apperr.AbortWithError(c, apperr.NewInternalServerError(err, "Failed to generate presigned URL"))
		return
	}

	c.Set("presignedUrl", postReq)
}

func GeneratePresignedGetUrl(c *gin.Context) {

	req, _ := ginctx.GetDto[dtos.GetPrivateTrackUploadUrl](c)
	objKey, err := GetObjectKeyFromUrl(req.AudioFile)
	if err != nil {
		apperr.AbortWithError(c, apperr.NewBadRequestError(err, "Not a url"))
	}

	c.Set("objKey", objKey)

	s3c, err := ginctx.GetS3(c, "s3")
	if err != nil {
		apperr.AbortWithError(c, apperr.NewInternalServerError(err, "Failed to connect to storage service"))
		return
	}

	opts := s3c.Options()
	rawEndpoint := *opts.BaseEndpoint
	actualEndpoint := strings.TrimSuffix(rawEndpoint, "/clap")
	opts.BaseEndpoint = &actualEndpoint
	s3c = s3.New(opts)

	// 1. Determine expiration time (reusing your existing env logic)
	urlExpireTime := env.C.PRESIGNED_URL_EXPIRE_TIME_MIN

	input := s3.GetObjectInput{
		Bucket: aws.String(env.C.BUCKET_NAME),
		Key:    aws.String(objKey),
	}

	options := func(opts *s3.PresignOptions) {
		opts.Expires = urlExpireTime
	}

	presigner := s3.NewPresignClient(s3c, options)

	getRequest, err := presigner.PresignGetObject(c.Request.Context(), &input, options)
	if err != nil {
		apperr.AbortWithError(c, apperr.NewInternalServerError(err, "Failed to generate GET presigned URL"))
	}

	url := strings.Replace(getRequest.URL, actualEndpoint, rawEndpoint, 1)

	c.JSON(200, url)
}