jambotron/src/main/java/com/jambotronGroup/jambotron/controllers/FilesController.java

package com.jambotronGroup.jambotron.controllers;

import com.jambotronGroup.jambotron.fileUpload.FilesStorageService;
import com.jambotronGroup.jambotron.fileUpload.ResponseImageUploadResult;
import com.jambotronGroup.jambotron.fileUpload.ResponseMessage;
import com.jambotronGroup.jambotron.model.FileInfo;
import com.jambotronGroup.jambotron.model.User;
import com.jambotronGroup.jambotron.payload.request.SaveZhipuAiImageRequest;
import com.jambotronGroup.jambotron.security.AuthenticationFacade;
import com.jambotronGroup.jambotron.system.SystemServiceImpl;
import jakarta.validation.Valid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.method.annotation.MvcUriComponentsBuilder;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Collectors;

@Controller
public class FilesController {

    private static final Logger logger = LoggerFactory.getLogger(FilesController.class);

    @Autowired
    AuthenticationFacade authenticationFacade;
    @Autowired
    FilesStorageService storageService;

    /**
     * Generates a URL for accessing a user's image.
     * format: /api/user/user-images/{filename:.+}
     *
     * @param filename The name of the file.
     * @return The URL to access the file.
     */
    private static String getUserImageUrl(String filename) {
        return MvcUriComponentsBuilder
                .fromMethodName(FilesController.class, "getUserImage", filename).build().toString();
    }

    private static String getPublicImageUrl(String filename) {
        return MvcUriComponentsBuilder
                .fromMethodName(FilesController.class, "getFile", filename).build().toString();
    }

    @PostMapping("/api/user/saveZhipuAiImage")
    public ResponseEntity<ResponseMessage> saveZhipuAiImage(@Valid @RequestBody SaveZhipuAiImageRequest request) {

        if (request.getImageUrl() == null || request.getImageUrl().isEmpty()) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseMessage("URL cannot be empty"));
        }

        String url = request.getImageUrl();

        String message = "";

        RestTemplate restTemplate = new RestTemplate();

        try {
                // Make a GET request to fetch the image as a byte array
            ResponseEntity<byte[]> response = restTemplate.getForEntity(url, byte[].class);

            if (response.getStatusCode().is2xxSuccessful() && response.getBody() != null) {
                    // Save the image to a file

                int lastSlashIndex = url.lastIndexOf("/");
                String fileName = (lastSlashIndex != -1) ? url.substring(lastSlashIndex + 1) : url;

                MultipartFile multipartFile = new MockMultipartFile(
                            fileName, // Name of the file
                            fileName, // Original filename
                            "application/octet-stream", // Content type
                            response.getBody() // File content
                );

                User user = authenticationFacade.getUser();

                storageService.save(user.getId().toString(), multipartFile);

                message = "Uploaded the file successfully: " + fileName;

            } else {

                    message = "Failed to download image. HTTP Status: " + response.getStatusCode();
                    System.err.println(message);
                    return ResponseEntity.status(HttpStatus.EXPECTATION_FAILED).body(new ResponseMessage(message));
                }
        } catch (Exception e) {
                message = "Error fetching the image from URL: " + url + ". Error: " + e.getMessage();
                System.err.println(message);
                return ResponseEntity.status(HttpStatus.EXPECTATION_FAILED).body(new ResponseMessage(message));
        }
        return ResponseEntity.status(HttpStatus.OK).body(new ResponseMessage(message));
    }

    @PostMapping("/api/user/upload")
    public ResponseEntity<ResponseMessage> uploadFile(@RequestParam("file") MultipartFile file) {
        String message = "";
        try {
            User user = authenticationFacade.getUser();

            String localFullFileName = storageService.save(user.getId().toString(), file);

            FileInfo fileInfo = new FileInfo(
                    file.getOriginalFilename(),
                    FilesController.getUserImageUrl(localFullFileName));
            

            message = "Uploaded the file successfully: " + file.getOriginalFilename();
            return ResponseEntity.status(HttpStatus.OK).body(new ResponseImageUploadResult(message,fileInfo));
        } catch (Exception e) {
            message = "Could not upload the file: " + file.getOriginalFilename() + ". Error: " + e.getMessage();
            return ResponseEntity.status(HttpStatus.EXPECTATION_FAILED).body(new ResponseMessage(message));
        }
    }

    @GetMapping("/api/user/getImages")
    public ResponseEntity<List<FileInfo>> getImages() {

        User user = authenticationFacade.getUser();

        List<FileInfo> fileInfos = storageService.loadUserImages(user.getId().toString()).map(path -> {
            String filename = path.getFileName().toString();

            String url = FilesController.getUserImageUrl(filename);

            return new FileInfo(filename, url);
        }).collect(Collectors.toList());

        return ResponseEntity.status(HttpStatus.OK).body(fileInfos);
    }


    @GetMapping("/api/file/files")
    public ResponseEntity<List<FileInfo>> getListFiles() {
        List<FileInfo> fileInfos = storageService.loadAll().map(path -> {
            String filename = path.getFileName().toString();
            String url = FilesController.getPublicImageUrl(filename);
            return new FileInfo(filename, url);
        }).collect(Collectors.toList());

        return ResponseEntity.status(HttpStatus.OK).body(fileInfos);
    }

    @GetMapping("/files/{filename:.+}")
    @ResponseBody
    public ResponseEntity<Resource> getFile(@PathVariable String filename) {
        Resource file = storageService.load(filename);
        return ResponseEntity.ok()
                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + file.getFilename() + "\"").body(file);
    }

    @GetMapping("/api/user/user-images/{filename:.+}")
    @ResponseBody
    public ResponseEntity<Resource> getUserImage(@PathVariable String filename) {
        User user = authenticationFacade.getUser();
        Resource file = storageService.loadUserImage(user.getId().toString(),filename);
        return ResponseEntity.ok()
                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + file.getFilename() + "\"").body(file);
    }
}