package com.acumenvelocity.ath.gcs;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.InputStream;
   import java.net.URI;
   import java.nio.ByteBuffer;
   import java.nio.channels.Channels;
   import java.util.ArrayList;
  import java.util.List;
  
  import com.acumenvelocity.ath.common.Const;
  import com.acumenvelocity.ath.common.Log;
  import com.acumenvelocity.ath.common.exception.AthException;
  import com.google.api.gax.paging.Page;
  import com.google.auth.Credentials;
  import com.google.auth.oauth2.GoogleCredentials;
  import com.google.cloud.ReadChannel;
  import com.google.cloud.WriteChannel;
  import com.google.cloud.storage.Blob;
  import com.google.cloud.storage.BlobId;
  import com.google.cloud.storage.BlobInfo;
  import com.google.cloud.storage.Storage;
  import com.google.cloud.storage.Storage.BlobListOption;
  import com.google.cloud.storage.StorageOptions;
  
  public class AthStorage {
  
    private static Storage gcs;
  
    public static void init() throws Exception {
      Credentials credentials = GoogleCredentials
          .fromStream(new FileInputStream(Const.ATH_GCP_SECRET_FILE));
  
      gcs = StorageOptions.newBuilder().setCredentials(credentials).build()
          .getService();
    }
  
    public static boolean exists(URI gcsUrl) {
      try {
        BlobId blobId = BlobId.fromGsUtilUri(gcsUrl.toString());
        Blob blob = gcs.get(blobId);
  
        return blob != null;
  
      } catch (Exception e) {
        return false;
      }
    }
  
    // public static void storeFile(URI gcsUrl, String contentType, File file) throws Exception {
    // // BlobId blobId = BlobId.of(Const.ATH_GCS_BUCKET, objectName);
    // BlobId blobId = BlobId.fromGsUtilUri(gcsUrl.toString());
    // BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType(contentType).build();
    //
    // try (InputStream inputStream = new FileInputStream(file)) {
    // try (WriteChannel writer = gcs.writer(blobInfo)) {
    // ByteStreams.copy(inputStream, Channels.newOutputStream(writer));
    // }
    // }
    // }
  
    public static void storeFile(URI gcsUrl, String contentType, File file) throws Exception {
      BlobId blobId = BlobId.fromGsUtilUri(gcsUrl.toString());
  
      // FIX 1: Remove setSize(Long) as it's not visible/available
      BlobInfo blobInfo = BlobInfo.newBuilder(blobId)
          .setContentType(contentType)
          .build();
  
      long fileLength = file.length();
  
      // Check input file size
      if (fileLength == 0) {
        // Use your AthException or throw standard exception
        throw new Exception("Input file is 0 bytes. Cannot store to GCS.");
      }
  
      // FIX 2: Declare totalBytesCopied before the try-block
      // to ensure it's accessible for the final check.
      long totalBytesCopied = 0;
  
      try (InputStream inputStream = new FileInputStream(file)) {
  
        // Use the WriteChannel directly for binary data transfer
        try (WriteChannel writer = gcs.writer(blobInfo)) {
  
          byte[] buffer = new byte[8192];
          int bytesRead;
  
          while ((bytesRead = inputStream.read(buffer)) != -1) {
            // Write to the GCS WriteChannel using a ByteBuffer
            writer.write(ByteBuffer.wrap(buffer, 0, bytesRead));
            totalBytesCopied += bytesRead;
          }
  
          // The try-with-resources block closes the writer, which finalizes the upload.
        }
      }
 
     // FIX 3: totalBytesCopied is now accessible here
     if (totalBytesCopied != fileLength) {
       System.err.println("GCS upload warning: Copied bytes (" + totalBytesCopied +
           ") does not match input file size (" + fileLength + ")");
       // This mismatch is a strong indicator of the 0-byte issue persisting.
     }
   }
 
   public static void loadFile(URI gcsUrl, File file) throws Exception {
     // BlobId blobId = BlobId.of(Const.ATH_GCS_BUCKET, objectName);
     BlobId blobId = BlobId.fromGsUtilUri(gcsUrl.toString());
     Blob blob = gcs.get(blobId);
 
     if (blob == null) {
       AthException.logAndThrow(AthStorage.class, "Cannot acccess GCS blob '{}'", blobId);
     }
 
     blob.downloadTo(file.toPath());
   }
 
   public static InputStream getInputStream(URI gcsUrl) throws Exception {
     // BlobId blobId = BlobId.of(Const.ATH_GCS_BUCKET, objectName);
     BlobId blobId = BlobId.fromGsUtilUri(gcsUrl.toString());
     Blob blob = gcs.get(blobId);
 
     if (blob == null) {
       AthException.logAndThrow(AthStorage.class, "Cannot acccess GCS blob '{}'", blobId);
     }
 
     ReadChannel channel = blob.reader();
     return Channels.newInputStream(channel);
   }
 
   public static Storage getGcs() {
     return gcs;
   }
 
   public static List<String> getNames(String bucketName, String prefix) throws Exception {
     List<String> list = new ArrayList<>();
 
     Page<Blob> blobs = gcs.list(bucketName, BlobListOption.prefix(prefix));
 
     for (Blob blob : blobs.iterateAll()) {
       list.add(blob.getName());
     }
 
     return list;
   }
 
   public static void deleteMany(String bucketName, String prefix) throws Exception {
     Page<Blob> blobs = gcs.list(bucketName, BlobListOption.prefix(prefix));
 
     for (Blob blob : blobs.iterateAll()) {
       Log.info(AthStorage.class, "Deleting GCS blob '{}'", blob.getName());
       blob.delete();
     }
   }
 }