public class AppBundleExplorer {
    public static let shared = AppBundleExplorer()
    
    public func getBundleContents() -> BundleContents
    public func searchFiles(query: String) -> [BundleItem]
    public func previewFile(_ item: BundleItem) -> FilePreview?
    public func extractAssets() -> [AssetItem]
}

struct BundleContents {
    let rootPath: URL
    let items: [BundleItem]
    let totalSize: Int64
    let statistics: BundleStatistics
}

struct BundleItem: Identifiable {
    let id: UUID
    let name: String
    let path: URL
    let type: FileType
    let size: Int64
    let createdAt: Date
    let modifiedAt: Date
    let isDirectory: Bool
    
    enum FileType {
        case image, text, json, plist, binary, archive, media, other
    }
}

struct BundleStatistics {
    let totalFiles: Int
    let totalDirectories: Int
    let imageCount: Int
    let textFileCount: Int
    let largestFile: BundleItem?
    let typeBreakdown: [BundleItem.FileType: Int]
}

func getBundleContents(at path: URL? = nil) -> BundleContents {
    let bundlePath = path ?? Bundle.main.bundleURL
    let fileManager = FileManager.default
    
    var items: [BundleItem] = []
    var totalSize: Int64 = 0
    
    guard let enumerator = fileManager.enumerator(
        at: bundlePath,
        includingPropertiesForKeys: [
            .fileSizeKey,
            .isDirectoryKey,
            .creationDateKey,
            .contentModificationDateKey
        ]
    ) else {
        return BundleContents(
            rootPath: bundlePath,
            items: [],
            totalSize: 0,
            statistics: BundleStatistics(
                totalFiles: 0,
                totalDirectories: 0,
                imageCount: 0,
                textFileCount: 0,
                largestFile: nil,
                typeBreakdown: [:]
            )
        )
    }
    
    for case let fileURL as URL in enumerator {
        do {
            let resourceValues = try fileURL.resourceValues(
                forKeys: [
                    .fileSizeKey,
                    .isDirectoryKey,
                    .creationDateKey,
                    .contentModificationDateKey
                ]
            )
            
            let isDirectory = resourceValues.isDirectory ?? false
            let size = Int64(resourceValues.fileSize ?? 0)
            
            let item = BundleItem(
                id: UUID(),
                name: fileURL.lastPathComponent,
                path: fileURL,
                type: determineFileType(fileURL),
                size: size,
                createdAt: resourceValues.creationDate ?? Date(),
                modifiedAt: resourceValues.contentModificationDate ?? Date(),
                isDirectory: isDirectory
            )
            
            items.append(item)
            
            if !isDirectory {
                totalSize += size
            }
        } catch {
            print("Error reading file: \(error)")
        }
    }
    
    let statistics = calculateStatistics(items)
    
    return BundleContents(
        rootPath: bundlePath,
        items: items.sorted { $0.name < $1.name },
        totalSize: totalSize,
        statistics: statistics
    )
}

func determineFileType(_ url: URL) -> BundleItem.FileType {
    let ext = url.pathExtension.lowercased()
    
    switch ext {
    case "png", "jpg", "jpeg", "gif", "heic", "svg":
        return .image
    case "txt", "md", "swift", "m", "h", "c", "cpp":
        return .text
    case "json":
        return .json
    case "plist":
        return .plist
    case "zip", "tar", "gz":
        return .archive
    case "mp4", "mov", "mp3", "m4a":
        return .media
    default:
        // Check if it's a text file
        if let data = try? Data(contentsOf: url, options: .mappedIfSafe),
           String(data: data, encoding: .utf8) != nil {
            return .text
        }
        return .binary
    }
}

func extractAssets() -> [AssetItem] {
    var assets: [AssetItem] = []
    
    // Find Assets.car file
    guard let assetsURL = Bundle.main.url(
        forResource: "Assets",
        withExtension: "car"
    ) else {
        return []
    }
    
    // Use CUICatalog to read asset catalog (private API, for debug builds only)
    #if DEBUG
    if let catalog = CUICatalog(url: assetsURL) {
        for rendition in catalog.allRenditions() {
            let asset = AssetItem(
                name: rendition.name,
                type: determineAssetType(rendition),
                size: rendition.data.count,
                scale: rendition.scale,
                idiom: rendition.idiom
            )
            assets.append(asset)
        }
    }
    #endif
    
    return assets
}

struct AssetItem: Identifiable {
    let id = UUID()
    let name: String
    let type: AssetType
    let size: Int
    let scale: CGFloat
    let idiom: String
    
    enum AssetType {
        case image, color, data
    }
}

func previewFile(_ item: BundleItem) -> FilePreview? {
    switch item.type {
    case .image:
        return previewImage(item)
    case .text, .json:
        return previewText(item)
    case .plist:
        return previewPlist(item)
    default:
        return nil
    }
}

func previewImage(_ item: BundleItem) -> FilePreview {
    guard let image = UIImage(contentsOfFile: item.path.path) else {
        return FilePreview(type: .error, content: "Failed to load image")
    }
    
    let metadata = """
    Dimensions: \(Int(image.size.width)) x \(Int(image.size.height))
    Scale: \(image.scale)x
    Orientation: \(image.imageOrientation.rawValue)
    """
    
    return FilePreview(type: .image, content: image, metadata: metadata)
}

func previewText(_ item: BundleItem) -> FilePreview {
    guard let content = try? String(contentsOf: item.path, encoding: .utf8) else {
        return FilePreview(type: .error, content: "Failed to read file")
    }
    
    return FilePreview(type: .text, content: content)
}

func previewPlist(_ item: BundleItem) -> FilePreview {
    guard let data = try? Data(contentsOf: item.path),
          let plist = try? PropertyListSerialization.propertyList(
            from: data,
            options: [],
            format: nil
          ) else {
        return FilePreview(type: .error, content: "Failed to parse plist")
    }
    
    let jsonData = try? JSONSerialization.data(withJSONObject: plist, options: .prettyPrinted)
    let jsonString = jsonData.flatMap { String(data: $0, encoding: .utf8) } ?? "Error"
    
    return FilePreview(type: .text, content: jsonString)
}

struct FilePreview {
    enum PreviewType {
        case image, text, error
    }
    
    let type: PreviewType
    let content: Any
    let metadata: String?
    
    init(type: PreviewType, content: Any, metadata: String? = nil) {
        self.type = type
        self.content = content
        self.metadata = metadata
    }
}

func searchFiles(query: String, in path: URL? = nil) -> [BundleItem] {
    let contents = getBundleContents(at: path)
    let lowercaseQuery = query.lowercased()
    
    return contents.items.filter { item in
        // Search by filename
        if item.name.lowercased().contains(lowercaseQuery) {
            return true
        }
        
        // Search within text files
        if item.type == .text || item.type == .json {
            if let content = try? String(contentsOf: item.path, encoding: .utf8),
               content.lowercased().contains(lowercaseQuery) {
                return true
            }
        }
        
        return false
    }
}

### App Bundle Explorer
- Browse app bundle file structure
- View embedded resources
- Extract and share files
- Search within bundle
- Preview assets and configurations

// Access bundle explorer
DebugSwift.Resources.showBundleExplorer()

// Search files
let results = DebugSwift.Bundle.search("config")

// Extract specific file
DebugSwift.Bundle.export(file: "config.json")