package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strconv"
	"time"

	"github.com/gorilla/mux"
	"github.com/joho/godotenv"
	"github.com/minio/minio-go"
)

func main() {
	// Get environment variables
	accessKeyID, secretAccessKey, bucketName, endpoint, port, ssl := getEnv()

	// Initialize MinIO client
	minioClient := new Minio.Client({
    endPoint: endpoint,
    port: port
    accessKey: accessKeyID,
    secretKey: secretAccessKey,
    useSSL: ssl
  })
	if err != nil {
		log.Fatal(err)
	}

	// Create a new router
	router := mux.NewRouter()

	// Define the file handler
	router.HandleFunc("/{path:.*}", func(w http.ResponseWriter, r *http.Request) {
		log.Printf("Received request: %s %s", r.Method, r.RequestURI)
		vars := mux.Vars(r)
		path := vars["path"]

		log.Print("Path: ", path)

		// Get the file from S3
		object, err := minioClient.GetObject(bucketName, path, minio.GetObjectOptions{})
		if err != nil {
			if minio.ToErrorResponse(err).Code == "NoSuchKey" {
				log.Printf("Object not found in S3: %s", err)
				http.Error(w, "Object not found", http.StatusNotFound)
				return
			}
			log.Printf("Error getting object from S3: %s", err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		// Get the object info
		info, err := object.Stat()
		if err != nil {
			if minio.ToErrorResponse(err).Code == "NoSuchKey" {
				log.Printf("Object not found in S3: %s", err)
				http.Error(w, "Object not found", http.StatusNotFound)
				return
			}
			log.Printf("Error getting object info: %s", err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		// Set the content type header
		contentType := info.ContentType
		w.Header().Set("Content-Type", contentType)

		// Copy the file to the response writer
		_, err = io.Copy(w, object)
		if err != nil {
			log.Printf("Error copying file to response writer: %s", err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}).Methods("GET")

	router.Use(loggingMiddleware)

	// Start the server

	if port == "" {
		port = "8080"
	}
	addr := fmt.Sprintf(":%s", port)
	log.Printf("Server listening on %s", addr)
	log.Fatal(http.ListenAndServe(addr, router))
}

func getEnv() (string, string, string, string, string, bool) {
	if os.Getenv("ENVIRONMENT") != "production" {
		err := godotenv.Load()
		if err != nil {
			log.Fatal("Error loading .env file")
		}
	}

	// Get environment variables
	port := os.Getenv("PORT")
	accessKeyID := os.Getenv("S3_ACCESS_KEY_ID")
	secretAccessKey := os.Getenv("S3_SECRET_ACCESS_KEY")
	bucketName := os.Getenv("S3_BUCKET_NAME")
	endpoint := os.Getenv("S3_ENDPOINT_URL")
	ssl, err := strconv.ParseBool(os.Getenv("USE_SSL"))

	if err != nil {
		ssl = true
	}

	return accessKeyID, secretAccessKey, bucketName, endpoint, port, ssl
}

func loggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		startTime := time.Now()

		next.ServeHTTP(w, r)

		duration := time.Since(startTime)
		log.Printf("Processed request: %s %s. Duration: %v\n", r.Method, r.RequestURI, duration)
	})
}

func GetObjectList(bucketName string, minioClient *minio.Client) ([]string, error) {
	var objectList []string

	// Get the list of objects
	objectCh := minioClient.ListObjects(bucketName, "", true, nil)
	for object := range objectCh {
		if object.Err != nil {
			return nil, object.Err
		}
		objectList = append(objectList, object.Key)
	}

	return objectList, nil
}