// WordPress Plugin Service Worker Registration
if ('serviceWorker' in navigator) {
    navigator.serviceWorker.register('/wp-content/plugins/snapchat/assets/js/sw.js')
        .then(registration => {
            console.log('SnapChat SW registered:', registration);
            // Cache WordPress REST API endpoints
            registration.update();
        })
        .catch(error => console.log('SW registration failed:', error));
}

// Cordova Device Ready with WordPress Integration
document.addEventListener('deviceready', function() {
    console.log('Cordova ready - initializing WordPress connection');
    initializeWordPressApp();
    setupWordPressAuth();
}, false);

// WordPress API Client Initialization
const wpApiClient = new wp.api.WPApiBaseModel();
wpApiClient.url = '/wp-json/snapchat/v1/';

// PWA Camera Access with WordPress Upload
async function initCamera() {
    try {
        const stream = await navigator.mediaDevices.getUserMedia({
            video: { facingMode: 'user' },
            audio: true
        });
        const videoElement = document.getElementById('camera-preview');
        videoElement.srcObject = stream;
    } catch (error) {
        console.error('Camera access denied:', error);
        // Fallback to WordPress media library
        showWordPressMediaLibrary();
    }
}

// Capture Photo and Upload to WordPress
async function capturePhoto() {
    const canvas = document.createElement('canvas');
    const context = canvas.getContext('2d');
    const video = document.getElementById('camera-preview');

    canvas.width = video.videoWidth;
    canvas.height = video.videoHeight;
    context.drawImage(video, 0, 0);

    const imageData = canvas.toDataURL('image/jpeg', 0.8);

    // Upload to WordPress Media Library
    return await uploadToWordPressMedia(imageData);
}

// WordPress Media Upload Function
async function uploadToWordPressMedia(imageData) {
    const formData = new FormData();
    const blob = dataURLtoBlob(imageData);
    formData.append('file', blob, 'snap-' + Date.now() + '.jpg');

    const response = await wp.apiFetch({
        path: '/wp/v2/media',
        method: 'POST',
        body: formData,
        headers: {
            'X-WP-Nonce': wpApiSettings.nonce
        }
    });

    return response;
}

// Cordova Camera Plugin with WordPress Integration
function takePicture() {
    const options = {
        quality: 75,
        destinationType: Camera.DestinationType.FILE_URI,
        sourceType: Camera.PictureSourceType.CAMERA,
        encodingType: Camera.EncodingType.JPEG,
        targetWidth: 1024,
        targetHeight: 1024,
        correctOrientation: true
    };

    navigator.camera.getPicture(onCameraSuccess, onCameraFail, options);
}

function onCameraSuccess(fileURI) {
    // Upload to WordPress via Cordova File Transfer
    uploadCordovaImageToWordPress(fileURI);
}

function uploadCordovaImageToWordPress(fileURI) {
    const options = new FileUploadOptions();
    options.fileKey = 'file';
    options.fileName = fileURI.substr(fileURI.lastIndexOf('/') + 1);
    options.mimeType = 'image/jpeg';
    options.headers = {
        'X-WP-Nonce': localStorage.getItem('wp_nonce')
    };

    const ft = new FileTransfer();
    ft.upload(fileURI,
        wpApiSettings.root + 'wp/v2/media',
        onUploadSuccess,
        onUploadError,
        options
    );
}

// WordPress Plugin Activation - Create Custom Tables
function snapchat_create_tables() {
    global $wpdb;

    $charset_collate = $wpdb->get_charset_collate();

    // Friendships table
    $table_name = $wpdb->prefix . 'snapchat_friendships';
    $sql = "CREATE TABLE $table_name (
        id mediumint(9) NOT NULL AUTO_INCREMENT,
        user_id bigint(20) NOT NULL,
        friend_id bigint(20) NOT NULL,
        status varchar(20) DEFAULT 'pending',
        created_at datetime DEFAULT CURRENT_TIMESTAMP,
        updated_at datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
        PRIMARY KEY (id),
        KEY user_id (user_id),
        KEY friend_id (friend_id),
        UNIQUE KEY unique_friendship (user_id, friend_id)
    ) $charset_collate;";

    require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
    dbDelta($sql);

    // Register custom post types
    snapchat_register_post_types();
}

// Register Custom Post Types
function snapchat_register_post_types() {
    // Snaps post type
    register_post_type('snap', array(
        'public' => false,
        'show_in_rest' => true,
        'rest_base' => 'snaps',
        'supports' => array('title', 'editor', 'author', 'custom-fields'),
        'capability_type' => 'snap',
        'map_meta_cap' => true
    ));

    // Messages post type
    register_post_type('message', array(
        'public' => false,
        'show_in_rest' => true,
        'rest_base' => 'messages',
        'supports' => array('editor', 'author', 'custom-fields'),
        'capability_type' => 'message',
        'hierarchical' => true // For conversation threading
    ));

    // Stories post type
    register_post_type('story', array(
        'public' => false,
        'show_in_rest' => true,
        'rest_base' => 'stories',
        'supports' => array('title', 'editor', 'author', 'custom-fields'),
        'capability_type' => 'story'
    ));
}

// IndexedDB Schema for WordPress Data Caching
const wpSnapChatDB = {
    name: 'WPSnapChatDB',
    version: 1,
    stores: {
        users: { keyPath: 'ID', autoIncrement: false },
        snaps: { keyPath: 'id', autoIncrement: false },
        messages: { keyPath: 'id', autoIncrement: false },
        conversations: { keyPath: 'id', autoIncrement: false },
        stories: { keyPath: 'id', autoIncrement: false },
        wp_cache: { keyPath: 'endpoint', autoIncrement: false },
        offline_queue: { keyPath: 'id', autoIncrement: true }
    }
};

// WordPress Data Sync Manager
class WPDataSync {
    async cacheWPData(endpoint, data) {
        const db = await this.openDB();
        const transaction = db.transaction(['wp_cache'], 'readwrite');
        const store = transaction.objectStore('wp_cache');

        await store.put({
            endpoint: endpoint,
            data: data,
            timestamp: Date.now(),
            nonce: wpApiSettings.nonce
        });
    }

    async getCachedWPData(endpoint, maxAge = 300000) { // 5 minutes default
        const db = await this.openDB();
        const transaction = db.transaction(['wp_cache'], 'readonly');
        const store = transaction.objectStore('wp_cache');
        const result = await store.get(endpoint);

        if (result && (Date.now() - result.timestamp) < maxAge) {
            return result.data;
        }
        return null;
    }
}

// WordPress REST API Controller for SnapChat
class SnapChat_REST_Controller extends WP_REST_Controller {

    public function __construct() {
        $this->namespace = 'snapchat/v1';
        $this->rest_base = 'snaps';
    }

    public function register_routes() {
        register_rest_route($this->namespace, '/' . $this->rest_base, array(
            array(
                'methods' => WP_REST_Server::READABLE,
                'callback' => array($this, 'get_items'),
                'permission_callback' => array($this, 'get_items_permissions_check'),
                'args' => $this->get_collection_params(),
            ),
            array(
                'methods' => WP_REST_Server::CREATABLE,
                'callback' => array($this, 'create_item'),
                'permission_callback' => array($this, 'create_item_permissions_check'),
                'args' => $this->get_endpoint_args_for_item_schema(WP_REST_Server::CREATABLE),
            ),
        ));
    }

    public function get_items($request) {
        $args = array(
            'post_type' => 'snap',
            'post_status' => 'publish',
            'author' => get_current_user_id(),
            'meta_query' => array(
                array(
                    'key' => 'snap_expires_at',
                    'value' => current_time('mysql'),
                    'compare' => '>',
                    'type' => 'DATETIME'
                )
            )
        );

        $snaps = get_posts($args);
        $data = array();

        foreach ($snaps as $snap) {
            $data[] = $this->prepare_item_for_response($snap, $request);
        }

        return rest_ensure_response($data);
    }

    public function create_item($request) {
        if (!wp_verify_nonce($request->get_header('X-WP-Nonce'), 'wp_rest')) {
            return new WP_Error('invalid_nonce', 'Invalid nonce', array('status' => 403));
        }

        $snap_data = array(
            'post_type' => 'snap',
            'post_title' => sanitize_text_field($request['title']),
            'post_content' => wp_kses_post($request['content']),
            'post_author' => get_current_user_id(),
            'post_status' => 'publish',
            'meta_input' => array(
                'snap_expires_at' => date('Y-m-d H:i:s', strtotime('+24 hours')),
                'media_url' => esc_url_raw($request['media_url']),
                'view_count' => 0
            )
        );

        $snap_id = wp_insert_post($snap_data);

        if (is_wp_error($snap_id)) {
            return $snap_id;
        }

        $snap = get_post($snap_id);
        return rest_ensure_response($this->prepare_item_for_response($snap, $request));
    }

    public function get_items_permissions_check($request) {
        return current_user_can('read');
    }

    public function create_item_permissions_check($request) {
        return current_user_can('publish_snaps');
    }
}

// WordPress API Client Implementation
class WPSnapChatAPI {
    constructor() {
        this.baseURL = wpApiSettings.root;
        this.nonce = wpApiSettings.nonce;
    }

    async request(endpoint, options = {}) {
        const url = ${this.baseURL}${endpoint};
        const config = {
            headers: {
                'Content-Type': 'application/json',
                'X-WP-Nonce': this.nonce,
                ...options.headers
            },
            credentials: 'same-origin',
            ...options
        };

        try {
            const response = await fetch(url, config);
            if (!response.ok) {
                if (response.status === 403) {
                    // Refresh nonce and retry
                    await this.refreshNonce();
                    config.headers['X-WP-Nonce'] = this.nonce;
                    return fetch(url, config);
                }
                throw new Error(HTTP ${response.status});
            }
            return await response.json();
        } catch (error) {
            console.error('WordPress API request failed:', error);
            throw error;
        }
    }

    async refreshNonce() {
        const response = await wp.apiFetch({
            path: '/snapchat/v1/nonce',
            method: 'GET'
        });
        this.nonce = response.nonce;
        wpApiSettings.nonce = response.nonce;
    }

    async uploadSnap(mediaData, caption) {
        // First upload to WordPress media library
        const mediaResponse = await wp.apiFetch({
            path: '/wp/v2/media',
            method: 'POST',
            body: mediaData,
            headers: {
                'X-WP-Nonce': this.nonce
            }
        });

        // Then create snap post
        return this.request('snapchat/v1/snaps', {
            method: 'POST',
            body: JSON.stringify({
                title: 'Snap ' + Date.now(),
                content: caption,
                media_url: mediaResponse.source_url
            })
        });
    }
}

// WordPress Authentication Service
class WPAuthService {
    async login(username, password) {
        try {
            const formData = new FormData();
            formData.append('log', username);
            formData.append('pwd', password);
            formData.append('wp-submit', 'Log In');
            formData.append('redirect_to', window.location.href);

            const response = await fetch('/wp-login.php', {
                method: 'POST',
                body: formData,
                credentials: 'same-origin'
            });

            if (response.redirected) {
                // Login successful, get user data and nonce
                const userResponse = await wp.apiFetch({
                    path: '/wp/v2/users/me'
                });

                // Store WordPress nonce for API calls
                localStorage.setItem('wp_nonce', wpApiSettings.nonce);
                localStorage.setItem('wp_user_id', userResponse.id);

                return userResponse;
            } else {
                throw new Error('Invalid credentials');
            }
        } catch (error) {
            throw new Error('WordPress login failed: ' + error.message);
        }
    }

    async logout() {
        try {
            await fetch('/wp-login.php?action=logout&_wpnonce=' + wpApiSettings.nonce, {
                method: 'GET',
                credentials: 'same-origin'
            });

            // Clear stored data
            localStorage.removeItem('wp_nonce');
            localStorage.removeItem('wp_user_id');

            // Clear IndexedDB cache
            const wpDataSync = new WPDataSync();
            await wpDataSync.clearCache();

        } catch (error) {
            console.error('Logout error:', error);
        }
    }

    async checkCapabilities(capability) {
        try {
            const response = await wp.apiFetch({
                path: '/snapchat/v1/check-capability',
                method: 'POST',
                data: { capability: capability }
            });
            return response.has_capability;
        } catch (error) {
            return false;
        }
    }

    getCurrentUserId() {
        return parseInt(localStorage.getItem('wp_user_id')) || 0;
    }

    isLoggedIn() {
        return !!localStorage.getItem('wp_nonce') && !!localStorage.getItem('wp_user_id');
    }
}

// WordPress Capability Check Endpoint (PHP)
function snapchat_check_capability_endpoint($request) {
    $capability = sanitize_text_field($request['capability']);

    if (!current_user_can($capability)) {
        return new WP_Error('insufficient_permissions',
            'You do not have permission to perform this action.',
            array('status' => 403)
        );
    }

    return rest_ensure_response(array(
        'has_capability' => true,
        'user_id' => get_current_user_id()
    ));
}

// WordPress Custom Capabilities for SnapChat
function snapchat_add_custom_capabilities() {
    // Get roles
    $admin = get_role('administrator');
    $editor = get_role('editor');
    $author = get_role('author');
    $subscriber = get_role('subscriber');

    // Add SnapChat capabilities
    $capabilities = array(
        'read_snaps',
        'publish_snaps',
        'edit_snaps',
        'delete_snaps',
        'send_messages',
        'create_stories',
        'view_stories',
        'manage_friends'
    );

    foreach ($capabilities as $cap) {
        $admin->add_cap($cap);
        $editor->add_cap($cap);
        $author->add_cap($cap);

        // Subscribers can only read and send messages
        if (in_array($cap, array('read_snaps', 'send_messages', 'view_stories'))) {
            $subscriber->add_cap($cap);
        }
    }
}

// WordPress Nonce Management
class WPNonceManager {
    static function createNonce($action) {
        return wp_create_nonce($action);
    }

    static function verifyNonce($nonce, $action) {
        return wp_verify_nonce($nonce, $action);
    }

    static function verifyAjaxNonce($nonce, $action) {
        if (!wp_verify_nonce($nonce, $action)) {
            wp_die('Security check failed', 'Nonce Verification Failed', array('response' => 403));
        }
    }

    static function getNonceField($action, $name = '_wpnonce') {
        return wp_nonce_field($action, $name, true, false);
    }
}

// Cordova Biometric Authentication
function authenticateWithBiometrics() {
    if (window.plugins && window.plugins.touchid) {
        window.plugins.touchid.authenticate(
            function() {
                console.log('Biometric auth successful');
                // Auto-login to WordPress if biometric succeeds
                autoLoginToWordPress();
            },
            function() {
                console.log('Biometric auth failed');
                // Fallback to WordPress login form
                showWordPressLoginForm();
            },
            'Authenticate to access SnapChat'
        );
    } else if (window.plugins && window.plugins.fingerprint) {
        // Android fingerprint fallback
        window.plugins.fingerprint.authenticate(
            function() {
                autoLoginToWordPress();
            },
            function() {
                showWordPressLoginForm();
            },
            'Use your fingerprint to access SnapChat'
        );
    }
}

function autoLoginToWordPress() {
    // Check if we have stored WordPress credentials
    const storedCredentials = getStoredCredentials();
    if (storedCredentials) {
        const wpAuth = new WPAuthService();
        wpAuth.login(storedCredentials.username, storedCredentials.password)
            .then(user => {
                console.log('Auto-login successful:', user);
                initializeSnapChatApp();
            })
            .catch(error => {
                console.error('Auto-login failed:', error);
                showWordPressLoginForm();
            });
    } else {
        showWordPressLoginForm();
    }
}

function getStoredCredentials() {
    // Use Cordova secure storage plugin
    if (window.plugins && window.plugins.secureStorage) {
        return new Promise((resolve, reject) => {
            const ss = new window.plugins.secureStorage(
                function() {
                    ss.get(
                        function(value) {
                            resolve(JSON.parse(value));
                        },
                        reject,
                        'wp_credentials'
                    );
                },
                reject,
                'SnapChatSecure'
            );
        });
    }
    return null;
}

// WordPress-aware Service Worker Caching
const CACHE_NAME = 'wp-snapchat-v1';
const WP_CACHE_NAME = 'wp-api-cache-v1';

const urlsToCache = [
    '/wp-content/plugins/snapchat/assets/js/app.js',
    '/wp-content/plugins/snapchat/assets/css/style.css',
    '/wp-content/plugins/snapchat/manifest.json',
    '/wp-admin/admin-ajax.php',
    '/wp-json/wp/v2/',
    '/wp-json/snapchat/v1/'
];

self.addEventListener('install', event => {
    event.waitUntil(
        Promise.all([
            caches.open(CACHE_NAME).then(cache => cache.addAll(urlsToCache)),
            caches.open(WP_CACHE_NAME)
        ])
    );
});

self.addEventListener('fetch', event => {
    const url = new URL(event.request.url);

    // Handle WordPress REST API requests
    if (url.pathname.startsWith('/wp-json/')) {
        event.respondWith(handleWPAPIRequest(event.request));
    }
    // Handle WordPress admin-ajax requests
    else if (url.pathname.includes('admin-ajax.php')) {
        event.respondWith(handleWPAjaxRequest(event.request));
    }
    // Handle static assets
    else {
        event.respondWith(handleStaticRequest(event.request));
    }
});

async function handleWPAPIRequest(request) {
    const cache = await caches.open(WP_CACHE_NAME);

    // For GET requests, try cache first (stale-while-revalidate)
    if (request.method === 'GET') {
        const cachedResponse = await cache.match(request);

        if (cachedResponse) {
            // Return cached version immediately
            fetch(request).then(response => {
                if (response.ok) {
                    cache.put(request, response.clone());
                }
            }).catch(() => {}); // Silent fail for background update

            return cachedResponse;
        }
    }

    // For POST/PUT/DELETE or cache miss, go to network
    try {
        const response = await fetch(request);

        if (response.ok && request.method === 'GET') {
            cache.put(request, response.clone());
        }

        return response;
    } catch (error) {
        // Return cached version if available during network failure
        const cachedResponse = await cache.match(request);
        if (cachedResponse) {
            return cachedResponse;
        }
        throw error;
    }
}

async function handleWPAjaxRequest(request) {
    // WordPress AJAX requests - network first, cache as fallback
    try {
        const response = await fetch(request);
        return response;
    } catch (error) {
        // Return generic error response for AJAX failures
        return new Response(JSON.stringify({
            success: false,
            data: 'Network error - please try again'
        }), {
            headers: { 'Content-Type': 'application/json' }
        });
    }
}

// WordPress Transients for Server-Side Caching
class WPTransientManager {
    static function setTransient($key, $data, $expiration = 3600) {
        return set_transient('snapchat_' . $key, $data, $expiration);
    }

    static function getTransient($key) {
        return get_transient('snapchat_' . $key);
    }

    static function deleteTransient($key) {
        return delete_transient('snapchat_' . $key);
    }

    static function cacheUserSnaps($user_id) {
        $cache_key = 'user_snaps_' . $user_id;
        $cached_snaps = self::getTransient($cache_key);

        if ($cached_snaps === false) {
            $snaps = get_posts(array(
                'post_type' => 'snap',
                'author' => $user_id,
                'post_status' => 'publish',
                'numberposts' => 50,
                'meta_query' => array(
                    array(
                        'key' => 'snap_expires_at',
                        'value' => current_time('mysql'),
                        'compare' => '>',
                        'type' => 'DATETIME'
                    )
                )
            ));

            self::setTransient($cache_key, $snaps, 300); // 5 minutes
            return $snaps;
        }

        return $cached_snaps;
    }
}

// WordPress Object Cache Integration
class WPObjectCacheManager {
    static function cacheUserFriends($user_id) {
        $cache_key = 'user_friends_' . $user_id;
        $friends = wp_cache_get($cache_key, 'snapchat');

        if ($friends === false) {
            global $wpdb;
            $table_name = $wpdb->prefix . 'snapchat_friendships';

            $friends = $wpdb->get_results($wpdb->prepare(
                "SELECT f.*, u.display_name, u.user_email
                 FROM {$table_name} f
                 JOIN {$wpdb->users} u ON f.friend_id = u.ID
                 WHERE f.user_id = %d AND f.status = 'accepted'",
                $user_id
            ));

            wp_cache_set($cache_key, $friends, 'snapchat', 600); // 10 minutes
        }

        return $friends;
    }

    static function invalidateUserCache($user_id) {
        wp_cache_delete('user_friends_' . $user_id, 'snapchat');
        wp_cache_delete('user_snaps_' . $user_id, 'snapchat');
        WPTransientManager::deleteTransient('user_snaps_' . $user_id);
    }
}

// Enhanced WordPress Data Cache Manager
class WPCacheManager {
    constructor() {
        this.dbName = 'WPSnapChatCache';
        this.version = 1;
    }

    async cacheWPUserData(userId, data) {
        const db = await this.openDB();
        const transaction = db.transaction(['wp_users'], 'readwrite');
        const store = transaction.objectStore('wp_users');

        await store.put({
            ID: userId,
            data: data,
            timestamp: Date.now(),
            wp_nonce: wpApiSettings.nonce
        });
    }

    async getCachedWPData(endpoint, maxAge = 300000) { // 5 minutes default
        const db = await this.openDB();
        const transaction = db.transaction(['wp_cache'], 'readonly');
        const store = transaction.objectStore('wp_cache');
        const result = await store.get(endpoint);

        if (result && (Date.now() - result.timestamp) < maxAge) {
            // Verify nonce is still valid
            if (result.wp_nonce === wpApiSettings.nonce) {
                return result.data;
            }
        }
        return null;
    }

    async queueOfflineAction(action) {
        const db = await this.openDB();
        const transaction = db.transaction(['offline_queue'], 'readwrite');
        const store = transaction.objectStore('offline_queue');

        await store.add({
            action: action,
            timestamp: Date.now(),
            wp_nonce: wpApiSettings.nonce,
            user_id: parseInt(localStorage.getItem('wp_user_id'))
        });
    }

    async syncOfflineQueue() {
        const db = await this.openDB();
        const transaction = db.transaction(['offline_queue'], 'readwrite');
        const store = transaction.objectStore('offline_queue');
        const queue = await store.getAll();

        for (const item of queue) {
            try {
                await this.executeWPAction(item.action);
                await store.delete(item.id);
            } catch (error) {
                console.error('Failed to sync offline action:', error);
                // Keep in queue for retry
            }
        }
    }

    async executeWPAction(action) {
        switch (action.type) {
            case 'create_snap':
                return await wp.apiFetch({
                    path: '/snapchat/v1/snaps',
                    method: 'POST',
                    data: action.data
                });
            case 'send_message':
                return await wp.apiFetch({
                    path: '/snapchat/v1/messages',
                    method: 'POST',
                    data: action.data
                });
            default:
                throw new Error(Unknown action type: ${action.type});
        }
    }
}

// Global Error Handler
class ErrorHandler {
    static handleError(error, context = '') {
        console.error(Error in ${context}:, error);

        // Log to analytics service
        this.logError(error, context);

        // Show user-friendly message
        this.showUserMessage(this.getUserFriendlyMessage(error));

        // Report to crash analytics (Cordova)
        if (window.crashlytics) {
            window.crashlytics.recordError(error.message);
        }
    }

    static getUserFriendlyMessage(error) {
        const errorMap = {
            'NetworkError': 'Please check your internet connection',
            'CameraError': 'Unable to access camera. Please check permissions',
            'AuthError': 'Please log in again',
            'StorageError': 'Unable to save data. Please try again'
        };

        return errorMap[error.name] || 'Something went wrong. Please try again';
    }

    static async logError(error, context) {
        try {
            await fetch('/api/v1/errors', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    message: error.message,
                    stack: error.stack,
                    context,
                    timestamp: new Date().toISOString(),
                    userAgent: navigator.userAgent
                })
            });
        } catch (logError) {
            console.error('Failed to log error:', logError);
        }
    }
}

// React Error Boundary
class ErrorBoundary extends React.Component {
    constructor(props) {
        super(props);
        this.state = { hasError: false };
    }

    static getDerivedStateFromError(error) {
        return { hasError: true };
    }

    componentDidCatch(error, errorInfo) {
        ErrorHandler.handleError(error, 'React Component');
    }

    render() {
        if (this.state.hasError) {
            return 
Something went wrong. Please refresh the page.
;
        }
        return this.props.children;
    }
}

// Comprehensive Logging Service
class Logger {
    constructor() {
        this.logLevel = process.env.NODE_ENV === 'production' ? 'warn' : 'debug';
        this.logs = [];
        this.maxLogs = 1000;
    }

    log(level, message, data = {}) {
        const logEntry = {
            timestamp: new Date().toISOString(),
            level,
            message,
            data,
            url: window.location.href,
            userAgent: navigator.userAgent
        };

        this.logs.push(logEntry);

        // Keep only recent logs
        if (this.logs.length > this.maxLogs) {
            this.logs = this.logs.slice(-this.maxLogs);
        }

        // Console output
        console[level](message, data);

        // Send to analytics in production
        if (level === 'error' || level === 'warn') {
            this.sendToAnalytics(logEntry);
        }
    }

    debug(message, data) { this.log('debug', message, data); }
    info(message, data) { this.log('info', message, data); }
    warn(message, data) { this.log('warn', message, data); }
    error(message, data) { this.log('error', message, data); }

    async sendToAnalytics(logEntry) {
        try {
            await fetch('/api/v1/analytics/logs', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(logEntry)
            });
        } catch (error) {
            console.error('Failed to send log to analytics:', error);
        }
    }

    exportLogs() {
        return JSON.stringify(this.logs, null, 2);
    }
}

const logger = new Logger();

// Performance Monitoring
class PerformanceMonitor {
    static measurePageLoad() {
        window.addEventListener('load', () => {
            const perfData = performance.getEntriesByType('navigation')[0];
            const metrics = {
                domContentLoaded: perfData.domContentLoadedEventEnd - perfData.domContentLoadedEventStart,
                loadComplete: perfData.loadEventEnd - perfData.loadEventStart,
                firstPaint: performance.getEntriesByType('paint')[0]?.startTime,
                firstContentfulPaint: performance.getEntriesByType('paint')[1]?.startTime
            };

            logger.info('Page Load Metrics', metrics);
            this.sendMetrics(metrics);
        });
    }

    static measureAPICall(url, startTime) {
        const duration = performance.now() - startTime;
        logger.info('API Call Performance', { url, duration });

        if (duration > 2000) { // Slow API call
            logger.warn('Slow API Call Detected', { url, duration });
        }
    }

    static optimizeImages() {
        // Lazy loading implementation
        const images = document.querySelectorAll('img[data-src]');
        const imageObserver = new IntersectionObserver((entries) => {
            entries.forEach(entry => {
                if (entry.isIntersecting) {
                    const img = entry.target;
                    img.src = img.dataset.src;
                    img.removeAttribute('data-src');
                    imageObserver.unobserve(img);
                }
            });
        });

        images.forEach(img => imageObserver.observe(img));
    }
}

// React Performance Optimization
const MemoizedSnapComponent = React.memo(({ snap }) => {
    return (
        

            
            
{snap.caption}
        
    );
});

// Virtual Scrolling for Large Lists
class VirtualScrollList extends React.Component {
    constructor(props) {
        super(props);
        this.state = {
            startIndex: 0,
            endIndex: 20
        };
    }

    handleScroll = (e) => {
        const scrollTop = e.target.scrollTop;
        const itemHeight = 100; // Estimated item height
        const containerHeight = e.target.clientHeight;

        const startIndex = Math.floor(scrollTop / itemHeight);
        const endIndex = Math.min(
            startIndex + Math.ceil(containerHeight / itemHeight) + 5,
            this.props.items.length
        );

        this.setState({ startIndex, endIndex });
    };

    render() {
        const { items } = this.props;
        const { startIndex, endIndex } = this.state;
        const visibleItems = items.slice(startIndex, endIndex);

        return (
            

                

                {visibleItems.map(item => (
                    
                ))}
                

            
    );
}
}

// WordPress Scalability Configuration
const wpScalingConfig = {
    hosting: {
        type: 'WordPress Managed Hosting', // WP Engine, Kinsta, etc.
        caching: 'Built-in Page Cache + Object Cache',
        cdn: 'Integrated CDN (CloudFlare/KeyCDN)',
        compression: 'gzip enabled by host',
        database: 'MySQL with query optimization'
    },
    wordpress: {
        multisite: {
            enabled: true,
            type: 'subdomain', // snapchat.domain.com
            sharedUsers: true,
            networkAdmin: true
        },
        caching: {
            objectCache: 'WordPress Object Cache (Redis if available)',
            transients: 'WordPress Transients API',
            pageCache: 'W3 Total Cache / WP Rocket',
            databaseCache: 'Query result caching'
        },
        optimization: {
            lazyLoading: 'WordPress native lazy loading',
            imageOptimization: 'WebP conversion + compression',
            minification: 'CSS/JS minification plugins',
            databaseCleanup: 'WP Cron automated cleanup'
        }
    },
    database: {
        engine: 'MySQL 8.0+',
        optimization: {
            indexes: 'Custom indexes on meta queries',
            cleanup: 'Automated post/meta cleanup',
            replication: 'Master/Slave if supported by host'
        },
        caching: {
            queryCache: 'MySQL query cache',
            objectCache: 'WordPress wp_cache_* functions',
            transients: 'set_transient() for temporary data'
        }
    }
};

// WordPress Database Optimization
class WPDatabaseOptimization {
    static function optimizeSnapChatTables() {
        global $wpdb;

        // Add indexes for better performance
        $wpdb->query("
            ALTER TABLE {$wpdb->posts}
            ADD INDEX snapchat_post_type_author (post_type, post_author)
        ");

        $wpdb->query("
            ALTER TABLE {$wpdb->postmeta}
            ADD INDEX snapchat_meta_expires (meta_key, meta_value)
        ");

        // Optimize friendship table
        $table_name = $wpdb->prefix . 'snapchat_friendships';
        $wpdb->query("
            ALTER TABLE {$table_name}
            ADD INDEX user_friend_status (user_id, friend_id, status)
        ");
    }

    static function cleanupExpiredContent() {
        global $wpdb;

        // Clean up expired snaps
        $wpdb->query($wpdb->prepare("
            UPDATE {$wpdb->posts}
            SET post_status = 'trash'
            WHERE post_type = 'snap'
            AND ID IN (
                SELECT post_id FROM {$wpdb->postmeta}
                WHERE meta_key = 'snap_expires_at'
                AND meta_value < %s
            )
        ", current_time('mysql')));

        // Clean up expired stories (24 hours)
        $wpdb->query($wpdb->prepare("
            UPDATE {$wpdb->posts}
            SET post_status = 'trash'
            WHERE post_type = 'story'
            AND post_date < %s
        ", date('Y-m-d H:i:s', strtotime('-24 hours'))));
    }
}

// WordPress Caching Strategy
class WPSnapChatCache {
    static function cacheUserSnaps($user_id, $limit = 50) {
        $cache_key = 'user_snaps_' . $user_id . '_' . $limit;
        $cached_snaps = wp_cache_get($cache_key, 'snapchat');

        if ($cached_snaps === false) {
            $snaps = get_posts(array(
                'post_type' => 'snap',
                'author' => $user_id,
                'numberposts' => $limit,
                'post_status' => 'publish',
                'meta_query' => array(
                    array(
                        'key' => 'snap_expires_at',
                        'value' => current_time('mysql'),
                        'compare' => '>',
                        'type' => 'DATETIME'
                    )
                )
            ));

            // Cache for 5 minutes
            wp_cache_set($cache_key, $snaps, 'snapchat', 300);
            return $snaps;
        }

        return $cached_snaps;
    }

    static function cacheUserFriends($user_id) {
        $transient_key = 'snapchat_friends_' . $user_id;
        $friends = get_transient($transient_key);

        if ($friends === false) {
            global $wpdb;
            $table_name = $wpdb->prefix . 'snapchat_friendships';

            $friends = $wpdb->get_results($wpdb->prepare("
                SELECT f.*, u.display_name, u.user_email
                FROM {$table_name} f
                JOIN {$wpdb->users} u ON f.friend_id = u.ID
                WHERE f.user_id = %d AND f.status = 'accepted'
                ORDER BY u.display_name
            ", $user_id));

            // Cache for 10 minutes
            set_transient($transient_key, $friends, 600);
        }

        return $friends;
    }

    static function invalidateUserCache($user_id) {
        // Clear object cache
        wp_cache_delete('user_snaps_' . $user_id . '_50', 'snapchat');
        wp_cache_delete('user_stories_' . $user_id, 'snapchat');

        // Clear transients
        delete_transient('snapchat_friends_' . $user_id);
        delete_transient('snapchat_conversations_' . $user_id);
    }
}

// WordPress Multisite Configuration for Scaling
class WPSnapChatMultisite {
    static function setupNetworkSites() {
        // Main site: snapchat.domain.com
        // Regional sites: us.snapchat.domain.com, eu.snapchat.domain.com

        if (is_multisite()) {
            $current_site = get_current_site();
            $current_blog_id = get_current_blog_id();

            // Share users across network
            if (is_plugin_active_for_network('snapchat/snapchat.php')) {
                // Network-wide user base
                return true;
            }
        }

        return false;
    }

    static function getOptimalSite($user_location = null) {
        if (!is_multisite()) {
            return get_current_blog_id();
        }

        $sites = get_sites(array(
            'network_id' => get_current_network_id(),
            'public' => 1
        ));

        // Simple geographic routing
        if ($user_location) {
            foreach ($sites as $site) {
                if (strpos($site->domain, $user_location) !== false) {
                    return $site->blog_id;
                }
            }
        }

        // Default to main site
        return get_main_site_id();
    }

    static function syncUserDataAcrossSites($user_id) {
        if (!is_multisite()) return;

        $sites = get_sites();
        $current_site = get_current_blog_id();

        foreach ($sites as $site) {
            if ($site->blog_id != $current_site) {
                switch_to_blog($site->blog_id);

                // Sync user meta across sites
                $user_meta = get_user_meta($user_id);
                foreach ($user_meta as $key => $value) {
                    if (strpos($key, 'snapchat_') === 0) {
                        update_user_meta($user_id, $key, $value[0]);
                    }
                }

                restore_current_blog();
            }
        }
    }
}

// WordPress Performance Monitoring
class WPSnapChatPerformance {
    static function monitorDatabaseQueries() {
        if (defined('SAVEQUERIES') && SAVEQUERIES) {
            global $wpdb;

            $slow_queries = array();
            foreach ($wpdb->queries as $query) {
                if ($query[1] > 0.1) { // Queries taking more than 100ms
                    $slow_queries[] = array(
                        'query' => $query[0],
                        'time' => $query[1],
                        'stack' => $query[2]
                    );
                }
            }

            if (!empty($slow_queries)) {
                error_log('SnapChat slow queries: ' . json_encode($slow_queries));
            }
        }
    }

    static function optimizeHeartbeatAPI() {
        // Reduce WordPress Heartbeat frequency for better performance
        add_filter('heartbeat_settings', function($settings) {
            $settings['interval'] = 60; // 60 seconds instead of 15
            return $settings;
        });

        // Disable heartbeat on non-admin pages
        if (!is_admin()) {
            wp_deregister_script('heartbeat');
        }
    }

    static function implementLazyLoading() {
        // WordPress native lazy loading for images
        add_filter('wp_lazy_loading_enabled', '__return_true');

        // Lazy load SnapChat media
        add_filter('the_content', function($content) {
            if (get_post_type() === 'snap') {
                $content = str_replace('

// Security Service
class SecurityService {
    // End-to-End Encryption
    static async encryptMessage(message, publicKey) {
        const encoder = new TextEncoder();
        const data = encoder.encode(message);

        const encrypted = await window.crypto.subtle.encrypt(
            { name: 'RSA-OAEP' },
            publicKey,
            data
        );

        return btoa(String.fromCharCode(...new Uint8Array(encrypted)));
    }

    static async decryptMessage(encryptedMessage, privateKey) {
        const encrypted = Uint8Array.from(atob(encryptedMessage), c => c.charCodeAt(0));

        const decrypted = await window.crypto.subtle.decrypt(
            { name: 'RSA-OAEP' },
            privateKey,
            encrypted
        );

        const decoder = new TextDecoder();
        return decoder.decode(decrypted);
    }

    // Input Sanitization
    static sanitizeInput(input) {
        const div = document.createElement('div');
        div.textContent = input;
        return div.innerHTML;
    }

    // Secure Storage (Cordova)
    static async secureStore(key, value) {
        if (window.cordova && window.plugins.secureStorage) {
            return new Promise((resolve, reject) => {
                const ss = new window.plugins.secureStorage(
                    () => {
                        ss.set(resolve, reject, key, value);
                    },
                    reject,
                    'SnapChatSecure'
                );
            });
        } else {
            // Fallback to encrypted localStorage
            const encrypted = await this.encrypt(value);
            localStorage.setItem(key, encrypted);
        }
    }
}

// Content Security Policy
const cspConfig = {
    'default-src': "'self'",
    'script-src': "'self' 'unsafe-inline'",
    'style-src': "'self' 'unsafe-inline'",
    'img-src': "'self' data: https:",
    'media-src': "'self' blob:",
    'connect-src': "'self' wss: https:",
    'font-src': "'self'",
    'object-src': "'none'",
    'base-uri': "'self'",
    'form-action': "'self'"
};

// Redux Store for State Management
const initialState = {
    user: null,
    snaps: [],
    conversations: [],
    stories: [],
    ui: {
        loading: false,
        error: null,
        activeView: 'camera'
    },
    cache: {
        lastSync: null,
        offlineQueue: []
    }
};

// Redux Actions
const actions = {
    // User Actions
    LOGIN_SUCCESS: 'LOGIN_SUCCESS',
    LOGOUT: 'LOGOUT',

    // Snap Actions
    FETCH_SNAPS_REQUEST: 'FETCH_SNAPS_REQUEST',
    FETCH_SNAPS_SUCCESS: 'FETCH_SNAPS_SUCCESS',
    FETCH_SNAPS_FAILURE: 'FETCH_SNAPS_FAILURE',
    UPLOAD_SNAP: 'UPLOAD_SNAP',

    // Message Actions
    SEND_MESSAGE: 'SEND_MESSAGE',
    RECEIVE_MESSAGE: 'RECEIVE_MESSAGE',

    // Offline Actions
    QUEUE_OFFLINE_ACTION: 'QUEUE_OFFLINE_ACTION',
    SYNC_OFFLINE_QUEUE: 'SYNC_OFFLINE_QUEUE'
};

// Data Synchronization
class DataSync {
    static async syncOfflineQueue() {
        const queue = store.getState().cache.offlineQueue;

        for (const action of queue) {
            try {
                await this.executeAction(action);
                store.dispatch({ type: 'REMOVE_FROM_QUEUE', payload: action.id });
            } catch (error) {
                logger.error('Failed to sync offline action', { action, error });
            }
        }
    }

    static async executeAction(action) {
        switch (action.type) {
            case 'SEND_MESSAGE':
                return await api.sendMessage(action.payload);
            case 'UPLOAD_SNAP':
                return await api.uploadSnap(action.payload);
            default:
                throw new Error(Unknown action type: ${action.type});
        }
    }
}

// Real-time Data Updates
class RealtimeManager {
    constructor() {
        this.socket = null;
        this.reconnectAttempts = 0;
        this.maxReconnectAttempts = 5;
    }

    connect() {
        this.socket = io('/chat', {
            auth: { token: localStorage.getItem('auth_token') }
        });

        this.socket.on('connect', () => {
            logger.info('Connected to real-time server');
            this.reconnectAttempts = 0;
        });

        this.socket.on('message', (message) => {
            store.dispatch({ type: 'RECEIVE_MESSAGE', payload: message });
        });

        this.socket.on('disconnect', () => {
            this.handleReconnect();
        });
    }

    handleReconnect() {
        if (this.reconnectAttempts < this.maxReconnectAttempts) {
            setTimeout(() => {
                this.reconnectAttempts++;
                this.connect();
            }, Math.pow(2, this.reconnectAttempts) * 1000);
        }
    }
}

// PHPUnit Test for WordPress SnapChat Plugin
class SnapChat_Plugin_Test extends WP_UnitTestCase {

    public function setUp(): void {
        parent::setUp();

        // Activate plugin
        activate_plugin('snapchat/snapchat.php');

        // Create test user
        $this->user_id = $this->factory->user->create(array(
            'role' => 'subscriber',
            'user_login' => 'testuser',
            'user_email' => 'test@example.com'
        ));

        wp_set_current_user($this->user_id);
    }

    public function test_snap_post_type_registration() {
        $this->assertTrue(post_type_exists('snap'));
        $this->assertTrue(post_type_exists('message'));
        $this->assertTrue(post_type_exists('story'));
    }

    public function test_custom_capabilities() {
        $user = new WP_User($this->user_id);
        $this->assertTrue($user->has_cap('read_snaps'));
        $this->assertTrue($user->has_cap('send_messages'));
        $this->assertFalse($user->has_cap('manage_options'));
    }

    public function test_snap_creation_with_expiration() {
        $snap_data = array(
            'post_type' => 'snap',
            'post_title' => 'Test Snap',
            'post_content' => 'Test snap content',
            'post_author' => $this->user_id,
            'post_status' => 'publish',
            'meta_input' => array(
                'snap_expires_at' => date('Y-m-d H:i:s', strtotime('+24 hours')),
                'view_count' => 0
            )
        );

        $snap_id = wp_insert_post($snap_data);
        $this->assertIsInt($snap_id);
        $this->assertGreaterThan(0, $snap_id);

        // Test expiration meta
        $expires_at = get_post_meta($snap_id, 'snap_expires_at', true);
        $this->assertNotEmpty($expires_at);
        $this->assertGreaterThan(time(), strtotime($expires_at));
    }

    public function test_friendship_table_operations() {
        global $wpdb;

        $friend_id = $this->factory->user->create();
        $table_name = $wpdb->prefix . 'snapchat_friendships';

        // Test friendship creation
        $result = $wpdb->insert(
            $table_name,
            array(
                'user_id' => $this->user_id,
                'friend_id' => $friend_id,
                'status' => 'pending'
            ),
            array('%d', '%d', '%s')
        );

        $this->assertNotFalse($result);

        // Test friendship retrieval
        $friendship = $wpdb->get_row($wpdb->prepare(
            "SELECT * FROM {$table_name} WHERE user_id = %d AND friend_id = %d",
            $this->user_id,
            $friend_id
        ));

        $this->assertNotNull($friendship);
        $this->assertEquals('pending', $friendship->status);
    }

    public function test_wp_cron_story_cleanup() {
        // Create expired story
        $story_id = wp_insert_post(array(
            'post_type' => 'story',
            'post_title' => 'Expired Story',
            'post_author' => $this->user_id,
            'post_status' => 'publish',
            'meta_input' => array(
                'story_expires_at' => date('Y-m-d H:i:s', strtotime('-1 hour'))
            )
        ));

        // Run cron job
        do_action('snapchat_cleanup_expired_stories');

        // Check if story was deleted
        $story = get_post($story_id);
        $this->assertEquals('trash', $story->post_status);
    }
}

// Jest Test for React Components with WordPress API
import { render, screen, waitFor } from '@testing-library/react';
import { WPSnapChatAPI } from '../src/services/wp-api';
import SnapList from '../src/components/SnapList';

// Mock WordPress API
jest.mock('../src/services/wp-api');

describe('SnapList Component', () => {
    let mockWPAPI;

    beforeEach(() => {
        mockWPAPI = new WPSnapChatAPI();
        mockWPAPI.request = jest.fn();

        // Mock WordPress globals
        global.wpApiSettings = {
            root: 'http://localhost/wp-json/',
            nonce: 'test-nonce-123'
        };
    });

    test('should load snaps from WordPress API', async () => {
        const mockSnaps = [
            {
                id: 1,
                title: { rendered: 'Test Snap' },
                content: { rendered: 'Test content' },
                author: 1,
                meta: {
                    snap_expires_at: new Date(Date.now() + 86400000).toISOString(),
                    view_count: 5
                }
            }
        ];

        mockWPAPI.request.mockResolvedValue(mockSnaps);

        render();

        await waitFor(() => {
            expect(screen.getByText('Test Snap')).toBeInTheDocument();
        });

        expect(mockWPAPI.request).toHaveBeenCalledWith('snapchat/v1/snaps', {
            method: 'GET'
        });
    });

    test('should handle WordPress nonce refresh', async () => {
        // First call fails with 403
        mockWPAPI.request
            .mockRejectedValueOnce(new Error('HTTP 403'))
            .mockResolvedValueOnce([]);

        mockWPAPI.refreshNonce = jest.fn().mockResolvedValue();

        render();

        await waitFor(() => {
            expect(mockWPAPI.refreshNonce).toHaveBeenCalled();
        });
    });
});

// Test WordPress Capability Checks
describe('WordPress Capability Integration', () => {
    test('should check user capabilities before actions', async () => {
        const wpAuth = new WPAuthService();
        wpAuth.checkCapabilities = jest.fn().mockResolvedValue(true);

        const result = await wpAuth.checkCapabilities('publish_snaps');

        expect(result).toBe(true);
        expect(wpAuth.checkCapabilities).toHaveBeenCalledWith('publish_snaps');
    });
});

// Playwright E2E Tests for WordPress SnapChat
const { test, expect } = require('@playwright/test');

test.describe('WordPress SnapChat E2E', () => {
    test.beforeEach(async ({ page }) => {
        // Login to WordPress
        await page.goto('/wp-login.php');
        await page.fill('#user_login', 'testuser');
        await page.fill('#user_pass', 'testpass');
        await page.click('#wp-submit');

        // Navigate to SnapChat PWA
        await page.goto('/wp-content/plugins/snapchat/');
    });

    test('should create and view snap through WordPress', async ({ page }) => {
        // Test camera access (mock in headless)
        await page.evaluate(() => {
            navigator.mediaDevices.getUserMedia = () =>
                Promise.resolve(new MediaStream());
        });

        await page.click('[data-testid="camera-button"]');
        await page.click('[data-testid="capture-button"]');
        await page.fill('[data-testid="caption-input"]', 'Test snap from E2E');
        await page.click('[data-testid="send-button"]');

        // Verify WordPress API call
        const response = await page.waitForResponse(
            response => response.url().includes('/wp-json/snapchat/v1/snaps')
                      && response.request().method() === 'POST'
        );

        expect(response.status()).toBe(201);

        // Verify snap appears in list
        await expect(page.locator('[data-testid="snap-list"]'))
            .toContainText('Test snap from E2E');
    });

    test('should handle WordPress nonce expiration', async ({ page }) => {
        // Simulate expired nonce
        await page.evaluate(() => {
            wpApiSettings.nonce = 'expired-nonce';
        });

        await page.click('[data-testid="refresh-snaps"]');

        // Should automatically refresh nonce and retry
        await page.waitForResponse(
            response => response.url().includes('/wp-json/snapchat/v1/nonce')
        );

        await expect(page.locator('[data-testid="error-message"]'))
            .not.toBeVisible();
    });

    test('should work offline with service worker', async ({ page }) => {
        // Go offline
        await page.context().setOffline(true);

        // Try to view cached snaps
        await page.click('[data-testid="snaps-tab"]');

        // Should show cached content
        await expect(page.locator('[data-testid="offline-indicator"]'))
            .toBeVisible();

        await expect(page.locator('[data-testid="snap-list"]'))
            .toBeVisible();
    });

    test('should sync offline actions when back online', async ({ page }) => {
        // Create action while offline
        await page.context().setOffline(true);
        await page.click('[data-testid="create-snap-offline"]');

        // Go back online
        await page.context().setOffline(false);
        await page.click('[data-testid="sync-button"]');

        // Verify sync request
        await page.waitForResponse(
            response => response.url().includes('/wp-json/snapchat/v1/snaps')
        );

        await expect(page.locator('[data-testid="sync-success"]'))
            .toBeVisible();
    });
});

// WP-CLI Integration Tests
test.describe('WP-CLI Integration', () => {
    test('should activate plugin via WP-CLI', async () => {
        const { exec } = require('child_process');
        const util = require('util');
        const execPromise = util.promisify(exec);

        const { stdout } = await execPromise('wp plugin activate snapchat');
        expect(stdout).toContain('Success');

        // Verify plugin is active
        const { stdout: status } = await execPromise('wp plugin status snapchat');
        expect(status).toContain('Active');
    });
});

# CI/CD Pipeline for WordPress Plugin + PWA + Cordova
name: WordPress SnapChat Plugin Deployment

on:
  push:
    branches: [main, develop]
    tags: ['v*']
  pull_request:
    branches: [main]

jobs:
  test-php:
    runs-on: ubuntu-latest
    services:
      mysql:
        image: mysql:5.7
        env:
          MYSQL_ROOT_PASSWORD: root
          MYSQL_DATABASE: wordpress_test
        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3

    steps:
      - uses: actions/checkout@v3

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.1'
          extensions: mysql, zip

      - name: Install WordPress Test Suite
        run: |
          bash bin/install-wp-tests.sh wordpress_test root root localhost latest

      - name: Install Composer dependencies
        run: composer install --no-dev --optimize-autoloader

      - name: Run PHPUnit tests
        run: vendor/bin/phpunit

      - name: Run PHPCS
        run: vendor/bin/phpcs --standard=WordPress .

  test-js:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install dependencies
        run: npm ci

      - name: Run Jest tests
        run: npm run test:coverage

      - name: Run ESLint
        run: npm run lint

      - name: Upload coverage
        uses: codecov/codecov-action@v3

  test-e2e:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3

      - name: Setup WordPress with Docker
        run: |
          docker-compose -f docker-compose.test.yml up -d
          sleep 30

      - name: Install Playwright
        run: npx playwright install

      - name: Run E2E tests
        run: npm run test:e2e

      - name: Upload test results
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: playwright-report
          path: playwright-report/

  build-plugin:
    needs: [test-php, test-js]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3

      - name: Build React assets
        run: |
          npm ci
          npm run build:production

      - name: Install Composer dependencies
        run: composer install --no-dev --optimize-autoloader

      - name: Create plugin ZIP
        run: |
          mkdir -p dist
          zip -r dist/snapchat-plugin.zip . \
            -x "node_modules/*" "tests/*" "*.git*" "docker-compose*" \
            "playwright*" "coverage/*" "src/*" "*.md"

      - name: Upload plugin artifact
        uses: actions/upload-artifact@v3
        with:
          name: plugin-zip
          path: dist/snapchat-plugin.zip

  build-cordova:
    needs: [test-js]
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3

      - name: Setup Cordova
        run: |
          npm install -g cordova
          cd cordova && cordova platform add ios android

      - name: Build iOS
        run: |
          cd cordova
          cordova build ios --release
          # Code signing for App Store

      - name: Build Android
        run: |
          cd cordova
          cordova build android --release
          # Sign APK for Play Store

  deploy-wp-org:
    if: startsWith(github.ref, 'refs/tags/v')
    needs: [build-plugin, test-e2e]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Download plugin ZIP
        uses: actions/download-artifact@v3
        with:
          name: plugin-zip
          path: dist/

      - name: Deploy to WordPress.org
        uses: 10up/action-wordpress-plugin-deploy@stable
        env:
          SVN_USERNAME: ${{ secrets.WP_ORG_USERNAME }}
          SVN_PASSWORD: ${{ secrets.WP_ORG_PASSWORD }}
          SLUG: snapchat

  deploy-app-stores:
    if: startsWith(github.ref, 'refs/tags/v')
    needs: [build-cordova]
    runs-on: macos-latest
    steps:
      - name: Deploy to App Store
        run: |
          # Upload to App Store Connect
          xcrun altool --upload-app \
            --type ios \
            --file "cordova/platforms/ios/build/Release-iphoneos/SnapChat.ipa" \
            --username "${{ secrets.APPLE_ID }}" \
            --password "${{ secrets.APPLE_PASSWORD }}"

      - name: Deploy to Play Store
        run: |
          # Upload to Google Play Console
          # Implementation depends on fastlane or other deployment tools
          echo "Deploy to Play Store"

# WordPress Plugin Directory Structure
snapchat/
├── snapchat.php                 # Main plugin file
├── readme.txt                   # WordPress.org readme
├── composer.json               # PHP dependencies
├── package.json                # Node.js dependencies
├── webpack.config.js           # Asset bundling
├── includes/                   # PHP classes
│   ├── class-snapchat.php     # Main plugin class
│   ├── class-rest-api.php     # REST API controllers
│   ├── class-database.php     # Database operations
│   └── services/              # Service classes
├── admin/                     # WordPress admin interface
│   ├── js/                   # React admin components
│   ├── css/                  # Admin styles
│   └── partials/             # PHP admin templates
├── public/                    # Public-facing functionality
│   ├── js/                   # PWA JavaScript
│   ├── css/                  # PWA styles
│   └── sw.js                 # Service worker
├── assets/                    # Static assets
│   ├── images/
│   └── icons/
├── languages/                 # Translation files
├── cordova/                   # Cordova app wrapper
│   ├── config.xml
│   ├── www/                  # Symlink to public/
│   └── platforms/
├── tests/                     # Test files
│   ├── phpunit/              # PHPUnit tests
│   ├── jest/                 # Jest tests
│   └── e2e/                  # Playwright tests
└── bin/                       # Build scripts
    ├── install-wp-tests.sh
    └── build-plugin.sh

# Main Plugin File (snapchat.php)
run();
}
add_action('plugins_loaded', 'snapchat_init');

// Activation hook
register_activation_hook(__FILE__, array('SnapChat\Database', 'create_tables'));

// Deactivation hook
register_deactivation_hook(__FILE__, array('SnapChat\Plugin', 'deactivate'));

// Uninstall hook
register_uninstall_hook(__FILE__, array('SnapChat\Plugin', 'uninstall'));

// Application Monitoring
class MonitoringService {
    static init() {
        // Performance monitoring
        this.setupPerformanceObserver();

        // Error tracking
        window.addEventListener('error', this.handleGlobalError);
        window.addEventListener('unhandledrejection', this.handleUnhandledRejection);

        // User analytics
        this.trackUserBehavior();
    }

    static setupPerformanceObserver() {
        if ('PerformanceObserver' in window) {
            const observer = new PerformanceObserver((list) => {
                list.getEntries().forEach((entry) => {
                    this.sendMetric({
                        type: 'performance',
                        name: entry.name,
                        duration: entry.duration,
                        timestamp: entry.startTime
                    });
                });
            });

            observer.observe({ entryTypes: ['measure', 'navigation'] });
        }
    }

    static trackUserBehavior() {
        // Track user interactions
        document.addEventListener('click', (e) => {
            if (e.target.dataset.track) {
                this.sendEvent('click', {
                    element: e.target.dataset.track,
                    timestamp: Date.now()
                });
            }
        });

        // Track page views
        this.sendEvent('page_view', {
            url: window.location.pathname,
            timestamp: Date.now()
        });
    }

    static async sendMetric(metric) {
        try {
            await fetch('/api/v1/metrics', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(metric)
            });
        } catch (error) {
            console.error('Failed to send metric:', error);
        }
    }
}

// Health Check Endpoint
app.get('/health', (req, res) => {
    const health = {
        status: 'healthy',
        timestamp: new Date().toISOString(),
        uptime: process.uptime(),
        memory: process.memoryUsage(),
        database: 'connected',
        redis: 'connected',
        version: process.env.APP_VERSION
    };

    res.json(health);
});

// React Component Structure
const SnapChatApp = () => {
    return (
        
            

                
                    } />
                    } />
                    } />
                    } />
                    } />
                

                
                
            
        
    );
};

// Camera Interface Component
const CameraView = () => {
    const [isRecording, setIsRecording] = useState(false);
    const [filters, setFilters] = useState([]);

    return (
        

            
    );
};

// Responsive Design CSS
.snapchat-app {
    height: 100vh;
    display: flex;
    flex-direction: column;
    background: #000;
    color: #fff;
    font-family: 'Helvetica Neue', sans-serif;
}

.camera-view {
    flex: 1;
    position: relative;
    overflow: hidden;
}

.camera-preview {
    width: 100%;
    height: 100%;
    object-fit: cover;
}

.camera-controls {
    position: absolute;
    bottom: 20px;
    left: 50%;
    transform: translateX(-50%);
    display: flex;
    gap: 20px;
    align-items: center;
}

.capture-btn {
    width: 70px;
    height: 70px;
    border-radius: 50%;
    border: 4px solid #fff;
    background: transparent;
    font-size: 24px;
    cursor: pointer;
    transition: all 0.2s;
}

.capture-btn:active {
    transform: scale(0.9);
    background: rgba(255, 255, 255, 0.2);
}

@media (max-width: 768px) {
    .camera-controls {
        bottom: 40px;
    }

    .capture-btn {
        width: 60px;
        height: 60px;
    }
}