// Access parent post and its children
fun processPostContent(post: AmityPost) {
    // Parent post contains text content and metadata
    (post.data as? AmityTextPostData)?.let { textData ->
        println("Parent post text: ${textData.text}")
    }
    
    // Process child posts (media attachments)
    processChildPosts(post.children)
}

fun processChildPosts(children: List<AmityPost>) {
    children.forEach { childPost ->
        when (childPost.dataType) {
            AmityDataType.IMAGE -> processImagePost(childPost)
            AmityDataType.FILE -> processFilePost(childPost)
            AmityDataType.VIDEO -> processVideoPost(childPost)
            AmityDataType.LIVE_STREAM -> processLiveStreamPost(childPost)
            AmityDataType.POLL -> processPollPost(childPost)
            else -> println("Unknown post type: ${childPost.dataType}")
        }
    }
}

// Advanced: Reactive post content observer
class PostContentObserver {
    fun observePostContent(postId: String): Observable<ProcessedPostContent> {
        val repository = AmityPostRepository(client)
        
        return repository.getPost(postId)
            .build()
            .query()
            .map { post ->
                ProcessedPostContent(
                    parent = extractParentContent(post),
                    children = post.children.map { processChildPost(it) },
                    totalSize = calculateTotalSize(post),
                    hasMediaContent = post.children.isNotEmpty()
                )
            }
            .distinctUntilChanged()
    }
    
    private fun extractParentContent(post: AmityPost): ParentContent {
        val textData = post.data as? AmityTextPostData
        return ParentContent(
            text = textData?.text,
            metadata = post.metadata,
            mentions = textData?.mentions ?: emptyList(),
            tags = post.tags
        )
    }
}

// Access parent post and its children
function processPostContent(post: AmityPost): void {
  // Parent post contains text content and metadata
  if (post.dataType === 'text' && post.data) {
    const textData = post.data as AmityTextPostData;
    console.log('Parent post text:', textData.text);
  }
  
  // Process child posts (media attachments)
  processChildPosts(post.children);
}

function processChildPosts(children: AmityPost[]): void {
  children.forEach(childPost => {
    switch (childPost.dataType) {
      case 'image':
        processImagePost(childPost);
        break;
      case 'file':
        processFilePost(childPost);
        break;
      case 'video':
        processVideoPost(childPost);
        break;
      case 'liveStream':
        processLiveStreamPost(childPost);
        break;
      case 'poll':
        processPollPost(childPost);
        break;
      default:
        console.log('Unknown post type:', childPost.dataType);
    }
  });
}

// Advanced: Post content manager with caching
class PostContentManager {
  private contentCache = new Map<string, ProcessedPostContent>();
  
  async processPost(postId: string): Promise<ProcessedPostContent> {
    // Check cache first
    if (this.contentCache.has(postId)) {
      return this.contentCache.get(postId)!;
    }
    
    const repository = new AmityPostRepository(client);
    const post = await repository.getPost(postId);
    
    const processedContent: ProcessedPostContent = {
      parent: this.extractParentContent(post),
      children: await Promise.all(post.children.map(child => this.processChildPost(child))),
      totalSize: this.calculateTotalSize(post),
      hasMediaContent: post.children.length > 0
    };
    
    // Cache the processed content
    this.contentCache.set(postId, processedContent);
    
    return processedContent;
  }
  
  private extractParentContent(post: AmityPost): ParentContent {
    const textData = post.data as AmityTextPostData;
    return {
      text: textData?.text || null,
      metadata: post.metadata,
      mentions: textData?.mentions || [],
      tags: post.tags || []
    };
  }
  
  // Clear cache for memory management
  clearCache(): void {
    this.contentCache.clear();
  }
}

// Access parent post and its children
void processPostContent(AmityPost post) {
  // Parent post contains text content and metadata
  if (post.data is AmityTextPostData) {
    final textData = post.data as AmityTextPostData;
    print('Parent post text: ${textData.text}');
  }
  
  // Process child posts (media attachments)
  processChildPosts(post.children);
}

void processChildPosts(List<AmityPost> children) {
  for (final childPost in children) {
    switch (childPost.dataType) {
      case AmityDataType.image:
        processImagePost(childPost);
        break;
      case AmityDataType.file:
        processFilePost(childPost);
        break;
      case AmityDataType.video:
        processVideoPost(childPost);
        break;
      case AmityDataType.liveStream:
        processLiveStreamPost(childPost);
        break;
      case AmityDataType.poll:
        processPollPost(childPost);
        break;
      default:
        print('Unknown post type: ${childPost.dataType}');
    }
  }
}

// Advanced: Post content processor with state management
class PostContentProcessor extends ChangeNotifier {
  final Map<String, ProcessedPostContent> _contentCache = {};
  
  Future<ProcessedPostContent> processPost(String postId) async {
    // Check cache first
    if (_contentCache.containsKey(postId)) {
      return _contentCache[postId]!;
    }
    
    final repository = AmityPostRepository(client);
    final post = await repository.getPost(postId);
    
    final processedContent = ProcessedPostContent(
      parent: _extractParentContent(post),
      children: await Future.wait(
        post.children.map((child) => _processChildPost(child))
      ),
      totalSize: _calculateTotalSize(post),
      hasMediaContent: post.children.isNotEmpty,
    );
    
    // Cache the processed content
    _contentCache[postId] = processedContent;
    notifyListeners();
    
    return processedContent;
  }
  
  ParentContent _extractParentContent(AmityPost post) {
    final textData = post.data as AmityTextPostData?;
    return ParentContent(
      text: textData?.text,
      metadata: post.metadata,
      mentions: textData?.mentions ?? [],
      tags: post.tags ?? [],
    );
  }
  
  void clearCache() {
    _contentCache.clear();
    notifyListeners();
  }
}

// Basic image post processing
fun processImagePost(post: AmityPost) {
    val imageData = post.data as? AmityImagePostData ?: return
    
    // Get image information
    val imageInfo = imageData.getImageInfo()
    println("Image size: ${imageInfo.fileSize} bytes")
    println("Dimensions: ${imageInfo.width}x${imageInfo.height}")
    println("MIME type: ${imageInfo.mimeType}")
    
    // Load different image sizes
    loadImageWithSize(imageData, AmityImageSize.MEDIUM)
}

// Advanced: Optimized image loading with Glide integration
class ImagePostManager(private val client: AmityClient) {
    private val fileRepository = AmityFileRepository(client)
    
    fun loadOptimalImage(
        imageData: AmityImagePostData,
        imageView: ImageView,
        displayWidth: Int,
        displayHeight: Int
    ) {
        val optimalSize = determineOptimalSize(displayWidth, displayHeight)
        val imageUrl = constructImageURL(imageData.fileUrl, optimalSize)
        
        Glide.with(imageView.context)
            .load(imageUrl)
            .placeholder(R.drawable.image_placeholder)
            .error(R.drawable.image_error)
            .diskCacheStrategy(DiskCacheStrategy.ALL)
            .into(imageView)
    }
    
    private fun determineOptimalSize(width: Int, height: Int): AmityImageSize {
        val maxDimension = maxOf(width, height)
        
        return when (maxDimension) {
            in 0..150 -> AmityImageSize.SMALL
            in 151..400 -> AmityImageSize.MEDIUM
            in 401..800 -> AmityImageSize.LARGE
            else -> AmityImageSize.FULL
        }
    }
    
    // Manual URL construction
    fun constructImageURL(baseURL: String, size: AmityImageSize): String {
        return "$baseURL?size=${size.value}"
    }
    
    // Progressive loading with smooth transitions
    fun loadImageProgressively(
        imageData: AmityImagePostData,
        imageView: ImageView
    ) {
        val smallUrl = constructImageURL(imageData.fileUrl, AmityImageSize.SMALL)
        val largeUrl = constructImageURL(imageData.fileUrl, AmityImageSize.LARGE)
        
        Glide.with(imageView.context)
            .load(largeUrl)
            .thumbnail(
                Glide.with(imageView.context)
                    .load(smallUrl)
                    .transform(CenterCrop(), RoundedCorners(8))
            )
            .transition(DrawableTransitionOptions.withCrossFade())
            .into(imageView)
    }
}

// Custom image view with loading states
class PostImageView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : AppCompatImageView(context, attrs, defStyleAttr) {
    
    private var loadingProgressBar: ProgressBar? = null
    
    fun loadPostImage(imageData: AmityImagePostData) {
        showLoading()
        
        val manager = ImagePostManager(AmityClient.getInstance())
        manager.loadOptimalImage(
            imageData = imageData,
            imageView = this,
            displayWidth = width,
            displayHeight = height
        )
        
        // Hide loading when image is loaded
        Glide.with(context)
            .load(manager.constructImageURL(imageData.fileUrl, AmityImageSize.MEDIUM))
            .listener(object : RequestListener<Drawable> {
                override fun onLoadFailed(
                    e: GlideException?,
                    model: Any?,
                    target: Target<Drawable>?,
                    isFirstResource: Boolean
                ): Boolean {
                    hideLoading()
                    return false
                }
                
                override fun onResourceReady(
                    resource: Drawable?,
                    model: Any?,
                    target: Target<Drawable>?,
                    dataSource: DataSource?,
                    isFirstResource: Boolean
                ): Boolean {
                    hideLoading()
                    return false
                }
            })
            .into(this)
    }
    
    private fun showLoading() {
        loadingProgressBar?.visibility = View.VISIBLE
    }
    
    private fun hideLoading() {
        loadingProgressBar?.visibility = View.GONE
    }
}

// Basic image post processing
function processImagePost(post: AmityPost): void {
  const imageData = post.data as AmityImagePostData;
  if (!imageData) return;
  
  // Get image information
  const imageInfo = imageData.getImageInfo();
  console.log('Image size:', imageInfo.fileSize, 'bytes');
  console.log('Dimensions:', `${imageInfo.width}x${imageInfo.height}`);
  console.log('MIME type:', imageInfo.mimeType);
  
  // Load different image sizes
  loadImageWithSize(imageData, 'medium');
}

// Advanced: Optimized image loading manager
class ImagePostManager {
  private imageCache = new Map<string, HTMLImageElement>();
  private loadingPromises = new Map<string, Promise<HTMLImageElement>>();
  
  async loadOptimalImage(
    imageData: AmityImagePostData,
    displayWidth: number,
    displayHeight: number
  ): Promise<HTMLImageElement> {
    const optimalSize = this.determineOptimalSize(displayWidth, displayHeight);
    const imageUrl = this.constructImageURL(imageData.fileUrl, optimalSize);
    const cacheKey = `${imageData.fileId}_${optimalSize}`;
    
    // Check cache first
    if (this.imageCache.has(cacheKey)) {
      return this.imageCache.get(cacheKey)!;
    }
    
    // Check if already loading
    if (this.loadingPromises.has(cacheKey)) {
      return this.loadingPromises.get(cacheKey)!;
    }
    
    // Load and cache image
    const loadPromise = this.loadImage(imageUrl).then(image => {
      this.imageCache.set(cacheKey, image);
      this.loadingPromises.delete(cacheKey);
      return image;
    });
    
    this.loadingPromises.set(cacheKey, loadPromise);
    return loadPromise;
  }
  
  private determineOptimalSize(width: number, height: number): ImageSize {
    const maxDimension = Math.max(width, height);
    
    if (maxDimension <= 150) return 'small';
    if (maxDimension <= 400) return 'medium';
    if (maxDimension <= 800) return 'large';
    return 'full';
  }
  
  private constructImageURL(baseURL: string, size: ImageSize): string {
    return `${baseURL}?size=${size}`;
  }
  
  private loadImage(url: string): Promise<HTMLImageElement> {
    return new Promise((resolve, reject) => {
      const img = new Image();
      img.onload = () => resolve(img);
      img.onerror = () => reject(new Error(`Failed to load image: ${url}`));
      img.src = url;
    });
  }
  
  // Progressive loading with blur-to-sharp effect
  async loadImageProgressively(
    imageData: AmityImagePostData,
    imgElement: HTMLImageElement,
    displayWidth: number,
    displayHeight: number
  ): Promise<void> {
    // Load small version first (blurred placeholder)
    const smallUrl = this.constructImageURL(imageData.fileUrl, 'small');
    const smallImage = await this.loadImage(smallUrl);
    
    imgElement.src = smallImage.src;
    imgElement.style.filter = 'blur(5px)';
    imgElement.style.transition = 'filter 0.3s ease';
    
    // Load optimal size version
    try {
      const optimalImage = await this.loadOptimalImage(
        imageData,
        displayWidth,
        displayHeight
      );
      
      imgElement.src = optimalImage.src;
      imgElement.style.filter = 'none';
    } catch (error) {
      console.error('Failed to load high-quality image:', error);
    }
  }
}

// React component example
interface ImagePostProps {
  imageData: AmityImagePostData;
  width: number;
  height: number;
}

function ImagePost({ imageData, width, height }: ImagePostProps) {
  const [imageSrc, setImageSrc] = useState<string>('');
  const [isLoading, setIsLoading] = useState(true);
  const [hasError, setHasError] = useState(false);
  
  useEffect(() => {
    const manager = new ImagePostManager();
    
    manager.loadOptimalImage(imageData, width, height)
      .then(image => {
        setImageSrc(image.src);
        setIsLoading(false);
      })
      .catch(() => {
        setHasError(true);
        setIsLoading(false);
      });
  }, [imageData, width, height]);
  
  if (hasError) {
    return <div className="image-error">Failed to load image</div>;
  }
  
  return (
    <div className="image-container">
      {isLoading && <div className="image-skeleton">Loading...</div>}
      <img
        src={imageSrc}
        alt="Post image"
        style={{
          width: '100%',
          height: 'auto',
          display: isLoading ? 'none' : 'block'
        }}
        onLoad={() => setIsLoading(false)}
      />
    </div>
  );
}

// Basic image post processing
void processImagePost(AmityPost post) {
  final imageData = post.data as AmityImagePostData?;
  if (imageData == null) return;
  
  // Get image information
  final imageInfo = imageData.getImageInfo();
  print('Image size: ${imageInfo.fileSize} bytes');
  print('Dimensions: ${imageInfo.width}x${imageInfo.height}');
  print('MIME type: ${imageInfo.mimeType}');
  
  // Load different image sizes
  loadImageWithSize(imageData, AmityImageSize.medium);
}

// Advanced: Optimized image loading with cached_network_image
class ImagePostManager {
  final Map<String, ImageProvider> _imageCache = {};
  
  Future<ImageProvider> loadOptimalImage(
    AmityImagePostData imageData,
    double displayWidth,
    double displayHeight,
  ) async {
    final optimalSize = _determineOptimalSize(displayWidth, displayHeight);
    final imageUrl = _constructImageURL(imageData.fileUrl, optimalSize);
    final cacheKey = '${imageData.fileId}_${optimalSize.name}';
    
    if (_imageCache.containsKey(cacheKey)) {
      return _imageCache[cacheKey]!;
    }
    
    final imageProvider = CachedNetworkImageProvider(imageUrl);
    _imageCache[cacheKey] = imageProvider;
    
    return imageProvider;
  }
  
  AmityImageSize _determineOptimalSize(double width, double height) {
    final maxDimension = math.max(width, height);
    
    if (maxDimension <= 150) return AmityImageSize.small;
    if (maxDimension <= 400) return AmityImageSize.medium;
    if (maxDimension <= 800) return AmityImageSize.large;
    return AmityImageSize.full;
  }
  
  String _constructImageURL(String baseURL, AmityImageSize size) {
    return '$baseURL?size=${size.name}';
  }
  
  void clearCache() {
    _imageCache.clear();
  }
}

// Progressive image widget with blur effect
class ProgressiveImageWidget extends StatefulWidget {
  final AmityImagePostData imageData;
  final double width;
  final double height;
  final BorderRadius borderRadius;
  
  const ProgressiveImageWidget({
    Key? key,
    required this.imageData,
    required this.width,
    required this.height,
    this.borderRadius = BorderRadius.zero,
  }) : super(key: key);
  
  @override
  State<ProgressiveImageWidget> createState() => _ProgressiveImageWidgetState();
}

class _ProgressiveImageWidgetState extends State<ProgressiveImageWidget> {
  final ImagePostManager _manager = ImagePostManager();
  
  @override
  Widget build(BuildContext context) {
    return ClipRRect(
      borderRadius: widget.borderRadius,
      child: SizedBox(
        width: widget.width,
        height: widget.height,
        child: Stack(
          fit: StackFit.expand,
          children: [
            // Low quality placeholder (blurred)
            CachedNetworkImage(
              imageUrl: _manager._constructImageURL(
                widget.imageData.fileUrl,
                AmityImageSize.small,
              ),
              fit: BoxFit.cover,
              imageBuilder: (context, imageProvider) => Container(
                decoration: BoxDecoration(
                  image: DecorationImage(
                    image: imageProvider,
                    fit: BoxFit.cover,
                  ),
                ),
                child: BackdropFilter(
                  filter: ImageFilter.blur(sigmaX: 5, sigmaY: 5),
                  child: Container(color: Colors.transparent),
                ),
              ),
            ),
            // High quality image
            FutureBuilder<ImageProvider>(
              future: _manager.loadOptimalImage(
                widget.imageData,
                widget.width,
                widget.height,
              ),
              builder: (context, snapshot) {
                if (snapshot.hasData) {
                  return AnimatedOpacity(
                    duration: const Duration(milliseconds: 300),
                    opacity: 1.0,
                    child: Image(
                      image: snapshot.data!,
                      fit: BoxFit.cover,
                      loadingBuilder: (context, child, loadingProgress) {
                        if (loadingProgress == null) return child;
                        return const Center(
                          child: CircularProgressIndicator(),
                        );
                      },
                      errorBuilder: (context, error, stackTrace) {
                        return const Center(
                          child: Icon(
                            Icons.error_outline,
                            color: Colors.red,
                            size: 32,
                          ),
                        );
                      },
                    ),
                  );
                }
                return const SizedBox.shrink();
              },
            ),
          ],
        ),
      ),
    );
  }
}

// Post image widget with zoom functionality
class PostImageWidget extends StatelessWidget {
  final AmityImagePostData imageData;
  final VoidCallback? onTap;
  
  const PostImageWidget({
    Key? key,
    required this.imageData,
    this.onTap,
  }) : super(key: key);
  
  @override
  Widget build(BuildContext context) {
    return LayoutBuilder(
      builder: (context, constraints) {
        return GestureDetector(
          onTap: onTap ?? () => _showFullScreenImage(context),
          child: ProgressiveImageWidget(
            imageData: imageData,
            width: constraints.maxWidth,
            height: constraints.maxWidth * 0.75, // 4:3 aspect ratio
            borderRadius: BorderRadius.circular(8),
          ),
        );
      },
    );
  }
  
  void _showFullScreenImage(BuildContext context) {
    Navigator.of(context).push(
      PageRouteBuilder(
        opaque: false,
        barrierDismissible: true,
        pageBuilder: (context, animation, _) {
          return FadeTransition(
            opacity: animation,
            child: Scaffold(
              backgroundColor: Colors.black87,
              body: SafeArea(
                child: PhotoView(
                  imageProvider: CachedNetworkImageProvider(
                    ImagePostManager()._constructImageURL(
                      imageData.fileUrl,
                      AmityImageSize.full,
                    ),
                  ),
                  minScale: PhotoViewComputedScale.contained,
                  maxScale: PhotoViewComputedScale.covered * 3,
                  heroAttributes: PhotoViewHeroAttributes(
                    tag: imageData.fileId,
                  ),
                ),
              ),
            ),
          );
        },
      ),
    );
  }
}

// Basic file post processing
fun processFilePost(post: AmityPost) {
    val fileData = post.data as? AmityFilePostData ?: return
    
    // Get file information
    val fileInfo = fileData.getFileInfo()
    println("File name: ${fileInfo.fileName}")
    println("File size: ${fileInfo.fileSize} bytes")
    println("MIME type: ${fileInfo.mimeType}")
    println("File extension: ${fileInfo.fileExtension}")
    
    // Download file
    downloadFile(fileData)
}

// Advanced: File manager with download handling
class FilePostManager(private val context: Context) {
    private val fileRepository = AmityFileRepository(AmityClient.getInstance())
    private val downloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
    
    fun downloadFile(
        fileData: AmityFilePostData,
        progressCallback: ((Int) -> Unit)? = null,
        completion: (Result<Uri>) -> Unit
    ) {
        val fileInfo = fileData.getFileInfo()
        
        // Check permissions first
        if (!hasStoragePermission()) {
            completion(Result.failure(SecurityException("Storage permission required")))
            return
        }
        
        val request = DownloadManager.Request(Uri.parse(fileData.fileUrl))
            .setTitle(fileInfo.fileName)
            .setDescription("Downloading ${fileInfo.fileName}")
            .setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
            .setDestinationInExternalPublicDir(
                Environment.DIRECTORY_DOWNLOADS,
                fileInfo.fileName
            )
            .setAllowedOverMetered(true)
            .setAllowedOverRoaming(true)
        
        val downloadId = downloadManager.enqueue(request)
        
        // Monitor download progress
        monitorDownload(downloadId, progressCallback, completion)
    }
    
    private fun monitorDownload(
        downloadId: Long,
        progressCallback: ((Int) -> Unit)?,
        completion: (Result<Uri>) -> Unit
    ) {
        val handler = Handler(Looper.getMainLooper())
        val runnable = object : Runnable {
            override fun run() {
                val query = DownloadManager.Query().setFilterById(downloadId)
                val cursor = downloadManager.query(query)
                
                if (cursor.moveToFirst()) {
                    val status = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_STATUS))
                    val bytesDownloaded = cursor.getLong(cursor.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR))
                    val bytesTotal = cursor.getLong(cursor.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES))
                    
                    when (status) {
                        DownloadManager.STATUS_RUNNING -> {
                            if (bytesTotal > 0) {
                                val progress = ((bytesDownloaded * 100) / bytesTotal).toInt()
                                progressCallback?.invoke(progress)
                            }
                            handler.postDelayed(this, 100)
                        }
                        DownloadManager.STATUS_SUCCESSFUL -> {
                            val uri = downloadManager.getUriForDownloadedFile(downloadId)
                            completion(Result.success(uri))
                        }
                        DownloadManager.STATUS_FAILED -> {
                            val reason = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_REASON))
                            completion(Result.failure(Exception("Download failed: $reason")))
                        }
                    }
                }
                cursor.close()
            }
        }
        handler.post(runnable)
    }
    
    private fun hasStoragePermission(): Boolean {
        return ContextCompat.checkSelfPermission(
            context,
            Manifest.permission.WRITE_EXTERNAL_STORAGE
        ) == PackageManager.PERMISSION_GRANTED
    }
    
    // Get file icon resource based on MIME type
    fun getFileIconResource(mimeType: String): Int {
        return when {
            mimeType.contains("pdf") -> R.drawable.ic_pdf
            mimeType.contains("word") || mimeType.contains("document") -> R.drawable.ic_doc
            mimeType.contains("sheet") || mimeType.contains("excel") -> R.drawable.ic_excel
            mimeType.contains("presentation") || mimeType.contains("powerpoint") -> R.drawable.ic_ppt
            mimeType.contains("zip") || mimeType.contains("rar") -> R.drawable.ic_archive
            mimeType.contains("image") -> R.drawable.ic_image
            mimeType.contains("video") -> R.drawable.ic_video
            mimeType.contains("audio") -> R.drawable.ic_audio
            else -> R.drawable.ic_file
        }
    }
    
    // Format file size for display
    fun formatFileSize(bytes: Long): String {
        val units = arrayOf("B", "KB", "MB", "GB")
        var size = bytes.toDouble()
        var unitIndex = 0
        
        while (size >= 1024 && unitIndex < units.size - 1) {
            size /= 1024
            unitIndex++
        }
        
        return String.format("%.1f %s", size, units[unitIndex])
    }
    
    // Open file with appropriate app
    fun openFile(uri: Uri) {
        val intent = Intent(Intent.ACTION_VIEW).apply {
            setDataAndType(uri, getMimeType(uri))
            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
        }
        
        try {
            context.startActivity(intent)
        } catch (e: ActivityNotFoundException) {
            Toast.makeText(context, "No app found to open this file", Toast.LENGTH_SHORT).show()
        }
    }
    
    private fun getMimeType(uri: Uri): String? {
        return context.contentResolver.getType(uri)
    }
}

// Custom file view for RecyclerView
class FilePostViewHolder(
    private val binding: ItemFilePostBinding,
    private val fileManager: FilePostManager
) : RecyclerView.ViewHolder(binding.root) {
    
    fun bind(fileData: AmityFilePostData) {
        val fileInfo = fileData.getFileInfo()
        
        binding.apply {
            fileNameText.text = fileInfo.fileName
            fileSizeText.text = fileManager.formatFileSize(fileInfo.fileSize)
            fileIcon.setImageResource(fileManager.getFileIconResource(fileInfo.mimeType))
            
            downloadButton.setOnClickListener {
                downloadFile(fileData)
            }
            
            // Show file type badge
            fileTypeBadge.text = fileInfo.fileExtension.uppercase()
        }
    }
    
    private fun downloadFile(fileData: AmityFilePostData) {
        binding.downloadButton.isEnabled = false
        binding.progressBar.visibility = View.VISIBLE
        
        fileManager.downloadFile(
            fileData = fileData,
            progressCallback = { progress ->
                binding.progressBar.progress = progress
            },
            completion = { result ->
                binding.downloadButton.isEnabled = true
                binding.progressBar.visibility = View.GONE
                
                result.fold(
                    onSuccess = { uri ->
                        fileManager.openFile(uri)
                        Toast.makeText(
                            binding.root.context,
                            "File downloaded successfully",
                            Toast.LENGTH_SHORT
                        ).show()
                    },
                    onFailure = { error ->
                        Toast.makeText(
                            binding.root.context,
                            "Download failed: ${error.message}",
                            Toast.LENGTH_SHORT
                        ).show()
                    }
                )
            }
        )
    }
}

// Basic file post processing
function processFilePost(post: AmityPost): void {
  const fileData = post.data as AmityFilePostData;
  if (!fileData) return;
  
  // Get file information
  const fileInfo = fileData.getFileInfo();
  console.log('File name:', fileInfo.fileName);
  console.log('File size:', fileInfo.fileSize, 'bytes');
  console.log('MIME type:', fileInfo.mimeType);
  console.log('File extension:', fileInfo.fileExtension);
  
  // Download file
  downloadFile(fileData);
}

// Advanced: File manager with download capabilities
class FilePostManager {
  private downloadQueue = new Map<string, AbortController>();
  
  async downloadFile(
    fileData: AmityFilePostData,
    progressCallback?: (progress: number) => void,
    onComplete?: (blob: Blob) => void
  ): Promise<void> {
    const fileInfo = fileData.getFileInfo();
    const fileId = fileInfo.fileId;
    
    // Cancel existing download if any
    this.cancelDownload(fileId);
    
    const abortController = new AbortController();
    this.downloadQueue.set(fileId, abortController);
    
    try {
      const response = await fetch(fileData.fileUrl, {
        signal: abortController.signal
      });
      
      if (!response.ok) {
        throw new Error(`Download failed: ${response.statusText}`);
      }
      
      const contentLength = response.headers.get('content-length');
      const total = contentLength ? parseInt(contentLength, 10) : 0;
      let loaded = 0;
      
      const reader = response.body?.getReader();
      const chunks: Uint8Array[] = [];
      
      if (!reader) {
        throw new Error('Failed to read response body');
      }
      
      while (true) {
        const { done, value } = await reader.read();
        
        if (done) break;
        
        chunks.push(value);
        loaded += value.length;
        
        if (total > 0 && progressCallback) {
          const progress = Math.round((loaded / total) * 100);
          progressCallback(progress);
        }
      }
      
      const blob = new Blob(chunks, { type: fileInfo.mimeType });
      
      if (onComplete) {
        onComplete(blob);
      } else {
        this.saveFile(blob, fileInfo.fileName);
      }
      
    } catch (error) {
      if (error instanceof Error && error.name !== 'AbortError') {
        console.error('Download error:', error);
        throw error;
      }
    } finally {
      this.downloadQueue.delete(fileId);
    }
  }
  
  private saveFile(blob: Blob, fileName: string): void {
    const url = URL.createObjectURL(blob);
    const link = document.createElement('a');
    link.href = url;
    link.download = fileName;
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
    URL.revokeObjectURL(url);
  }
  
  cancelDownload(fileId: string): void {
    const controller = this.downloadQueue.get(fileId);
    if (controller) {
      controller.abort();
      this.downloadQueue.delete(fileId);
    }
  }
  
  // Get file icon class based on MIME type
  getFileIconClass(mimeType: string): string {
    if (mimeType.includes('pdf')) return 'fas fa-file-pdf';
    if (mimeType.includes('word') || mimeType.includes('document')) return 'fas fa-file-word';
    if (mimeType.includes('sheet') || mimeType.includes('excel')) return 'fas fa-file-excel';
    if (mimeType.includes('presentation') || mimeType.includes('powerpoint')) return 'fas fa-file-powerpoint';
    if (mimeType.includes('zip') || mimeType.includes('rar')) return 'fas fa-file-archive';
    if (mimeType.includes('image')) return 'fas fa-file-image';
    if (mimeType.includes('video')) return 'fas fa-file-video';
    if (mimeType.includes('audio')) return 'fas fa-file-audio';
    if (mimeType.includes('text') || mimeType.includes('code')) return 'fas fa-file-code';
    return 'fas fa-file';
  }
  
  // Format file size for display
  formatFileSize(bytes: number): string {
    const units = ['B', 'KB', 'MB', 'GB'];
    let size = bytes;
    let unitIndex = 0;
    
    while (size >= 1024 && unitIndex < units.length - 1) {
      size /= 1024;
      unitIndex++;
    }
    
    return `${size.toFixed(1)} ${units[unitIndex]}`;
  }
  
  // Preview file in new tab (for supported types)
  previewFile(fileData: AmityFilePostData): void {
    const fileInfo = fileData.getFileInfo();
    const supportedTypes = ['application/pdf', 'text/plain', 'text/html'];
    
    if (supportedTypes.includes(fileInfo.mimeType)) {
      window.open(fileData.fileUrl, '_blank');
    } else {
      console.log('Preview not supported for this file type');
    }
  }
}

// React component for file post
interface FilePostProps {
  fileData: AmityFilePostData;
  className?: string;
}

function FilePost({ fileData, className = '' }: FilePostProps) {
  const [downloadProgress, setDownloadProgress] = useState(0);
  const [isDownloading, setIsDownloading] = useState(false);
  const fileManager = useMemo(() => new FilePostManager(), []);
  
  const fileInfo = fileData.getFileInfo();
  
  const handleDownload = async () => {
    setIsDownloading(true);
    setDownloadProgress(0);
    
    try {
      await fileManager.downloadFile(
        fileData,
        (progress) => setDownloadProgress(progress)
      );
    } catch (error) {
      console.error('Download failed:', error);
      alert('Download failed. Please try again.');
    } finally {
      setIsDownloading(false);
      setDownloadProgress(0);
    }
  };
  
  const handlePreview = () => {
    fileManager.previewFile(fileData);
  };
  
  return (
    <div className={`file-post ${className}`}>
      <div className="file-info">
        <i className={`file-icon ${fileManager.getFileIconClass(fileInfo.mimeType)}`} />
        <div className="file-details">
          <h4 className="file-name">{fileInfo.fileName}</h4>
          <p className="file-size">{fileManager.formatFileSize(fileInfo.fileSize)}</p>
          <span className="file-type">{fileInfo.fileExtension.toUpperCase()}</span>
        </div>
      </div>
      
      {isDownloading && (
        <div className="download-progress">
          <div className="progress-bar">
            <div 
              className="progress-fill" 
              style={{ width: `${downloadProgress}%` }}
            />
          </div>
          <span>{downloadProgress}%</span>
        </div>
      )}
      
      <div className="file-actions">
        <button 
          onClick={handleDownload}
          disabled={isDownloading}
          className="download-btn"
        >
          {isDownloading ? 'Downloading...' : 'Download'}
        </button>
        <button 
          onClick={handlePreview}
          className="preview-btn"
        >
          Preview
        </button>
      </div>
    </div>
  );
}

// Basic file post processing
void processFilePost(AmityPost post) {
  final fileData = post.data as AmityFilePostData?;
  if (fileData == null) return;
  
  // Get file information
  final fileInfo = fileData.getFileInfo();
  print('File name: ${fileInfo.fileName}');
  print('File size: ${fileInfo.fileSize} bytes');
  print('MIME type: ${fileInfo.mimeType}');
  print('File extension: ${fileInfo.fileExtension}');
  
  // Download file
  downloadFile(fileData);
}

// Advanced: File manager with download capabilities
class FilePostManager {
  final Dio _dio = Dio();
  final Map<String, CancelToken> _downloadTokens = {};
  
  Future<void> downloadFile(
    AmityFilePostData fileData, {
    Function(int)? onProgress,
    Function(String)? onComplete,
    Function(String)? onError,
  }) async {
    final fileInfo = fileData.getFileInfo();
    final fileName = fileInfo.fileName;
    final fileId = fileInfo.fileId;
    
    // Cancel existing download if any
    cancelDownload(fileId);
    
    try {
      // Request storage permission
      if (!await _requestStoragePermission()) {
        onError?.call('Storage permission denied');
        return;
      }
      
      final directory = await getApplicationDocumentsDirectory();
      final filePath = '${directory.path}/$fileName';
      
      final cancelToken = CancelToken();
      _downloadTokens[fileId] = cancelToken;
      
      await _dio.download(
        fileData.fileUrl,
        filePath,
        cancelToken: cancelToken,
        onReceiveProgress: (received, total) {
          if (total != -1) {
            final progress = ((received / total) * 100).round();
            onProgress?.call(progress);
          }
        },
      );
      
      _downloadTokens.remove(fileId);
      onComplete?.call(filePath);
      
    } on DioException catch (e) {
      _downloadTokens.remove(fileId);
      if (e.type != DioExceptionType.cancel) {
        onError?.call(e.message ?? 'Download failed');
      }
    } catch (e) {
      _downloadTokens.remove(fileId);
      onError?.call(e.toString());
    }
  }
  
  void cancelDownload(String fileId) {
    final token = _downloadTokens[fileId];
    if (token != null && !token.isCancelled) {
      token.cancel();
      _downloadTokens.remove(fileId);
    }
  }
  
  Future<bool> _requestStoragePermission() async {
    if (Platform.isAndroid) {
      final status = await Permission.storage.request();
      return status == PermissionStatus.granted;
    }
    return true; // iOS handles this automatically
  }
  
  // Get file icon based on MIME type
  IconData getFileIcon(String mimeType) {
    if (mimeType.contains('pdf')) return Icons.picture_as_pdf;
    if (mimeType.contains('word') || mimeType.contains('document')) return Icons.description;
    if (mimeType.contains('sheet') || mimeType.contains('excel')) return Icons.table_chart;
    if (mimeType.contains('presentation') || mimeType.contains('powerpoint')) return Icons.slideshow;
    if (mimeType.contains('zip') || mimeType.contains('rar')) return Icons.archive;
    if (mimeType.contains('image')) return Icons.image;
    if (mimeType.contains('video')) return Icons.video_file;
    if (mimeType.contains('audio')) return Icons.audio_file;
    if (mimeType.contains('text') || mimeType.contains('code')) return Icons.code;
    return Icons.insert_drive_file;
  }
  
  // Format file size for display
  String formatFileSize(int bytes) {
    const units = ['B', 'KB', 'MB', 'GB'];
    double size = bytes.toDouble();
    int unitIndex = 0;
    
    while (size >= 1024 && unitIndex < units.length - 1) {
      size /= 1024;
      unitIndex++;
    }
    
    return '${size.toStringAsFixed(1)} ${units[unitIndex]}';
  }
  
  // Open file with system app
  Future<void> openFile(String filePath) async {
    try {
      await OpenFile.open(filePath);
    } catch (e) {
      print('Failed to open file: $e');
    }
  }
  
  // Get file color based on type
  Color getFileColor(String mimeType) {
    if (mimeType.contains('pdf')) return Colors.red;
    if (mimeType.contains('word') || mimeType.contains('document')) return Colors.blue;
    if (mimeType.contains('sheet') || mimeType.contains('excel')) return Colors.green;
    if (mimeType.contains('presentation') || mimeType.contains('powerpoint')) return Colors.orange;
    if (mimeType.contains('zip') || mimeType.contains('rar')) return Colors.purple;
    if (mimeType.contains('image')) return Colors.pink;
    if (mimeType.contains('video')) return Colors.indigo;
    if (mimeType.contains('audio')) return Colors.teal;
    return Colors.grey;
  }
}

// File post widget
class FilePostWidget extends StatefulWidget {
  final AmityFilePostData fileData;
  final VoidCallback? onTap;
  
  const FilePostWidget({
    Key? key,
    required this.fileData,
    this.onTap,
  }) : super(key: key);
  
  @override
  State<FilePostWidget> createState() => _FilePostWidgetState();
}

class _FilePostWidgetState extends State<FilePostWidget> {
  final FilePostManager _fileManager = FilePostManager();
  int _downloadProgress = 0;
  bool _isDownloading = false;
  
  @override
  Widget build(BuildContext context) {
    final fileInfo = widget.fileData.getFileInfo();
    final fileColor = _fileManager.getFileColor(fileInfo.mimeType);
    
    return Card(
      margin: const EdgeInsets.symmetric(vertical: 8),
      child: Padding(
        padding: const EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Row(
              children: [
                Container(
                  padding: const EdgeInsets.all(12),
                  decoration: BoxDecoration(
                    color: fileColor.withOpacity(0.1),
                    borderRadius: BorderRadius.circular(8),
                  ),
                  child: Icon(
                    _fileManager.getFileIcon(fileInfo.mimeType),
                    color: fileColor,
                    size: 32,
                  ),
                ),
                const SizedBox(width: 12),
                Expanded(
                  child: Column(
                    crossAxisAlignment: CrossAxisAlignment.start,
                    children: [
                      Text(
                        fileInfo.fileName,
                        style: const TextStyle(
                          fontSize: 16,
                          fontWeight: FontWeight.w600,
                        ),
                        maxLines: 2,
                        overflow: TextOverflow.ellipsis,
                      ),
                      const SizedBox(height: 4),
                      Row(
                        children: [
                          Text(
                            _fileManager.formatFileSize(fileInfo.fileSize),
                            style: TextStyle(
                              color: Colors.grey[600],
                              fontSize: 14,
                            ),
                          ),
                          const SizedBox(width: 8),
                          Container(
                            padding: const EdgeInsets.symmetric(
                              horizontal: 6,
                              vertical: 2,
                            ),
                            decoration: BoxDecoration(
                              color: fileColor.withOpacity(0.1),
                              borderRadius: BorderRadius.circular(4),
                            ),
                            child: Text(
                              fileInfo.fileExtension.toUpperCase(),
                              style: TextStyle(
                                color: fileColor,
                                fontSize: 12,
                                fontWeight: FontWeight.w600,
                              ),
                            ),
                          ),
                        ],
                      ),
                    ],
                  ),
                ),
              ],
            ),
            if (_isDownloading) ...[
              const SizedBox(height: 12),
              Column(
                children: [
                  LinearProgressIndicator(
                    value: _downloadProgress / 100,
                    backgroundColor: Colors.grey[300],
                    valueColor: AlwaysStoppedAnimation<Color>(fileColor),
                  ),
                  const SizedBox(height: 4),
                  Text('$_downloadProgress%'),
                ],
              ),
            ],
            const SizedBox(height: 12),
            Row(
              children: [
                Expanded(
                  child: ElevatedButton.icon(
                    onPressed: _isDownloading ? null : _downloadFile,
                    icon: Icon(_isDownloading ? Icons.hourglass_empty : Icons.download),
                    label: Text(_isDownloading ? 'Downloading...' : 'Download'),
                    style: ElevatedButton.styleFrom(
                      backgroundColor: fileColor,
                      foregroundColor: Colors.white,
                    ),
                  ),
                ),
                if (_isDownloading) ...[
                  const SizedBox(width: 8),
                  OutlinedButton(
                    onPressed: _cancelDownload,
                    child: const Text('Cancel'),
                  ),
                ],
              ],
            ),
          ],
        ),
      ),
    );
  }
  
  void _downloadFile() {
    setState(() {
      _isDownloading = true;
      _downloadProgress = 0;
    });
    
    _fileManager.downloadFile(
      widget.fileData,
      onProgress: (progress) {
        setState(() {
          _downloadProgress = progress;
        });
      },
      onComplete: (filePath) {
        setState(() {
          _isDownloading = false;
        });
        
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: const Text('File downloaded successfully'),
            action: SnackBarAction(
              label: 'Open',
              onPressed: () => _fileManager.openFile(filePath),
            ),
          ),
        );
      },
      onError: (error) {
        setState(() {
          _isDownloading = false;
        });
        
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: Text('Download failed: $error'),
            backgroundColor: Colors.red,
          ),
        );
      },
    );
  }
  
  void _cancelDownload() {
    final fileInfo = widget.fileData.getFileInfo();
    _fileManager.cancelDownload(fileInfo.fileId);
    
    setState(() {
      _isDownloading = false;
      _downloadProgress = 0;
    });
  }
}