#!/bin/bash

# BBeOS Telephony Build Script
# Builds telephony components and integrates them into the system

set -e

echo "Building BBeOS telephony components..."

# Configuration
TELEPHONY_DIR="src/telephony"
BUILD_DIR="build/telephony"
ROOTFS_DIR="build/rootfs"
KERNEL_SRC="vendor/kernel-source"

# Set up environment
export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabihf-

# Check for required tools
check_dependencies() {
    echo "Checking build dependencies..."
    
    # Check for cross-compiler
    if ! command -v arm-linux-gnueabihf-gcc &> /dev/null; then
        echo "Error: ARM cross-compiler not found"
        echo "Please install: sudo apt-get install gcc-arm-linux-gnueabihf"
        exit 1
    fi
    
    # Check for kernel source
    if [ ! -d "$KERNEL_SRC" ]; then
        echo "Error: Kernel source not found at $KERNEL_SRC"
        echo "Please run: ./scripts/build-kernel-minimal.sh first"
        exit 1
    fi
}

# Create build directory
setup_build() {
    echo "Setting up build directory..."
    rm -rf $BUILD_DIR
    mkdir -p $BUILD_DIR
    
    # Copy telephony source to build directory
    cp -r $TELEPHONY_DIR/* $BUILD_DIR/
}

# Build telephony components
build_telephony() {
    echo "Building telephony components..."
    cd $BUILD_DIR
    
    # Set kernel source path
    export KERNEL_SRC=../$KERNEL_SRC
    
    # Build modem driver
    echo "Building Q20 modem driver..."
    if [ -f "modem/q20-modem.c" ]; then
        make -C modem KERNEL_SRC=$KERNEL_SRC modules
        if [ ! -f "modem/q20-modem.ko" ]; then
            echo "Warning: Failed to build modem driver"
        else
            echo "Modem driver built successfully"
        fi
    else
        echo "Warning: Modem source not found"
    fi
    
    # Build voice driver
    echo "Building Q20 voice driver..."
    if [ -f "voice/q20-voice.c" ]; then
        make -C voice KERNEL_SRC=$KERNEL_SRC modules
        if [ ! -f "voice/q20-voice.ko" ]; then
            echo "Warning: Failed to build voice driver"
        else
            echo "Voice driver built successfully"
        fi
    else
        echo "Warning: Voice source not found"
    fi
    
    # Build SMS driver
    echo "Building Q20 SMS driver..."
    if [ -f "sms/q20-sms.c" ]; then
        make -C sms KERNEL_SRC=$KERNEL_SRC modules
        if [ ! -f "sms/q20-sms.ko" ]; then
            echo "Warning: Failed to build SMS driver"
        else
            echo "SMS driver built successfully"
        fi
    else
        echo "Warning: SMS source not found"
    fi
    
    cd ..
}

# Create telephony applications
create_apps() {
    echo "Creating telephony applications..."
    mkdir -p $BUILD_DIR/apps
    
    # Create dialer application
    cat > $BUILD_DIR/apps/dialer.c << 'EOF'
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    printf("Q20 Dialer Application\n");
    printf("======================\n");
    
    if (argc < 2) {
        printf("Usage: dialer <phone_number>\n");
        printf("Example: dialer +1234567890\n");
        return 1;
    }
    
    printf("Dialing %s...\n", argv[1]);
    printf("(This is a stub - actual dialing requires modem integration)\n");
    
    return 0;
}
EOF

    # Create SMS application
    cat > $BUILD_DIR/apps/sms-app.c << 'EOF'
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    printf("Q20 SMS Application\n");
    printf("===================\n");
    
    if (argc < 3) {
        printf("Usage: sms-app <phone_number> <message>\n");
        printf("Example: sms-app +1234567890 \"Hello World\"\n");
        return 1;
    }
    
    printf("Sending SMS to %s: %s\n", argv[1], argv[2]);
    printf("(This is a stub - actual SMS requires modem integration)\n");
    
    return 0;
}
EOF

    # Compile applications
    echo "Compiling telephony applications..."
    arm-linux-gnueabihf-gcc -o $BUILD_DIR/apps/dialer $BUILD_DIR/apps/dialer.c
    arm-linux-gnueabihf-gcc -o $BUILD_DIR/apps/sms-app $BUILD_DIR/apps/sms-app.c
    
    echo "Telephony applications created"
}

# Create telephony configuration
create_config() {
    echo "Creating telephony configuration..."
    mkdir -p $BUILD_DIR/config
    
    # Create modem configuration
    cat > $BUILD_DIR/config/modem.conf << 'EOF'
# Q20 Modem Configuration
# BlackBerry Classic Q20 MDM9615 Modem

[modem]
vendor_id = 0x05c6
product_id = 0x9001
interface = 0

[gpio]
power = 25
reset = 26
wake = 27

[regulators]
vdd = pm8921_lvs1
vddio = pm8921_lvs2

[qmi]
control_service = 0x00
wds_service = 0x01
nas_service = 0x03
wms_service = 0x05
voice_service = 0x09
EOF

    # Create voice configuration
    cat > $BUILD_DIR/config/voice.conf << 'EOF'
# Q20 Voice Configuration
# BlackBerry Classic Q20 Voice Call System

[audio]
speaker_gpio = 28
mic_gpio = 29
headset_detect_gpio = 30
vibrator_gpio = 31

[regulators]
audio_vdd = pm8921_lvs3

[call_control]
send_key = KEY_SEND
end_key = KEY_END
volume_up = KEY_VOLUMEUP
volume_down = KEY_VOLUMEDOWN

[features]
speaker_phone = true
mute = true
hold = true
conference = false
EOF

    # Create SMS configuration
    cat > $BUILD_DIR/config/sms.conf << 'EOF'
# Q20 SMS Configuration
# BlackBerry Classic Q20 SMS System

[storage]
max_messages = 1000
max_length = 160
storage_path = /data/sms_messages.dat

[notifications]
vibrate = true
led_flash = true
sound = true

[hardware]
vibrator_gpio = 31
led_gpio = 32

[features]
flash_sms = true
concatenated_sms = true
delivery_reports = true
EOF

    echo "Telephony configuration created"
}

# Install to rootfs
install_to_rootfs() {
    echo "Installing telephony components to rootfs..."
    
    if [ ! -d "$ROOTFS_DIR" ]; then
        echo "Creating rootfs directory..."
        mkdir -p $ROOTFS_DIR
    fi
    
    # Create directory structure
    mkdir -p $ROOTFS_DIR/lib/modules/$(uname -r)/extra
    mkdir -p $ROOTFS_DIR/usr/bin
    mkdir -p $ROOTFS_DIR/etc/bbeos/telephony
    mkdir -p $ROOTFS_DIR/data
    
    # Install kernel modules
    if [ -f "$BUILD_DIR/modem/q20-modem.ko" ]; then
        cp $BUILD_DIR/modem/q20-modem.ko $ROOTFS_DIR/lib/modules/$(uname -r)/extra/
    fi
    
    if [ -f "$BUILD_DIR/voice/q20-voice.ko" ]; then
        cp $BUILD_DIR/voice/q20-voice.ko $ROOTFS_DIR/lib/modules/$(uname -r)/extra/
    fi
    
    if [ -f "$BUILD_DIR/sms/q20-sms.ko" ]; then
        cp $BUILD_DIR/sms/q20-sms.ko $ROOTFS_DIR/lib/modules/$(uname -r)/extra/
    fi
    
    # Install applications
    if [ -f "$BUILD_DIR/apps/dialer" ]; then
        cp $BUILD_DIR/apps/dialer $ROOTFS_DIR/usr/bin/
        chmod +x $ROOTFS_DIR/usr/bin/dialer
    fi
    
    if [ -f "$BUILD_DIR/apps/sms-app" ]; then
        cp $BUILD_DIR/apps/sms-app $ROOTFS_DIR/usr/bin/
        chmod +x $ROOTFS_DIR/usr/bin/sms-app
    fi
    
    # Install configuration
    if [ -d "$BUILD_DIR/config" ]; then
        cp $BUILD_DIR/config/* $ROOTFS_DIR/etc/bbeos/telephony/
    fi
    
    # Create telephony startup script
    cat > $ROOTFS_DIR/usr/bin/start-telephony << 'EOF'
#!/bin/sh

# BBeOS Telephony Startup Script
# Starts telephony services and drivers

echo "Starting BBeOS telephony system..."

# Load kernel modules
echo "Loading telephony kernel modules..."
modprobe q20-modem
modprobe q20-voice
modprobe q20-sms

# Wait for modules to load
sleep 2

# Check if modules loaded successfully
if lsmod | grep -q "q20_modem"; then
    echo "Modem driver loaded successfully"
else
    echo "Warning: Modem driver failed to load"
fi

if lsmod | grep -q "q20_voice"; then
    echo "Voice driver loaded successfully"
else
    echo "Warning: Voice driver failed to load"
fi

if lsmod | grep -q "q20_sms"; then
    echo "SMS driver loaded successfully"
else
    echo "Warning: SMS driver failed to load"
fi

# Create data directory
mkdir -p /data

echo "Telephony system started"
echo "Available commands:"
echo "  dialer <number>     - Make a phone call"
echo "  sms-app <number> <message> - Send SMS"
echo "  cat /proc/q20_sms/messages - View SMS messages"
EOF
    chmod +x $ROOTFS_DIR/usr/bin/start-telephony
    
    echo "Telephony components installed to rootfs"
}

# Main build process
main() {
    echo "=== BBeOS Telephony Build Process ==="
    
    check_dependencies
    setup_build
    build_telephony
    create_apps
    create_config
    install_to_rootfs
    
    echo ""
    echo "=== Telephony Build Complete ==="
    echo "Generated files:"
    echo "  - $BUILD_DIR/modem/q20-modem.ko (modem driver)"
    echo "  - $BUILD_DIR/voice/q20-voice.ko (voice driver)"
    echo "  - $BUILD_DIR/sms/q20-sms.ko (SMS driver)"
    echo "  - $BUILD_DIR/apps/dialer (dialer application)"
    echo "  - $BUILD_DIR/apps/sms-app (SMS application)"
    echo "  - $BUILD_DIR/config/ (configuration files)"
    echo "  - $ROOTFS_DIR/usr/bin/start-telephony (startup script)"
    echo ""
    echo "To test on target hardware:"
    echo "  ./scripts/flash-boot.sh"
    echo "  Then run: start-telephony"
    echo ""
    echo "Note: These are framework implementations."
    echo "Full functionality requires:"
    echo "  - Actual Q20 hardware with modem"
    echo "  - QMI protocol implementation"
    echo "  - Audio codec integration"
    echo "  - Network stack integration"
}

# Run main function
main "$@"