+-----------------------------------------------------------------------------------------+
|                  Traditional HTTP Upload vs Tus Resumable Protocol                      |
+-----------------------------------------------------------------------------------------+

TRADITIONAL HTTP UPLOAD (Fragile Single-Stream):
[Browser] ===(HTTP POST: 25 GB Stream)=========================================> [Server]
               │ (Network Disconnects at 24.8 GB!)
               ▼
* Connection Terminated! Server discards partial file! User must restart from 0% (0 GB)!

TUS RESUMABLE PROTOCOL (2026 Standard - Byte-Offset Synchronization):
1. [POST /files] ---> Creates Upload Resource -> Server returns URL: '/files/upload_98420'
2. [PATCH /files/upload_98420 (Offset: 0B)] ---> Transmits 0B to 15GB -> Network drops!
3. Network Restored! Client sends: [HEAD /files/upload_98420]
4. Server responds: 'Upload-Offset: 15728640000' (Server received exactly 15GB!)
5. Client sends: [PATCH /files/upload_98420 (Offset: 15GB)] ---> Resumes instantly from 15GB!
* Zero Data Lost! 100% Seamless Resumption!

+-----------------------------------------------------------------------------------------+
|                  AWS S3 Direct Multipart Architecture                                   |
+-----------------------------------------------------------------------------------------+

[BROWSER APPLICATION] (User selects 50 GB File)
  │
  ├── 1. POST /api/upload/initiate -> Backend returns { uploadId, key }
  │
  ├── 2. Slices file into 1,000 x 50MB Chunks via Web Streams API.
  │
  ├── 3. GET /api/upload/presigned-urls?partNumbers=1..10
  │
  ├── 4. Uploads 50MB Parts DIRECTLY TO AMAZON S3 IN PARALLEL! (Uses HTTP PUT Presigned URLs)
  │      - S3 returns an ETag for each part: { PartNumber: 1, ETag: "a8f948..." }
  │
  └── 5. POST /api/upload/complete -> Backend calls S3 'CompleteMultipartUpload'!

// components/ResumableUploader.tsx
"use client";

import React, { useState } from "react";
import * as tus from "tus-js-client";

export function ResumableUploader() {
  const [progress, setProgress] = useState<number>(0);
  const [isUploading, setIsUploading] = useState<boolean>(false);
  const [uploadInstance, setUploadInstance] = useState<tus.Upload | null>(null);

  const startUpload = (file: File) => {
    setIsUploading(true);

    // 1. Initialize Tus Resumable Upload Client
    const upload = new tus.Upload(file, {
      endpoint: "https://tus-server.mojostudio.in/files/",
      retryDelays: [0, 1000, 3000, 5000, 10000, 20000], // Automated Exponential Backoff!
      chunkSize: 10 * 1024 * 1024, // 10MB Chunks
      metadata: {
        filename: file.name,
        filetype: file.type,
      },
      // 2. Persist URL in LocalStorage / IndexedDB for Browser Crash Recovery!
      removeFingerprintOnSuccess: true,
      
      onError: (error) => {
        console.error("❌ Upload failed:", error);
        setIsUploading(false);
      },
      onProgress: (bytesUploaded, bytesTotal) => {
        const percentage = Math.round((bytesUploaded / bytesTotal) * 100);
        setProgress(percentage);
      },
      onSuccess: () => {
        console.log("✅ File upload completed successfully:", upload.url);
        setIsUploading(false);
      },
    });

    // 3. Check if previous upload exists on server and resume from offset!
    upload.findPreviousUploads().then((previousUploads) => {
      if (previousUploads.length > 0) {
        console.log("🔄 Found previous partial upload! Resuming from offset...");
        upload.resumeFromPreviousUpload(previousUploads[0]);
      }
      upload.start();
      setUploadInstance(upload);
    });
  };

  return (
    <div className="p-6 bg-neutral-900 border border-neutral-800 rounded-xl text-white">
      <h3 className="text-xl font-bold mb-4">Resumable High-Speed Upload</h3>
      <input
        type="file"
        onChange={(e) => e.target.files?.[0] && startUpload(e.target.files[0])}
        className="mb-4 block w-full text-sm text-neutral-400"
      />
      {isUploading && (
        <div>
          <div className="w-full bg-neutral-800 h-3 rounded-full overflow-hidden">
            <div
              className="bg-red-600 h-full transition-all duration-300"
              style={{ width: `${progress}%` }}
            />
          </div>
          <p className="mt-2 text-sm text-neutral-300 font-mono">{progress}% Uploaded</p>
          <button
            onClick={() => uploadInstance?.abort()}
            className="mt-3 px-4 py-1.5 bg-neutral-800 hover:bg-neutral-700 rounded text-sm"
          >
            Pause Upload
          </button>
        </div>
      )}
    </div>
  );
}

// backend/s3_uploader.go
package main

import (
	"context"
	"fmt"
	"time"

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

type S3MultipartController struct {
	client     *s3.Client
	presignCli *s3.PresignClient
	bucket     string
}

// 1. Initiate Multipart Upload Session
func (c *S3MultipartController) InitiateUpload(ctx context.Context, key string) (string, error) {
	resp, err := c.client.CreateMultipartUpload(ctx, &s3.CreateMultipartUploadInput{
		Bucket: aws.String(c.bucket),
		Key:    aws.String(key),
	})
	if err != nil {
		return "", err
	}
	return *resp.UploadId, nil
}

// 2. Generate Presigned URL for Specific Part Number (Direct Browser to S3 Upload!)
func (c *S3MultipartController) GetPresignedPartURL(ctx context.Context, key, uploadID string, partNumber int32) (string, error) {
	req, err := c.presignCli.PresignUploadPart(ctx, &s3.UploadPartInput{
		Bucket:     aws.String(c.bucket),
		Key:        aws.String(key),
		UploadId:   aws.String(uploadID),
		PartNumber: aws.Int32(partNumber),
	}, s3.WithPresignExpires(20*time.Minute))

	if err != nil {
		return "", err
	}
	return req.URL, nil
}

// 3. Finalize and Stitch Parts together in S3
func (c *S3MultipartController) CompleteUpload(ctx context.Context, key, uploadID string, completedParts []types.CompletedPart) error {
	_, err := c.client.CompleteMultipartUpload(ctx, &s3.CompleteMultipartUploadInput{
		Bucket:   aws.String(c.bucket),
		Key:      aws.String(key),
		UploadId: aws.String(uploadID),
		MultipartUpload: &types.CompletedMultipartUpload{
			Parts: completedParts,
		},
	})
	return err
}

       +-------------------------------------------------------------+
       |             Time to Recover from 90% Network Drop (50GB File)|
       +-------------------------------------------------------------+
 Standard HTTP Upload (Full Restart)  | ==================================== [2,700.0s] (45 Mins)
 Tus Resumable Protocol (Resumes at 90%)| === [270.0s] (4.5 Mins - 10x Faster Recovery!)
                                      +-------------------------------------+
                                      0s     600s    1200s   1800s   2400s

       +-------------------------------------------------------------+
       |             Application Server RAM Under 50 Concurrent 10GB Uploads |
       +-------------------------------------------------------------+
 Monolithic Node.js File Proxy        | ==================================== [42.0 GB] (OOM Crash!)
 S3 Direct Multipart (Presigned URLs) | = [0.05 GB] (99.8% RAM Reduction!)
                                      +-------------------------------------+
                                      0GB     10GB    20GB    30GB    40GB