// Option 1: local import (place the downloaded SDK file into your project)
import { IceShuttle, downloadBlob } from './sdk/iceshuttle.esm.js';

// Option 2: script tag from the official site (for projects without a build tool)
// Download: https://www.wringcloud.com/sdk/iceshuttle-js/dist/iceshuttle.min.js
<script src="./sdk/iceshuttle.min.js"></script>
<script>
  const { IceShuttle, downloadBlob } = window.IceShuttle;
</script>

import { IceShuttle } from 'iceshuttle-js';

const client = new IceShuttle({
  appKey: 'your-app-key',         // required: your app key
  appSecret: 'your-app-secret',   // required: your app secret
  serverDomain: 'https://www.wringcloud.com',  // optional: server domain
  debug: false                       // optional: enable debug logging
});

// 1. Create a P2P send task
const sender = await client.createP2PSender({
  fileName: file.name,             // required: file name
  fileSize: file.size,             // required: file size (bytes)
  password: 'optional-password',            // optional: transfer password
  maxReceiveCount: 1              // optional: max receive count
});

// 2. Get the receive link and share it with the receiver
const receiveLink = sender.getReceiveLink();
console.log('Receive link:', receiveLink);

// 3. Send the file (the SDK handles the transfer automatically)
await sender.sendFile(file, {
  onProgress: (percent) => {
    console.log(`Transfer progress: ${percent.toFixed(1)}%`);
  },
  onComplete: (info) => {
    console.log('Transfer complete', info);
  },
  onError: (err) => {
    console.error('Transfer failed:', err);
  },
  onProcessing: (info) => {
    console.log(info.message); // e.g. "Verifying file..."
  }
});

// 4. Cancel the transfer (optional)
await sender.cancel();

// Parse transferId and token from the receive link
const receiver = await client.createP2PReceiver(transferId, token);

// Get file info
console.log('File name:', receiver.getFileName());

// Receive the file
await receiver.receiveFile({
  onProgress: (percent) => {
    console.log(`Receive progress: ${percent.toFixed(1)}%`);
  },
  onComplete: ({ blob, fileName, fileSize }) => {
    // Trigger the browser download
    downloadBlob(blob, fileName);
  },
  onError: (err) => {
    console.error('Receive failed:', err);
  }
});

// 1. Create a secure relay task
const sender = await client.createRelaySender({
  fileName: file.name,             // required: file name
  fileSize: file.size,             // required: file size (bytes)
  password: 'optional-password',            // optional: transfer password
  maxReceiveCount: 5,             // optional: max download count
  expireHours: 168               // optional: link validity (hours)
});

// 2. Get the download link and share it with the receiver
const downloadLink = sender.getDownloadLink();
console.log('Download link:', downloadLink);

// 3. Upload the file (the SDK handles chunked upload automatically)
await sender.sendFile(file, {
  onProgress: (percent) => {
    console.log(`Upload progress: ${percent.toFixed(1)}%`);
  },
  onComplete: (info) => {
    console.log('Upload complete, waiting for the receiver to download');
  },
  onError: (err) => {
    console.error('Upload failed:', err);
  }
});

// 4. Cancel the transfer (optional)
await sender.cancel();

// Parse transferId and token from the download link
const receiver = await client.createRelayReceiver(transferId, token);

// Get file info
console.log('File name:', receiver.getFileName());

// Download the file as a Blob
const blob = await receiver.receiveFileAsBlob({
  onProgress: (percent) => {
    console.log(`Download progress: ${percent.toFixed(1)}%`);
  }
});

// Trigger the browser download
downloadBlob(blob, receiver.getFileName());

// Query the P2P transfer status
const p2pStatus = await client.getP2PTransferStatus(transferId);

// Query the secure relay transfer status
const relayStatus = await client.getRelayTransferStatus(transferId);

// Cancel a P2P transfer
await client.cancelP2PTransfer(transferId);

// Cancel a secure relay transfer
await client.cancelRelayTransfer(transferId);

// or simply call sender.cancel()
await sender.cancel();

import { downloadBlob } from 'iceshuttle-js';

// Trigger the browser download
downloadBlob(blob, 'filename.txt');

// P2P receive link format: https://www.wringcloud.com/p2p/{transferId}?token={token}
// Secure relay download link format: https://www.wringcloud.com/r/{transferId}?token={token}

function parseLink(link) {
  const url = new URL(link);
  const transferId = url.pathname.split('/').pop();
  const token = url.searchParams.get('token');
  return { transferId, token };
}

import { IceShuttle, downloadBlob } from 'iceshuttle-js';

// Initialize
const client = new IceShuttle({
  appKey: 'your-app-key',
  appSecret: 'your-app-secret'
});

// ===== P2P Direct Transfer =====
async function p2pSend(file) {
  const sender = await client.createP2PSender({
    fileName: file.name,
    fileSize: file.size
  });
  console.log('Receive link:', sender.getReceiveLink());
  await sender.sendFile(file, {
    onProgress: (p) => console.log(p + '%'),
    onComplete: () => console.log('Done')
  });
}

async function p2pReceive(transferId, token) {
  const receiver = await client.createP2PReceiver(transferId, token);
  await receiver.receiveFile({
    onProgress: (p) => console.log(p + '%'),
    onComplete: ({ blob, fileName }) => downloadBlob(blob, fileName)
  });
}

// ===== Secure Relay =====
async function relaySend(file) {
  const sender = await client.createRelaySender({
    fileName: file.name,
    fileSize: file.size
  });
  console.log('Download link:', sender.getDownloadLink());
  await sender.sendFile(file, {
    onProgress: (p) => console.log(p + '%'),
    onComplete: () => console.log('Upload complete')
  });
}

async function relayReceive(transferId, token) {
  const receiver = await client.createRelayReceiver(transferId, token);
  const blob = await receiver.receiveFileAsBlob({
    onProgress: (p) => console.log(p + '%')
  });
  downloadBlob(blob, receiver.getFileName());
}