package api

import (
	"context"
	"encoding/json"
	"fileserver/config"
	"fileserver/internal/models"
	"fileserver/internal/service"
	"fmt"
	"github.com/google/uuid"
	"io"
	"mime/multipart"
	"net/http"
	"os"
	"time"
)

// Constants for default bucket name and folder path for uploaded files
const (
	defaultBucketName   = "documents"              // Default bucket name in MinIO
	localFolderTemplate = "%s/fileserver/uploads/" // Template for creating local upload directories
)

// GetFiles retrieves the list of indexed documents from the database with fuzzy search on file names
func GetFiles(w http.ResponseWriter, r *http.Request) {
	// Step 1: Retrieve the search query from the URL parameters
	searchQuery := r.URL.Query().Get("searchQuery")
	if searchQuery == "" {
		// If there is no search query, retrieve all documents
		searchQuery = "%"
	} else {
		// Add wildcards for partial search
		searchQuery = "%" + searchQuery + "%"
	}

	// Step 2: Retrieve documents whose name matches the fuzzy search
	documents, err := service.GetFiles(searchQuery)
	if err != nil {
		// Handle error if the query fails
		http.Error(w, fmt.Sprintf("Error retrieving documents: %v", err), http.StatusInternalServerError)
		return
	}

	// Step 3: Convert the documents to JSON format
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)

	// Use json.NewEncoder to write the response directly in JSON format
	if err := json.NewEncoder(w).Encode(documents); err != nil {
		http.Error(w, fmt.Sprintf("Error encoding response: %v", err), http.StatusInternalServerError)
		return
	}
}

// GetFile handles the request to fetch a file from MinIO and serve it to the user.
func GetFile(w http.ResponseWriter, r *http.Request) {
	// Ensure that the request method is GET
	if r.Method != http.MethodGet {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// Extract the object name from the query parameters
	objectName := r.PathValue("idFile")
	idFile, err := uuid.Parse(objectName)
	if err != nil {
		http.Error(w, fmt.Sprintf("Error parsing objectName: %v", err), http.StatusBadRequest)
		return
	}

	document, err := service.GetDocument(idFile)
	if document == nil || err != nil {
		http.Error(w, fmt.Sprintf("Error retrieving document: %v", err), http.StatusNotFound)
		return
	}

	// Fetch the file object from MinIO storage
	object, err := service.GetFileFromMinIO(defaultBucketName, objectName)
	if err != nil {
		return
	}
	defer object.Close() // Ensure that the file object is closed after use

	// Create the upload directory if it doesn't exist
	uploadDir := fmt.Sprintf(localFolderTemplate, os.TempDir())
	err = os.MkdirAll(uploadDir, os.ModePerm)
	if err != nil {
		http.Error(w, "Error creating the uploads folder", http.StatusInternalServerError)
		return
	}

	// Create a new file locally with a unique name (using a timestamp)
	newFileName := fmt.Sprintf("%d_%s", time.Now().Unix(), objectName)
	file, err := os.Create(uploadDir + newFileName)
	if err != nil {
		http.Error(w, "Error saving the file: "+err.Error(), http.StatusInternalServerError)
		return
	}
	defer func(file *os.File) {
		err := file.Close()
		if err != nil {
			http.Error(w, "Error closing file: "+err.Error(), http.StatusInternalServerError)
		}
	}(file)

	// Copy the file content from MinIO to the local file
	_, err = io.Copy(file, object)
	if err != nil {
		fmt.Println("Error saving object to file:", err)
		return
	}

	// Get the file's information (size, name, etc.)
	fileInfo, err := file.Stat()
	if err != nil {
		http.Error(w, "Could not get file information", http.StatusInternalServerError)
		return
	}

	// Set headers for file download (name, content type, and length)
	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; objectName=%s", fileInfo.Name()))
	w.Header().Set("Content-Type", "application/octet-stream")
	w.Header().Set("Content-Length", fmt.Sprintf("%d", fileInfo.Size()))

	// Log the successful file retrieval
	fmt.Printf("Sending file: %s (Size: %d bytes)\n", fileInfo.Name(), fileInfo.Size())

	// Serve the file content as a download
	http.ServeContent(w, r, fileInfo.Name(), fileInfo.ModTime(), file)
}

// LoadFile handles file uploads from a client and stores them locally and on MinIO.
func LoadFile(w http.ResponseWriter, r *http.Request) {
	// Ensure that the request method is POST and that it is a multipart form
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// Parse the multipart form data with a maximum file size of 10MB
	err := r.ParseMultipartForm(10 << 20) // 10 MB
	if err != nil {
		http.Error(w, "Error parsing the request", http.StatusBadRequest)
		return
	}

	// Retrieve the uploaded file from the form
	file, header, err := r.FormFile("file")
	if err != nil {
		http.Error(w, "Error retrieving the file: "+err.Error(), http.StatusInternalServerError)
		return
	}
	defer func(file multipart.File) {
		err := file.Close()
		if err != nil {
			http.Error(w, "Error closing the input file: "+err.Error(), http.StatusInternalServerError)
		}
	}(file)

	// Create the upload directory if it doesn't exist
	uploadDir := fmt.Sprintf(localFolderTemplate, os.TempDir())
	err = os.MkdirAll(uploadDir, os.ModePerm)
	if err != nil {
		http.Error(w, "Error creating the uploads folder", http.StatusInternalServerError)
		return
	}

	// Use a unique file name based on timestamp and the original file name
	newFileName := fmt.Sprintf("%d_%s", time.Now().Unix(), header.Filename)
	filePath := uploadDir + newFileName
	out, err := os.Create(filePath)
	if err != nil {
		http.Error(w, "Error saving the file: "+err.Error(), http.StatusInternalServerError)
		return
	}
	defer func(out *os.File) {
		err := out.Close()
		if err != nil {
			http.Error(w, "Error closing the output file: "+err.Error(), http.StatusInternalServerError)
		}
		if err := cleanup(out); err != nil {
			http.Error(w, "Error remove the output file: "+err.Error(), http.StatusInternalServerError)
		}
	}(out)

	// Copy the file content from the request to the local file
	_, err = io.Copy(out, file)
	if err != nil {
		http.Error(w, "Error copying the file", http.StatusInternalServerError)
		return
	}

	// Calculate fingerprint of file
	//fingerprint, err := utils.CalculateFingerprint(filePath)
	//if err != nil {
	//	http.Error(w, "Error during calculate fingerprint: "+err.Error(), http.StatusInternalServerError)
	//	return
	//}
	fingerprint := uuid.New().String()

	// Check if document already uploaded
	_, err = service.GetDocumentByFingerprint(fingerprint)
	if err == nil {
		http.Error(w, "Document already exists.", http.StatusConflict)
		return
	}

	// Upload the file to MinIO with a unique ID (UUID)
	idFile := uuid.New()
	err = service.UploadFileToMinIO(context.Background(), defaultBucketName, idFile.String(), filePath)
	if err != nil {
		http.Error(w, "Error during upload file to MinIO: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// Save document to database
	newDocument := &models.Document{
		Name:        header.Filename,
		IdFile:      idFile,
		Fingerprint: fingerprint,
	}
	if err := service.AddDocument(newDocument); err != nil {
		http.Error(w, "Error adding document: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// Respond to the client with a success message
	_, err = fmt.Fprintf(w, "File %s uploaded successfully!\n", newFileName)
	if err != nil {
		return
	}
}

// cleanup removes a file from the local file system after use.
func cleanup(file *os.File) error {
	if _, err := os.Stat(file.Name()); err == nil {
		err := os.Remove(file.Name())
		if err != nil {
			return fmt.Errorf("Error removing file: %v", err)
		} else {
			fmt.Println("File removed successfully:", file.Name())
		}
	} else if os.IsNotExist(err) {
		return fmt.Errorf("File does not exist: %v", file.Name())
	} else {
		fmt.Println("Error checking file:", err)
	}
	return nil
}

// DeleteFile deletes a file from the database and MinIO
func DeleteFile(w http.ResponseWriter, r *http.Request) {
	// Ensure that the request method is GET
	if r.Method != http.MethodDelete {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// Extract the object name from the path value
	idFile, err := uuid.Parse(r.PathValue("idFile"))
	if err != nil {
		http.Error(w, "Error parsing the idFile: "+err.Error(), http.StatusBadRequest)
		return
	}

	// Step 1: Get document from PostgreSQL database
	document, err := service.GetDocument(idFile)
	if err != nil {
		http.Error(w, "Document not found: "+err.Error(), http.StatusNotFound)
		return
	}

	// Step 2: Delete from PostgreSQL
	if err := config.DB.Delete(&document).Error; err != nil {
		http.Error(w, fmt.Sprintf("Error deleting document from DB: %v", err), http.StatusInternalServerError)
		return
	}

	// Return success response
	w.WriteHeader(http.StatusOK)
	fmt.Fprintf(w, "File with ID %v deleted successfully", idFile)
}