#!/bin/bash

# BBeOS Firmware Extraction Tool
# Extracts and analyzes BlackBerry 10 firmware for Q20

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
EXTRACT_DIR="$PROJECT_ROOT/firmware"
TOOLS_DIR="$PROJECT_ROOT/tools"

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Logging functions
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Check dependencies
check_dependencies() {
    log_info "Checking dependencies..."
    
    local deps=("wget" "unzip" "tar" "hexdump" "strings" "file")
    local missing_deps=()
    
    for dep in "${deps[@]}"; do
        if ! command -v "$dep" &> /dev/null; then
            missing_deps+=("$dep")
        fi
    done
    
    if [ ${#missing_deps[@]} -ne 0 ]; then
        log_error "Missing dependencies: ${missing_deps[*]}"
        log_info "Please install the missing packages and try again."
        exit 1
    fi
    
    log_success "All dependencies found"
}

# Create directories
setup_directories() {
    log_info "Setting up directories..."
    
    mkdir -p "$EXTRACT_DIR"
    mkdir -p "$EXTRACT_DIR/autoloader"
    mkdir -p "$EXTRACT_DIR/partitions"
    mkdir -p "$EXTRACT_DIR/analysis"
    mkdir -p "$TOOLS_DIR"
    
    log_success "Directories created"
}

# Download firmware (placeholder - user needs to provide actual firmware)
download_firmware() {
    log_info "Firmware download section"
    log_warning "You need to manually download the BB10 firmware for Q20"
    log_info "Place the firmware file in: $EXTRACT_DIR/autoloader/"
    log_info "Common firmware files:"
    log_info "  - *.signed (autoloader format)"
    log_info "  - *.zip (extracted autoloader)"
    log_info "  - *.bar files (individual apps)"
    
    if [ -z "$(ls -A "$EXTRACT_DIR/autoloader" 2>/dev/null)" ]; then
        log_error "No firmware files found in $EXTRACT_DIR/autoloader/"
        log_info "Please download the firmware and place it in the autoloader directory"
        exit 1
    fi
}

# Extract autoloader
extract_autoloader() {
    log_info "Extracting autoloader..."
    
    local autoloader_dir="$EXTRACT_DIR/autoloader"
    local partitions_dir="$EXTRACT_DIR/partitions"
    
    for file in "$autoloader_dir"/*; do
        if [[ "$file" == *.signed ]]; then
            log_info "Processing signed autoloader: $(basename "$file")"
            # Extract signed autoloader
            # This is a placeholder - actual extraction depends on the format
            cp "$file" "$partitions_dir/"
        elif [[ "$file" == *.zip ]]; then
            log_info "Extracting ZIP autoloader: $(basename "$file")"
            unzip -q "$file" -d "$partitions_dir/"
        fi
    done
    
    log_success "Autoloader extraction completed"
}

# Analyze partitions
analyze_partitions() {
    log_info "Analyzing partitions..."
    
    local partitions_dir="$EXTRACT_DIR/partitions"
    local analysis_dir="$EXTRACT_DIR/analysis"
    
    # Find and analyze partition files
    find "$partitions_dir" -type f -exec sh -c '
        echo "=== Analyzing: $1 ===" >> "$2/partition_analysis.txt"
        file "$1" >> "$2/partition_analysis.txt"
        echo "" >> "$2/partition_analysis.txt"
        
        # Extract strings for analysis
        echo "=== Strings from: $1 ===" >> "$2/strings_$(basename "$1").txt"
        strings "$1" | head -100 >> "$2/strings_$(basename "$1").txt"
        echo "" >> "$2/strings_$(basename "$1").txt"
        
        # Hex dump for binary analysis
        echo "=== Hex dump of first 1KB: $1 ===" >> "$2/hexdump_$(basename "$1").txt"
        hexdump -C "$1" | head -50 >> "$2/hexdump_$(basename "$1").txt"
        echo "" >> "$2/hexdump_$(basename "$1").txt"
    ' _ {} "$analysis_dir" \;
    
    log_success "Partition analysis completed"
}

# Extract device tree and kernel info
extract_system_info() {
    log_info "Extracting system information..."
    
    local partitions_dir="$EXTRACT_DIR/partitions"
    local analysis_dir="$EXTRACT_DIR/analysis"
    
    # Look for device tree blobs
    find "$partitions_dir" -name "*.dtb" -o -name "*.dts" | while read -r dtb_file; do
        log_info "Found device tree: $(basename "$dtb_file")"
        cp "$dtb_file" "$analysis_dir/"
        
        # Try to decompile DTB to DTS
        if [[ "$dtb_file" == *.dtb ]]; then
            if command -v dtc &> /dev/null; then
                dtc -I dtb -O dts -o "$analysis_dir/$(basename "$dtb_file" .dtb).dts" "$dtb_file" 2>/dev/null || true
            fi
        fi
    done
    
    # Look for kernel images
    find "$partitions_dir" -name "*kernel*" -o -name "*boot*" -o -name "*Image*" | while read -r kernel_file; do
        log_info "Found kernel image: $(basename "$kernel_file")"
        cp "$kernel_file" "$analysis_dir/"
    done
    
    log_success "System information extraction completed"
}

# Generate analysis report
generate_report() {
    log_info "Generating analysis report..."
    
    local analysis_dir="$EXTRACT_DIR/analysis"
    local report_file="$analysis_dir/firmware_analysis_report.md"
    
    cat > "$report_file" << EOF
# BlackBerry Q20 Firmware Analysis Report

## Analysis Date
$(date)

## Extracted Files
$(find "$EXTRACT_DIR/partitions" -type f -exec basename {} \; | sort)

## Device Tree Files
$(find "$analysis_dir" -name "*.dtb" -o -name "*.dts" | xargs -I {} basename {} | sort)

## Kernel Images
$(find "$analysis_dir" -name "*kernel*" -o -name "*boot*" -o -name "*Image*" | xargs -I {} basename {} | sort)

## Partition Analysis
\`\`\`
$(cat "$analysis_dir/partition_analysis.txt" 2>/dev/null || echo "No partition analysis available")
\`\`\`

## Key Findings
- [ ] Bootloader signature verification method identified
- [ ] Device tree structure documented
- [ ] Kernel configuration extracted
- [ ] Proprietary drivers identified
- [ ] Firmware blobs catalogued

## Next Steps
1. Analyze bootloader security
2. Extract kernel configuration
3. Identify required drivers
4. Document hardware interfaces
5. Plan driver development

EOF
    
    log_success "Analysis report generated: $report_file"
}

# Main execution
main() {
    log_info "Starting BBeOS firmware extraction and analysis..."
    
    check_dependencies
    setup_directories
    download_firmware
    extract_autoloader
    analyze_partitions
    extract_system_info
    generate_report
    
    log_success "Firmware extraction and analysis completed!"
    log_info "Results available in: $EXTRACT_DIR/analysis/"
    log_info "Review the analysis report: $EXTRACT_DIR/analysis/firmware_analysis_report.md"
}

# Run main function
main "$@"