/**
 * Example: Combined Video Upload and Status Checking
 * 
 * This example demonstrates how to use the new combined method
 * uploadVideoAndWaitForCompletion() which handles both video upload
 * and status checking in a single call.
 */

import { ZaloSDK, VideoUploadStatus } from '../src/index';
import * as fs from 'fs';

async function videoUploadCombinedExample() {
  // Initialize SDK
  const zalo = new ZaloSDK();
  
  // Your access token
  const accessToken = "YOUR_ACCESS_TOKEN";
  
  try {
    console.log("🚀 Starting combined video upload example...");
    
    // Read video file
    const videoBuffer = fs.readFileSync('./path/to/your/video.mp4');
    console.log(`📁 Video file size: ${videoBuffer.length} bytes`);
    
    // Method 1: Combined upload and wait for completion
    console.log("\n📤 Method 1: Using combined uploadVideoAndWaitForCompletion()");
    
    const startTime = Date.now();
    const finalResult = await zalo.videoUpload.uploadVideoAndWaitForCompletion(
      accessToken,
      videoBuffer,
      "example-video.mp4",
      5 * 60 * 1000, // 5 minutes timeout
      5 * 1000       // 5 seconds polling interval
    );
    
    const duration = Date.now() - startTime;
    console.log(`✅ Video upload completed in ${duration}ms`);
    console.log(`📹 Video ID: ${finalResult.video_id}`);
    console.log(`📊 Status: ${finalResult.status} (${getStatusDescription(finalResult.status)})`);
    console.log(`📝 Status Message: ${finalResult.status_message}`);
    console.log(`🎬 Video Name: ${finalResult.video_name}`);
    console.log(`📏 Video Size: ${finalResult.video_size} bytes`);
    console.log(`🔄 Convert Progress: ${finalResult.convert_percent}%`);
    
    // Method 2: Manual step-by-step approach (for comparison)
    console.log("\n📤 Method 2: Manual step-by-step approach");
    
    // Step 1: Upload video
    const uploadResult = await zalo.videoUpload.uploadVideo(
      accessToken,
      videoBuffer,
      "example-video-manual.mp4"
    );
    console.log(`🎫 Upload token: ${uploadResult.token}`);
    
    // Step 2: Check status manually
    let attempts = 0;
    const maxAttempts = 60; // 5 minutes with 5-second intervals
    
    while (attempts < maxAttempts) {
      const status = await zalo.videoUpload.checkVideoStatus(accessToken, uploadResult.token);
      
      console.log(`🔍 Attempt ${attempts + 1}: Status ${status.status} - ${status.status_message} (${status.convert_percent}%)`);
      
      if (status.status === VideoUploadStatus.SUCCESS && status.video_id) {
        console.log(`✅ Manual upload completed!`);
        console.log(`📹 Video ID: ${status.video_id}`);
        break;
      }
      
      if (status.status === VideoUploadStatus.FAILED) {
        console.error(`❌ Manual upload failed: ${status.status_message}`);
        break;
      }
      
      if (status.status === VideoUploadStatus.LOCKED) {
        console.error(`🔒 Video has been locked: ${status.status_message}`);
        break;
      }
      
      if (status.status === VideoUploadStatus.DELETED) {
        console.error(`🗑️ Video has been deleted: ${status.status_message}`);
        break;
      }
      
      // Continue polling for PROCESSING or UNKNOWN status
      await new Promise(resolve => setTimeout(resolve, 5000));
      attempts++;
    }
    
    if (attempts >= maxAttempts) {
      console.error(`⏰ Manual upload timeout after ${maxAttempts} attempts`);
    }
    
    // Method 3: Upload from URL (bonus feature)
    console.log("\n🌐 Method 3: Upload video from URL");
    
    try {
      const urlUploadResult = await zalo.videoUpload.uploadVideoFromUrl(
        accessToken,
        "https://example.com/sample-video.mp4"
      );
      
      console.log(`🎫 URL upload token: ${urlUploadResult.token}`);
      
      // Wait for completion
      const urlFinalResult = await zalo.videoUpload.waitForUploadCompletion(
        accessToken,
        urlUploadResult.token
      );
      
      console.log(`✅ URL upload completed!`);
      console.log(`📹 Video ID: ${urlFinalResult.video_id}`);
    } catch (error) {
      console.log(`ℹ️ URL upload example skipped (URL not accessible): ${error.message}`);
    }
    
  } catch (error) {
    console.error("❌ Error in video upload example:", error);
    
    if (error.message.includes("Token cannot be empty")) {
      console.log("💡 Please set your access token in the example");
    }
    
    if (error.message.includes("Video file size exceeds")) {
      console.log("💡 Video file is too large. Maximum size is 50MB");
    }
    
    if (error.message.includes("Unsupported video format")) {
      console.log("💡 Only MP4 and AVI formats are supported");
    }
  }
}

/**
 * Get human-readable status description
 */
function getStatusDescription(status: number): string {
  switch (status) {
    case VideoUploadStatus.UNKNOWN:
      return "Trạng thái không xác định";
    case VideoUploadStatus.SUCCESS:
      return "Video đã được xử lý thành công và có thể sử dụng";
    case VideoUploadStatus.LOCKED:
      return "Video đã bị khóa";
    case VideoUploadStatus.PROCESSING:
      return "Video đang được xử lý";
    case VideoUploadStatus.FAILED:
      return "Video xử lý thất bại";
    case VideoUploadStatus.DELETED:
      return "Video đã bị xóa";
    default:
      return "Unknown status";
  }
}

/**
 * Example usage with error handling and retry logic
 */
async function robustVideoUploadExample() {
  const zalo = new ZaloSDK();
  const accessToken = "YOUR_ACCESS_TOKEN";
  
  try {
    const videoBuffer = fs.readFileSync('./path/to/your/video.mp4');
    
    // Retry logic for robust upload
    const maxRetries = 3;
    let attempt = 0;
    
    while (attempt < maxRetries) {
      try {
        console.log(`🔄 Upload attempt ${attempt + 1}/${maxRetries}`);
        
        const result = await zalo.videoUpload.uploadVideoAndWaitForCompletion(
          accessToken,
          videoBuffer,
          "robust-upload.mp4",
          10 * 60 * 1000, // 10 minutes timeout
          3 * 1000        // 3 seconds polling interval
        );
        
        console.log(`✅ Upload successful on attempt ${attempt + 1}`);
        console.log(`📹 Video ID: ${result.video_id}`);
        return result;
        
      } catch (error) {
        attempt++;
        console.log(`❌ Attempt ${attempt} failed: ${error.message}`);
        
        if (attempt >= maxRetries) {
          throw new Error(`Upload failed after ${maxRetries} attempts: ${error.message}`);
        }
        
        // Wait before retry
        console.log(`⏳ Waiting 10 seconds before retry...`);
        await new Promise(resolve => setTimeout(resolve, 10000));
      }
    }
    
  } catch (error) {
    console.error("❌ Robust upload failed:", error);
  }
}

// Run examples
if (require.main === module) {
  console.log("🎬 Zalo Video Upload Combined Example");
  console.log("=====================================\n");
  
  videoUploadCombinedExample()
    .then(() => {
      console.log("\n🎯 Basic example completed");
      return robustVideoUploadExample();
    })
    .then(() => {
      console.log("\n🛡️ Robust example completed");
      console.log("\n✨ All examples completed successfully!");
    })
    .catch(error => {
      console.error("\n💥 Example failed:", error);
      process.exit(1);
    });
}

export { videoUploadCombinedExample, robustVideoUploadExample };