const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const passport = require('passport');
const GoogleStrategy = require('passport-google-oauth20').Strategy;
const FacebookStrategy = require('passport-facebook').Strategy;
const GitHubStrategy = require('passport-github2').Strategy;
const nodemailer = require('nodemailer');
const axios = require('axios');
const { CloudinaryStorage } = require('multer-storage-cloudinary');
const cloudinary = require('cloudinary').v2;
const multer = require('multer');
const MGZonStrategy = require('passport-mgzon');
const { jsPDF } = require('jspdf');
const Jimp = require('jimp');
const fs = require('fs');
const fetch = global.fetch || require('node-fetch');
const pdfParse = require('pdf-parse');
const { createHash } = require('crypto');
const crypto = require('crypto');

const path = require('path');
require('jspdf-autotable');
require('dotenv').config();


const AdmZip = require('adm-zip');

const winston = require('winston');

// ✅ انقل تعريف logger هنا (قبل استخدامه)
const logger = winston.createLogger({
    level: 'info',
    format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.json()
    ),
    transports: [
        new winston.transports.Console(),
    ]
});

// ✅ الآن logger موجود، يقدر يستخدم
const allowedRedirectUris = process.env.ALLOWED_REDIRECT_URIS
    ? process.env.ALLOWED_REDIRECT_URIS.split(',')
    : [];
if (!allowedRedirectUris.length) {
    logger.error('ALLOWED_REDIRECT_URIS is not defined in .env');
    process.exit(1);
}

// ✅ طباعة قيمة ALLOWED_REDIRECT_URIS في الـ Console (للتأكد من قراءتها بشكل صحيح)
console.log('========================================');
console.log('🔍 ALLOWED_REDIRECT_URIS from env:', process.env.ALLOWED_REDIRECT_URIS);
console.log('📋 ALLOWED_REDIRECT_URIS array:', allowedRedirectUris);
console.log('========================================');


const sharp = require('sharp');
// const { body, validationResult } = require('express-validator');
const swaggerJsDoc = require('swagger-jsdoc');
const { body, validationResult, param } = require('express-validator');
const swaggerUi = require('swagger-ui-express');
// const { body, validationResult, param } = require('express-validator');
const csurf = require('csurf');
const Sentry = require('@sentry/node');
const morgan = require('morgan');
const cookieParser = require('cookie-parser');
const timeout = require('express-timeout-handler');
const compression = require('compression');
const SentryTracing = require('@sentry/tracing');
const helmet = require('helmet');

const app = express();
app.set('trust proxy', true);

const getSocketClient = require('./utils/socket-client');



app.use(cors({
  origin: '*',  // ⚠️ للاختبار فقط
  credentials: true,
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization', 'X-CSRF-Token', 'X-New-Token', 'x-refresh-token']
}));

const cron = require('node-cron');
const { google } = require('googleapis');
const { Handlers } = require('@sentry/node');
const rateLimit = require('express-rate-limit');
const OAuth2Strategy = require('passport-oauth2').Strategy;
// const jsPDF = require('jspdf');
const webpush = require('web-push');

const { Document, Packer, Paragraph, TextRun, Table, TableRow, TableCell, WidthType } = require('docx');

const ShortcodeService = require('./services/ShortcodeService');
const aiService = require('./services/aiService');

const StoreShortcode = require('./models/StoreShortcode');
const TemplateStore = require('./models/TemplateStore');
// const { buildContributionGraph, getDayActivities } = require('./services/contribution.service');


// ❌ احذف هذا السطر لأنه مكرر (logger عرفته فوق)
// const logger = winston.createLogger({...});


Sentry.init({
    dsn: process.env.SENTRY_DSN,
    tracesSampleRate: 0.2, // تتبع 20% من الطلبات
    environment: process.env.NODE_ENV || 'development',
});


// Endpoint لتحديث وجلب عدد الزوار
app.post('/api/visits', async (req, res) => {
    try {
        let visit = await Visit.findOne();
        if (!visit) {
            visit = new Visit({ count: 1930537 });
        }
        visit.count += 1;
        await visit.save();
        res.json({ visitCount: visit.count });
    } catch (error) {
        logger.error(`Error updating visit count: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to update visit count' });
    }
});


// GET /api/projects/:projectId/og-image - صورة ديناميكية للمشروع
app.get('/api/projects/:projectId/og-image', async (req, res) => {
    try {
        const { projectId } = req.params;
        
        // جلب بيانات المشروع
        const project = await Project.findById(projectId);
        if (!project) {
            return res.status(404).json({ error: 'Project not found' });
        }
        
        // جلب بيانات صاحب المشروع
        const user = await User.findById(project.userId);
        const ownerName = user?.profile?.nickname || user?.username || 'User';
        
        // إنشاء صورة باستخدام Sharp
        const width = 1200;
        const height = 630; // نسبة OG image standard (1.91:1)
        
        // إنشاء SVG template
        const svg = `
            <svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
                <!-- Background gradient -->
                <defs>
                    <linearGradient id="grad" x1="0%" y1="0%" x2="100%" y2="100%">
                        <stop offset="0%" style="stop-color:#1a1a2e;stop-opacity:1" />
                        <stop offset="50%" style="stop-color:#16213e;stop-opacity:1" />
                        <stop offset="100%" style="stop-color:#0f3460;stop-opacity:1" />
                    </linearGradient>
                    
                    <linearGradient id="accent" x1="0%" y1="0%" x2="100%" y2="0%">
                        <stop offset="0%" style="stop-color:#667eea" />
                        <stop offset="100%" style="stop-color:#764ba2" />
                    </linearGradient>
                </defs>
                
                <!-- Background -->
                <rect width="100%" height="100%" fill="url(#grad)" />
                
                <!-- Pattern overlay -->
                <pattern id="pattern" x="0" y="0" width="40" height="40" patternUnits="userSpaceOnUse">
                    <circle cx="20" cy="20" r="1.5" fill="rgba(255,255,255,0.05)" />
                </pattern>
                <rect width="100%" height="100%" fill="url(#pattern)" />
                
                <!-- Accent bar at top -->
                <rect x="0" y="0" width="100%" height="6" fill="url(#accent)" />
                
                <!-- Project Icon -->
                <circle cx="${width / 2}" cy="180" r="60" fill="rgba(102, 126, 234, 0.15)" stroke="url(#accent)" stroke-width="3"/>
                <text x="${width / 2}" y="192" text-anchor="middle" font-family="Arial, sans-serif" font-size="48" fill="#667eea" font-weight="bold">📁</text>
                
                <!-- Project Title -->
                <text x="${width / 2}" y="300" text-anchor="middle" font-family="Arial, sans-serif" font-size="42" fill="#ffffff" font-weight="bold" max-width="1000">
                    ${escapeXml(project.title.substring(0, 60))}
                </text>
                
                <!-- Project Description (if exists) -->
                ${project.description ? `
                    <text x="${width / 2}" y="370" text-anchor="middle" font-family="Arial, sans-serif" font-size="22" fill="#a0aec0" max-width="900">
                        ${escapeXml(project.description.substring(0, 100))}${project.description.length > 100 ? '...' : ''}
                    </text>
                ` : ''}
                
                <!-- Stars / Rating -->
                <g transform="translate(${width / 2 - 100}, 430)">
                    ${Array.from({ length: Math.min(5, project.stars || 0) }, (_, i) => `
                        <text x="${i * 50}" y="0" font-family="Arial" font-size="36" fill="#fbbf24">★</text>
                    `).join('')}
                    ${Array.from({ length: 5 - Math.min(5, project.stars || 0) }, (_, i) => `
                        <text x="${(Math.min(5, project.stars || 0) + i) * 50}" y="0" font-family="Arial" font-size="36" fill="#4a5568">★</text>
                    `).join('')}
                </g>
                
                <!-- Footer -->
                <rect x="0" y="${height - 80}" width="${width}" height="80" fill="rgba(0,0,0,0.3)" />
                <text x="60" y="${height - 40}" font-family="Arial, sans-serif" font-size="16" fill="#718096">
                    ${escapeXml(ownerName)}
                </text>
                <text x="${width - 60}" y="${height - 40}" text-anchor="end" font-family="Arial, sans-serif" font-size="16" fill="#718096">
                    MGZon
                </text>
                
                <!-- Decorative circles -->
                <circle cx="100" cy="${height - 60}" r="40" fill="rgba(102, 126, 234, 0.08)" />
                <circle cx="${width - 100}" cy="100" r="80" fill="rgba(118, 75, 162, 0.08)" />
            </svg>
        `;
        
        // تحويل SVG إلى PNG
        const imageBuffer = await sharp(Buffer.from(svg))
            .png()
            .toBuffer();
        
        res.setHeader('Content-Type', 'image/png');
        res.setHeader('Cache-Control', 'public, max-age=86400'); // Cache for 24 hours
        res.send(imageBuffer);
        
    } catch (error) {
        console.error('Error generating project image:', error);
        // Return default image
        res.sendFile(path.join(__dirname, 'public', 'assets', 'img', 'default-project.png'));
    }
});

// Helper function to escape XML
function escapeXml(str) {
    if (!str) return '';
    return str
        .replace(/&/g, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&apos;');
}

const visitSchema = new mongoose.Schema({
    count: { type: Number, default: 1930537 } // القيمة الابتدائية
});
const Visit = mongoose.model('Visit', visitSchema);


app.use(express.json({ type: ['application/json', 'text/plain'] }));

app.use(cookieParser());
app.use(Handlers.requestHandler());
app.use(morgan('combined', { stream: { write: message => logger.info(message.trim()) } }));




app.use(compression({ level: 6, threshold: 1024 }));
app.use(timeout.handler({ timeout: 10000, onTimeout: (req, res) => {
    logger.error(`Request timed out: ${req.originalUrl}`);
    res.status(504).json({ error: 'Request timed out' });
}}));


// ============================================
// 🛡️ GitHub Actions Bypass Middleware
// ============================================
const MGZON_ACTIONS_TOKEN = process.env.MGZON_ACTIONS_TOKEN;

app.use((req, res, next) => {
    const token = req.headers['x-github-token'];
    
    // لو الطلب جاي من GitHub Actions بالتوكن الصحيح
    if (token && token === MGZON_ACTIONS_TOKEN) {
        logger.info(`✅ GitHub Actions bypass for: ${req.originalUrl}`);
        return next(); // تخطي كل الحماية (CSRF, CORS, إلخ)
    }
    
    next();
});


// ✅ حماية CSRF مع استثناء مسار تسجيل الدخول
const csrfProtection = csurf({ cookie: true });

// قائمة المسارات المستثناة من CSRF
const excludedPaths = [
    '/api/login', 
    '/graphql',
    '/api/register', 
    '/api/forgot-password', 
    '/api/reset-password',
    '/api/verify-email',       
    '/api/resend-verification',
    '/api/projects',
    '/api/skills',
    '/api/comments',
    '/api/users',
    '/api/users/search',
    '/api/upload',
    '/api/files/list',
    '/api/files/delete',
    '/api/visits',
    '/api/profile/me',
    '/api/profile/:nickname',
    '/api/check-nickname',

    '/api/store/settings',
    '/api/store/enable',
    '/api/store/products',
    '/api/store/:username/products',
    '/api/store/products/:productId',
    '/api/store/theme',
    '/api/store/theme/reset',
    '/api/store/shortcodes/parse',
    '/api/store/shortcodes',
    '/api/store/shortcodes/:id',
    '/api/store/shortcodes/preview',

    '/api/cart',
    '/api/cart/add',
    '/api/cart/update',
    '/api/cart/remove',
    '/api/cart/clear-store',
    '/api/cart/store/:storeId',
    '/api/cart/clear-all',
    '/api/cart/summary',
    '/api/checkout/payment-info/:storeId',
    '/api/checkout/:storeId',

    '/api/templates/debug/:id',
    '/api/store/orders/buyer',
    '/api/store/orders/seller',
    '/api/store/orders/:orderId/status',
    '/api/store/earnings',
    '/api/store/cart',
    '/api/admin/stores',
    '/api/store/products/:productId/review',
    '/api/store/:storeId/follow',
    '/api/store/:storeId/followers',
    '/api/store/coupons',
    '/api/store/validate-coupon',
    '/api/store/analytics', 
    '/api/webhooks/paypal',
    '/api/webhooks/stripe',
    '/api/store/orders/:orderId',
    '/api/store/orders/:orderId/download/:productId',
    '/api/store/orders/:orderId/upload',
    '/api/store/orders/:orderId/file-url',

    '/api/admin/subscription/plans',
    '/api/admin/subscription/plans/:planId',
    '/api/subscription/plans',
    '/api/admin/subscription/payment-methods',
    '/api/admin/subscription/payment-methods/:methodId',
    '/api/subscription/payment-methods',
    '/api/subscription/subscribe',
    '/api/subscription/my',
    '/api/admin/subscriptions',
    '/api/admin/subscriptions/:subId/approve',
    '/api/admin/subscriptions/:subId/reject',
    '/api/admin/subscriptions/:subId/cancel',
    '/api/users/:userId/subscription-status',
    '/api/admin/subscription/stats',
    '/api/store/:storeId/follow-status', 
    '/api/store/orders/:orderId/cancel',
    '/api/subscription/settings',
    '/api/subscription/check',
    '/api/subscription/renew',
    '/api/subscription/cancel',
    '/api/users/:userId/badges',
    '/api/profile/:userId/view',
    '/api/achievements/:slug',
    '/api/users/:userId',
    '/api/admin/stores/:userId/toggle',
    '/api/admin/stores/:userId',
    '/api/admin/products',
    '/api/admin/products/:productId/toggle',
    '/api/admin/products/:productId',
    '/api/admin/orders',
    '/api/admin/orders/:orderId/status',
    '/api/admin/platform-banks',
    '/api/admin/platform-banks/:bankId',
    '/api/admin/users/all',
    '/api/admin/users/:userId/make-admin',
    '/api/admin/logs',
    '/api/admin/export/users',
    '/api/admin/export/orders',
    '/api/admin/backup',
    '/shop/preview',
    '/api/store/preview-data',
    '/api/store/preview/update',
    '/shop/preview/product/:productId',
    '/api/store/preview/product/:productId',
    '/api/store/:username',
    '/api/store/:username/follow-status',
    '/api/store/preview/products',
    '/api/store/preview',
    '/api/store/preview/settings',
    '/api/store/preview/sections',
    '/api/store/search/products',
    '/api/store/search/stores',
    '/api/store/search',
    '/api/store/sections/order',
    '/api/store/contact',
    '/api/store/:username/analytics',
    '/api/analytics/track-store-view',
    '/api/store/me',
    '/api/store/:username/pages',
    '/api/store/:username/page/:slug', 
    '/api/store/my/pages',
    '/api/store/my/pages/:pageId',
    '/api/store/preview/page/:slug',
    '/api/store/preview/pages',
    '/api/store/my/pages/upload',
    '/api/store/my/pages/upload-zip',
    '/api/store/my/pages/reorder',
    '/api/store/my/pages/preview',
    '/api/store/:username/:slug',
    '/api/store/my/pages/stats',

    '/api/backgrounds',
    '/api/backgrounds/categories',
    '/api/backgrounds/:id',
    '/api/store/background',
    '/api/store/backgrounds/upload',
    '/api/store/backgrounds/:id',
    '/api/store/background/current',
    '/api/store/background/history',

    '/api/store/theme/upload',
    '/api/store/theme/preview',
    '/api/store/my/pages/:pageId/duplicate',
    '/api/templates/serve/:slug/*',
    '/api/templates/serve/:slug',
    '/api/templates/serve/:slug/file/*',
    '/api/templates/serve/:slug/file',
    '/api/store/my/pages/:pageId/export',
    '/api/store/preview/follow-status',
    '/api/visual-builder/sections',
    '/api/visual-builder/section',
    '/api/visual-builder/section/:sectionId',
    '/api/visual-builder/section-types',
    '/api/visual-builder/preview',
    '/api/visual-builder/duplicate/:sectionId',
    '/api/store/reset-template',

    '/api/ai/generate-layout',
    '/api/ai/generate-shortcode',
    '/api/ai/suggest-design',
    '/api/ai/enhance-description',
    '/api/ai/suggest-keywords',
    '/api/ai/generate-store-description',
    '/api/ai/clear-cache',
    '/api/store/:username/full-template',
    '/api/ai/generate-template',
    '/api/ai/admin/stats',
    '/api/ai/admin/clear-cache',

    '/api/store/layout-template',
    '/api/store/layout-template/reset',
    '/api/store/apply-layout/:userId',
    '/api/store/layout-templates',
    '/api/templates',
    '/api/templates/featured',
    '/api/templates/popular',
    '/api/templates/categories',
    '/api/templates/:id',
    '/api/templates/:id/preview',
    '/api/templates/:id/apply',
    '/api/templates/:id/review',
    '/api/templates/my/installed',

    '/api/profile/project-progress',
    '/api/user-interactions',
    '/api/projects/:projectId/og-image',
    '/api/comments/:projectId',
    '/api/educations',
    '/api/profile/contact',
    '/api/conversations',
    '/api/conversations/:conversationId/messages',
    '/api/users/me/projects/:projectId',
    '/api/notifications',
    '/api/facebook/posts',
    '/api/github/repos',
    '/api/verify-token',
    // ✅ أضف هذه المسارات الجديدة
    '/api/profile/appearance',
    '/api/profile/seo',
    '/api/profile',
    '/api/refresh-token',
    '/api/logout',
    '/api/parse-resume',  
    '/api/comments/:commentId/report',
    '/api/profile/resume/:nickname',
    '/api/profile/pdf/:nickname',
    // ✅ مسارات التفاعل مع التعليقات (جديدة)
    '/api/comments/:commentId/like',
    '/api/comments/:commentId/reply',
    '/api/posts/:postId/comments/:commentId/reply',
    '/api/posts/comments/:commentId/reply/:replyId/like',
    '/api/posts/:postId/comments/:commentId/report',
    '/api/comments/:commentId',
    '/api/user/interactions/privacy',
    '/api/profile/:nickname/interactions',
    '/api/github/status',
    '/api/github/import-repo',
    '/api/user/education', 
    '/api/github/disconnect',
    '/api/github-projects',
    '/api/admin/comments/reported',
    '/api/admin/comments/:commentId/resolve-report',
    '/api/notifications/read-all',
    '/api/educations/:id',
    '/api/notifications/:id/read',
    '/api/notifications/:id',
    '/api/notifications/unread-count',
    '/api/site-settings',
    '/api/site-settings',
    '/api/profile/id/:userId',
    '/api/reports',
    '/api/posts/feed',
    '/api/users/me/pin/:postId',
    '/api/users/:userId/stats',
    '/api/posts/search',
    '/api/posts/suggested',
    '/api/users/explore',
    '/api/posts/saved',
    '/api/stories',
    '/api/stories/feed',
    '/api/stories/:storyId/view',

    '/api/stories/:storyId/reaction',
    '/api/stories/:storyId',
    '/api/stories/user/:userId',
    '/api/stories/all',
    '/api/stories/discover',
    '/api/stories/stats',
    '/api/stories/expired',

    '/api/jobs',
    '/api/jobs/my',
    '/api/admin/messages/reports',
    '/api/jobs/:jobId',
    '/api/posts/share-to-profile',
    '/api/messages/:messageId/report',
    '/api/jobs/:jobId/apply',
    '/api/jobs/applications/my',
    '/api/jobs/applications/:applicationId/withdraw',
    '/api/admin/messages/reports/:reportId/resolve',
    '/api/jobs/:jobId/applications',
    '/api/jobs/applications/:applicationId/status',
    '/api/jobs/applications/:applicationId/interview',
    '/api/jobs/:jobId/save',
    '/api/jobs/saved',
    '/api/jobs/categories',
    '/api/jobs/stats',
    '/api/jobs/:jobId/duplicate',
    '/api/jobs/my/applications',
    '/api/users/me/followers',
    '/api/users/me/following',
    '/api/jobs/applications/:applicationId',
    '/api/comments/:postId/:commentId',
    '/api/users/:userId/following',
    '/api/users/me/following/ids',
    '/api/users/me/following/check',
    '/api/users/trending',
    '/api/users/suggestions',
    '/api/trending/topics',
    '/api/trending/posts',
    '/api/users/:userId/followers',
    '/api/users/:userId/follow',
    '/api/posts/:postId',
    '/api/upload-cover',
    '/api/cover',
    '/api/posts/:postId/like',
    '/api/posts/:postId/save',
    '/api/posts/:postId/comments',
    '/api/profile/design-settings',
    '/api/profile/design-settings/reset',
    '/api/posts/comments/:commentId/like',
    '/api/posts/comments/:commentId',
    '/api/posts/comments/:commentId/report',

    '/api/health',
    '/api/subscribe',
    '/api/ask',
    '/api/chat',
    '/api/converse',
    '/api/conversations/export',
    '/auth/magic-link',
    '/auth/verify-magic-link',
    '/auth/resend-magic-link',
    
    '/auth/github',
    '/auth/facebook',
    '/auth/google',

    '/api/profile/custom-sections',
    '/api/profile/custom-sections/:sectionId',
    '/api/admin/jobs/categories',
    '/api/admin/jobs/categories/:categoryId',
    '/api/jobs/categories/stats',
    '/api/posts/:postId/share',
    '/api/posts/user/:userId',
    '/api/posts',
    '/api/upload-logo',
    '/api/comments/:commentId/privacy',
    '/api/messages/:messageId',
    '/api/conversations/:conversationId/read',
    '/api/conversations/unread/count',
    '/api/users/:userId/contributions',
    '/api/users/:userId/contributions/:date',
    '/api/analytics/also-viewed',
    '/api/pages/suggestions',
    '/api/pages/:pageId/follow',
    '/api/analytics/profile',
    '/api/analytics/track-view',
    '/api/ratings',
    '/api/ratings/:userId',
    '/api/websocket/config',
    '/api/websocket/token',
    '/api/conversations/:conversationId/typing',
    '/api/conversations/:conversationId/clear',
    '/api/conversations/:conversationId/pin',
    '/api/messages/:messageId/forward',
    '/api/messages/:messageId/reaction',
    '/sitemap-users.xml',
    '/sitemap.xml',
    '/sitemap-static.xml',
    '/sitemap-products.xml',
    '/sitemap-stores.xml',

    '/sitemap-images.xml',
    '/sitemap-comments.xml',
    '/sitemap-posts.xml',
    '/sitemap-jobs.xml', 
    '/sitemap-templates.xml',
    '/sitemap-pages.xml',
    '/sitemap-tags.xml',

    '/api/follow/requests',
    '/api/follow/requests/:requestId/accept',
    '/api/follow/requests/:requestId/decline',
    '/api/profile/section-order',
    '/api/profile/layout-presets',
    '/api/profile/layout-presets/:id',
    '/api/profile/:nickname/ai-status',
    '/api/profile/:nickname/ask',
    '/api/ai/conversations',
    '/api/profile/section-names',
    '/api/ai/stats',
    '/robots.txt',
    '/api/projects/:projectId'
];

app.use((req, res, next) => {
    // التحقق إذا كان المسار في القائمة أو يبدأ بأي مسار من القائمة (للتعامل مع :id)
    const isExcluded = excludedPaths.some(excludedPath => {
        // لو المسار في القائمة فيه :id (زي /api/skills/:skillId)
        if (excludedPath.includes(':')) {
            const basePath = excludedPath.split('/:')[0];
            return req.path.startsWith(basePath);
        }
        // المطابقة التامة أو المسار يبدأ بيه مع /
        return req.path === excludedPath || req.path.startsWith(excludedPath + '/');
    });
    
    if (isExcluded) {
        return next();
    }
    csrfProtection(req, res, next);
});

app.use((req, res, next) => {
    const start = Date.now();
    res.on('finish', () => {
        const duration = Date.now() - start;
        logger.info(`Request: ${req.method} ${req.originalUrl} - ${res.statusCode} - ${duration}ms`);
    });
    next();
});







app.get('/api/check-session', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId).select('username email profile');
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        res.json({
            valid: true,
            user: {
                userId: req.user.userId,
                email: req.user.email,
                isAdmin: req.user.isAdmin,
                username: user.username,
                profile: user.profile
            }
        });
    } catch (error) {
        logger.error(`Error checking session: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to check session' });
    }
});


const swaggerOptions = {
    swaggerDefinition: {
        openapi: '3.0.0',
        info: {
            title: 'Portfolio API',
            version: '1.0.0',
            description: 'API for Ibrahim Al-Asfar\'s portfolio website'
        },
        servers: [
            { url: process.env.BASE_URL, description: 'Production server' },
            { url: 'http://localhost:7860', description: 'Local development server' }
        ],
        components: {
            securitySchemes: {
                bearerAuth: {
                    type: 'http',
                    scheme: 'bearer',
                    bearerFormat: 'JWT'
                }
            }
        }
    },
    apis: ['./docs/swagger.yaml']
};
const swaggerDocs = swaggerJsDoc(swaggerOptions);
app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocs));
app.use(passport.initialize());



cloudinary.config({
    cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
    api_key: process.env.CLOUDINARY_API_KEY,
    api_secret: process.env.CLOUDINARY_API_SECRET
});

const storage = new CloudinaryStorage({
    cloudinary: cloudinary,
    params: {
        folder: 'Uploads',
        allowed_formats: ['jpeg', 'png', 'pdf'],
        resource_type: 'auto'
    }
});

// إعداد تخزين مؤقت للملفات
const memoryStorage = multer.memoryStorage();
const uploadTheme = multer({
    storage: memoryStorage,
    limits: { fileSize: 50 * 1024 * 1024 },
    fileFilter: (req, file, cb) => {
        if (file.originalname.endsWith('.zip')) {
            cb(null, true);
        } else {
            cb(new Error('Only ZIP files are allowed'), false);
        }
    }
});

// ============================================
// POST UPLOAD - رفع ميديا المنشورات
// ============================================
const uploadPost = multer({
    storage: new CloudinaryStorage({
        cloudinary: cloudinary,
        params: async (req, file) => {
            let resourceType = 'auto';
            let folder = `Posts/${req.user.userId}`;
            let allowedFormats = [];
            let transformation = [];
            
            // 📸 الصور
            if (file.mimetype.startsWith('image/')) {
                resourceType = 'image';
                allowedFormats = [
                    'jpeg', 'jpg', 'png', 'gif', 'webp', 
                    'bmp', 'tiff', 'tif', 'ico', 'svg', 'avif'
                ];
                folder = `Posts/${req.user.userId}/images`;
                transformation = [
                    { quality: 'auto:good' },
                    { fetch_format: 'auto' }
                ];
            } 
            // 🎬 الفيديوهات
            else if (file.mimetype.startsWith('video/')) {
                resourceType = 'video';
                allowedFormats = ['mp4', 'webm', 'ogg', 'mov', 'avi', 'mkv'];
                folder = `Posts/${req.user.userId}/videos`;
                transformation = [
                    { quality: 'auto' }
                ];
            }
            
            return {
                folder: folder,
                allowed_formats: allowedFormats,
                resource_type: resourceType,
                public_id: `post_${Date.now()}_${file.originalname.split('.')[0]}`,
                transformation: transformation.length > 0 ? transformation : undefined
            };
        }
    }),
    limits: {
        fileSize: 50 * 1024 * 1024 // 50MB
    },
    fileFilter: (req, file, cb) => {
        const imageTypes = [
            'image/jpeg', 'image/jpg', 'image/png', 'image/gif', 
            'image/webp', 'image/bmp', 'image/tiff', 'image/tif',
            'image/x-icon', 'image/svg+xml', 'image/avif'
        ];
        
        const videoTypes = [
            'video/mp4', 'video/webm', 'video/ogg', 'video/quicktime',
            'video/x-msvideo', 'video/x-matroska'
        ];
        
        const allAllowed = [...imageTypes, ...videoTypes];
        
        if (!allAllowed.includes(file.mimetype)) {
            return cb(new Error(
                'Unsupported file type. Supported formats:\n' +
                '📸 Images: JPEG, PNG, GIF, WEBP, BMP, TIFF, SVG, AVIF\n' +
                '🎬 Videos: MP4, WEBM, OGG, MOV, AVI, MKV'
            ), false);
        }
        
        let maxSize = 50 * 1024 * 1024;
        if (file.mimetype.startsWith('image/')) {
            maxSize = 10 * 1024 * 1024; // 10MB للصور
        } else if (file.mimetype.startsWith('video/')) {
            maxSize = 50 * 1024 * 1024; // 50MB للفيديوهات
        }
        
        if (file.size > maxSize) {
            const typeName = file.mimetype.startsWith('image/') ? 'images' : 'videos';
            return cb(new Error(
                `File too large. Maximum ${maxSize / 1024 / 1024}MB for ${typeName}`
            ), false);
        }
        
        cb(null, true);
    }
});


const upload = multer({
    storage: new CloudinaryStorage({
        cloudinary: cloudinary,
        params: async (req, file) => ({
            folder: `Uploads/${req.user.userId}`,
            allowed_formats: ['jpeg', 'png', 'pdf'],
            resource_type: 'auto',
            public_id: `${Date.now()}_${file.originalname}`
        })
    }),
    limits: { fileSize: 5 * 1024 * 1024 },
    fileFilter: (req, file, cb) => {
        const allowedTypes = ['image/jpeg', 'image/png', 'application/pdf'];
        if (!allowedTypes.includes(file.mimetype)) {
            return cb(new Error('Only JPEG, PNG, or PDF files are allowed'));
        }
        cb(null, true);
    }
});


// ============================================
// Multer configuration for HTML/JS/CSS/ZIP files
// ============================================
const uploadHTML = multer({
    storage: multer.memoryStorage(), // ✅ تخزين مؤقت في الذاكرة للمعالجة
    limits: { fileSize: 10 * 1024 * 1024 }, // 10MB
    fileFilter: (req, file, cb) => {
        const allowedTypes = [
            'text/html',
            'text/css',
            'text/javascript',
            'application/javascript',
            'application/x-javascript',
            'application/zip',
            'application/x-zip-compressed',
            'application/x-html+xml'
        ];
        
        const allowedExtensions = ['.html', '.htm', '.css', '.js', '.zip'];
        const ext = '.' + file.originalname.split('.').pop();
        
        if (allowedTypes.includes(file.mimetype) || allowedExtensions.includes(ext)) {
            cb(null, true);
        } else {
            cb(new Error('Only HTML, CSS, JS, or ZIP files are allowed'), false);
        }
    }
});


const uploadPDF = multer({
    storage: multer.memoryStorage(), 
    limits: { fileSize: 5 * 1024 * 1024 },
    fileFilter: (req, file, cb) => {
        if (file.mimetype !== 'application/pdf') {
            return cb(new Error('Only PDF files are allowed'));
        }
        cb(null, true);
    }
});




// ============================================
// STORY UPLOAD - رفع ميديا القصص (مطور)
// ============================================
const uploadStory = multer({
    storage: new CloudinaryStorage({
        cloudinary: cloudinary,
        params: async (req, file) => {
            // تحديد نوع المورد
            let resourceType = 'auto';
            let folder = `Stories/${req.user.userId}`;
            let allowedFormats = [];
            let transformation = [];
            let eager = [];
            
            // 📸 الصور
            if (file.mimetype.startsWith('image/')) {
                resourceType = 'image';
                allowedFormats = [
                    'jpeg', 'jpg', 'png', 'gif', 'webp', 
                    'bmp', 'tiff', 'tif', 'ico', 'svg', 'avif', 'heic', 'heif'
                ];
                folder = `Stories/${req.user.userId}/images`;
                transformation = [
                    { quality: 'auto:good' },
                    { fetch_format: 'auto' }
                ];
                eager = [
                    { width: 1080, height: 1920, crop: 'limit' },
                    { width: 540, height: 960, crop: 'limit' }
                ];
            } 
            // 🎬 الفيديوهات
            else if (file.mimetype.startsWith('video/')) {
                resourceType = 'video';
                allowedFormats = [
                    'mp4', 'webm', 'ogg', 'mov', 'avi', 
                    'mkv', 'flv', 'wmv', 'm4v', 'mpg', 'mpeg', '3gp'
                ];
                folder = `Stories/${req.user.userId}/videos`;
                transformation = [
                    { quality: 'auto' }
                ];
                eager = [
                    { format: 'mp4', quality: 'auto' },
                    { format: 'webm', quality: 'auto' }
                ];
            }
            // 🎵 الصوتيات
            else if (file.mimetype.startsWith('audio/')) {
                resourceType = 'video'; // Cloudinary يتعامل مع الصوت كـ video
                allowedFormats = ['mp3', 'wav', 'aac', 'ogg', 'm4a', 'flac', 'webm'];
                folder = `Stories/${req.user.userId}/audio`;
                transformation = [
                    { quality: 'auto' },
                    { audio_codec: 'aac' }
                ];
                eager = [
                    { format: 'mp3', audio_codec: 'mp3' },
                    { format: 'm4a', audio_codec: 'aac' }
                ];
                
                // ✅ إرجاع مباشر للصوتيات
                return {
                    folder: folder,
                    allowed_formats: allowedFormats,
                    resource_type: resourceType,
                    public_id: `audio_${Date.now()}_${file.originalname.split('.')[0]}`,
                    transformation: transformation,
                    eager: eager,
                    eager_async: true
                };
            }
            
            return {
                folder: folder,
                allowed_formats: allowedFormats,
                resource_type: resourceType,
                public_id: `story_${Date.now()}_${file.originalname.split('.')[0]}`,
                transformation: transformation.length > 0 ? transformation : undefined,
                eager: eager.length > 0 ? eager : undefined,
                eager_async: true
            };
        }
    }),
    limits: {
        fileSize: 50 * 1024 * 1024 // 50MB
    },
    fileFilter: (req, file, cb) => {
        const imageTypes = [
            'image/jpeg', 'image/jpg', 'image/png', 'image/gif', 
            'image/webp', 'image/bmp', 'image/tiff', 'image/tif',
            'image/x-icon', 'image/svg+xml', 'image/avif',
            'image/heic', 'image/heif'
        ];
        
        const videoTypes = [
            'video/mp4', 'video/webm', 'video/ogg', 'video/quicktime',
            'video/x-msvideo', 'video/x-matroska', 'video/x-flv',
            'video/x-ms-wmv', 'video/mp4v-es', 'video/mpeg',
            'video/3gpp', 'video/3gpp2'
        ];
        
        const audioTypes = [
            'audio/mpeg', 'audio/wav', 'audio/aac', 'audio/ogg',
            'audio/mp4', 'audio/flac', 'audio/webm', 'audio/x-m4a'
        ];
        
        const allAllowed = [...imageTypes, ...videoTypes, ...audioTypes];
        
        // التحقق من النوع
        if (!allAllowed.includes(file.mimetype)) {
            return cb(new Error(
                'Unsupported file type. Supported formats:\n' +
                '📸 Images: JPEG, PNG, GIF, WEBP, BMP, TIFF, SVG, AVIF, HEIC\n' +
                '🎬 Videos: MP4, WEBM, OGG, MOV, AVI, MKV, FLV, WMV, MPEG, 3GP\n' +
                '🎵 Audio: MP3, WAV, AAC, OGG, M4A, FLAC, WEBM'
            ), false);
        }
        
        // التحقق من الحجم حسب النوع
        let maxSize = 50 * 1024 * 1024; // 50MB افتراضي
        
        if (file.mimetype.startsWith('image/')) {
            maxSize = 20 * 1024 * 1024; // 20MB للصور
        } else if (file.mimetype.startsWith('video/')) {
            maxSize = 50 * 1024 * 1024; // 50MB للفيديوهات
        } else if (file.mimetype.startsWith('audio/')) {
            maxSize = 15 * 1024 * 1024; // 15MB للصوتيات
        }
        
        if (file.size > maxSize) {
            const typeName = file.mimetype.startsWith('image/') ? 'images' : 
                           file.mimetype.startsWith('video/') ? 'videos' : 'audio';
            return cb(new Error(
                `File too large. Maximum ${maxSize / 1024 / 1024}MB for ${typeName}`
            ), false);
        }
        
        cb(null, true);
    }
});

// ============================================
// MIDDLEWARE - معالجة أخطاء رفع الملفات (مطور)
// ============================================
const handleUploadError = (err, req, res, next) => {
    if (err instanceof multer.MulterError) {
        const errorMap = {
            'LIMIT_FILE_SIZE': 'File too large. Maximum size is 50MB.',
            'LIMIT_FILE_COUNT': 'Too many files.',
            'LIMIT_FIELD_KEY': 'Field name too long.',
            'LIMIT_FIELD_VALUE': 'Field value too long.',
            'LIMIT_FIELD_COUNT': 'Too many fields.',
            'LIMIT_PART_COUNT': 'Too many parts.',
            'LIMIT_UNEXPECTED_FILE': 'Unexpected file field.'
        };
        
        return res.status(400).json({ 
            error: errorMap[err.code] || `Upload error: ${err.message}`,
            code: err.code
        });
    }
    
    if (err) {
        return res.status(400).json({ 
            error: err.message || 'File upload failed',
            code: 'FILE_ERROR'
        });
    }
    
    next();
};



// ============================================
// Multer configuration for message attachments (temporary storage)
// ============================================
const messageUpload = multer({
    storage: multer.memoryStorage(),
    limits: { fileSize: 10 * 1024 * 1024 },
    fileFilter: (req, file, cb) => {
        const allowedTypes = [
            'image/jpeg', 'image/png', 'image/gif', 'image/webp',
            'video/mp4', 'video/webm', 'video/ogg',
            'application/pdf',
            'audio/mpeg', 'audio/webm', 'audio/mp4', 'audio/ogg'
        ];
        if (allowedTypes.includes(file.mimetype)) {
            cb(null, true);
        } else {
            cb(new Error('File type not allowed. Allowed: images, videos, PDF, audio'), false);
        }
    }
});


mongoose.connect(process.env.MONGODB_URI)
    .then(() => logger.info('Connected to MongoDB'))
    .catch(err => {
        logger.error(`MongoDB connection error: ${err.message}`, { stack: err.stack });
        Sentry.captureException(err);
        process.exit(1);
    });

const MONGODB_URI = process.env.MONGODB_URI;
const JWT_SECRET = process.env.JWT_SECRET;
const PORT = process.env.PORT || 7860;
const GOOGLE_CLIENT_ID = process.env.GOOGLE_CLIENT_ID;
const GOOGLE_CLIENT_SECRET = process.env.GOOGLE_CLIENT_SECRET;
const FACEBOOK_CLIENT_ID = process.env.FACEBOOK_CLIENT_ID;
const FACEBOOK_CLIENT_SECRET = process.env.FACEBOOK_CLIENT_SECRET;
const GITHUB_CLIENT_ID = process.env.GITHUB_CLIENT_ID;
const GITHUB_CLIENT_SECRET = process.env.GITHUB_CLIENT_SECRET;
const EMAIL_USER = process.env.EMAIL_USER;
const EMAIL_PASS = process.env.EMAIL_PASS;
const HUGGING_FACE_TOKEN = process.env.HUGGING_FACE_TOKEN;
const AI_API_URL = process.env.AI_API_URL;
const FRONTEND_URL = process.env.FRONTEND_URL || 'https://mark-elasfar.web.app';
const FRONTEND_URL_XCV = process.env.FRONTEND_URL_XCV || 'https://xccv.vercel.app';


if (!MONGODB_URI || !JWT_SECRET || !GOOGLE_CLIENT_ID || !GOOGLE_CLIENT_SECRET || !FACEBOOK_CLIENT_ID || !FACEBOOK_CLIENT_SECRET || !GITHUB_CLIENT_ID || !GITHUB_CLIENT_SECRET || !EMAIL_USER || !EMAIL_PASS || !HUGGING_FACE_TOKEN || !process.env.BASE_URL || !FRONTEND_URL || !process.env.CLOUDINARY_CLOUD_NAME || !process.env.CLOUDINARY_API_KEY || !process.env.CLOUDINARY_API_SECRET || !process.env.GITHUB_TOKEN || !process.env.SENTRY_DSN) {
    logger.error('Missing environment variables');
    process.exit(1);
}

webpush.setVapidDetails(
    'mailto:marklasfar@gmail.com',
    process.env.VAPID_PUBLIC_KEY,
    process.env.VAPID_PRIVATE_KEY
);

const WEB_URL = process.env.WEB_URL; 
const BASE_URL = process.env.BASE_URL;



// ✅ استخدام Brevo API بدلاً من nodemailer
const BREVO_API_KEY = process.env.BREVO_API_KEY;

async function sendEmailWithBrevo(to, subject, htmlContent, textContent) {
    try {
        const response = await fetch('https://api.brevo.com/v3/smtp/email', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'api-key': BREVO_API_KEY
            },
            body: JSON.stringify({
                sender: { name: 'MGZon', email: 'amarlasfar0@gmail.com' },
                to: [{ email: to }],
                subject: subject,
                htmlContent: htmlContent,
                textContent: textContent || htmlContent.replace(/<[^>]*>/g, '')
            })
        });
        
        if (!response.ok) {
            const error = await response.json();
            throw new Error(error.message || 'Failed to send email');
        }
        
        const data = await response.json();
        console.log('✅ Email sent via Brevo:', data.messageId);
        return data;
    } catch (error) {
        console.error('❌ Brevo error:', error.message);
        throw error;
    }
}


// ============================================
// 📧 HELPER FUNCTION FOR SENDING EMAILS
// ============================================
async function sendStoreEmailWithBrevo(to, subject, htmlContent, textContent) {
    try {
        const response = await fetch('https://api.brevo.com/v3/smtp/email', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'api-key': process.env.BREVO_API_KEY
            },
            body: JSON.stringify({
                sender: { 
                    name: 'MGZon Store', 
                    email: process.env.EMAIL_USER || 'no-reply@mgzon.com' 
                },
                to: [{ email: to }],
                subject: subject,
                htmlContent: htmlContent,
                textContent: textContent || htmlContent.replace(/<[^>]*>/g, '')
            })
        });
        
        if (!response.ok) {
            const error = await response.json();
            console.error('Brevo error:', error);
            throw new Error(error.message || 'Failed to send email');
        }
        
        const data = await response.json();
        console.log(`✅ Email sent to ${to}: ${data.messageId}`);
        return data;
        
    } catch (error) {
        console.error('❌ Failed to send email:', error.message);
        // لا نرمي الخطأ عشان العملية تكمل
        return null;
    }
}



// ============================================
// Helper: إرسال إشعارات عند الدفع
// ============================================
async function sendOrderPaidNotifications(orderId, req) {
    try {
        const order = await Order.findById(orderId)
            .populate('buyerId')
            .populate('sellerId');
        if (!order) return;
        
        const storeSettings = await StoreSettings.findOne({ userId: order.sellerId._id });
        const currencySymbol = storeSettings?.currencySymbol || '$';
        
        // 📧 إشعار للمشتري
        await sendStoreEmailWithBrevo(
            order.buyerId.email,
            `✅ Payment Confirmed - Order #${order.orderNumber}`,
            `
            <h2>Payment Confirmed! 🎉</h2>
            <p>Your order #${order.orderNumber} has been paid successfully.</p>
            <p><strong>Amount:</strong> ${currencySymbol}${order.totalAmount}</p>
            <p>The seller will process your order shortly.</p>
            <a href="${FRONTEND_URL}/store/orders/${order._id}">View Order</a>
            `,
            `Payment confirmed for order #${order.orderNumber}`
        );
        
        // 📧 إشعار للبائع
        await sendStoreEmailWithBrevo(
            order.sellerId.email,
            `💰 Payment Received - Order #${order.orderNumber}`,
            `
            <h2>Payment Received! 🎉</h2>
            <p>Order #${order.orderNumber} has been paid by ${order.buyerId.profile?.nickname || order.buyerId.username}.</p>
            <p><strong>Amount:</strong> ${currencySymbol}${order.totalAmount}</p>
            <p><strong>Items:</strong> ${order.items.length} product(s)</p>
            <a href="${FRONTEND_URL}/store/orders/${order._id}">Process Order</a>
            `,
            `Payment received for order #${order.orderNumber}`
        );
        
        // 📱 إشعار Socket.IO
        const io = req.app?.get('io');
        if (io) {
            io.to(`user_${order.sellerId._id}`).emit('payment_received', {
                orderId: order._id,
                orderNumber: order.orderNumber,
                buyerName: order.buyerId.profile?.nickname || order.buyerId.username,
                amount: order.totalAmount,
                currencySymbol: currencySymbol
            });
            
            io.to(`user_${order.buyerId._id}`).emit('payment_confirmed', {
                orderId: order._id,
                orderNumber: order.orderNumber,
                amount: order.totalAmount,
                currencySymbol: currencySymbol
            });
        }
        
        console.log(`✅ Notifications sent for order #${order.orderNumber}`);
        
    } catch (error) {
        console.error('❌ Error sending notifications:', error);
    }
}


app.get('/api/test-email-config', async (req, res) => {
    try {
        // اختبار الاتصال فقط
        await transporter.verify();
        res.json({ success: true, message: 'SMTP connection successful!' });
    } catch (error) {
        console.error('SMTP Error:', error);
        res.json({ success: false, error: error.message });
    }
});
// mongoose.connect(MONGODB_URI)
//     .then(() => logger.info('Connected to MongoDB'))
//     .catch(err => logger.error('MongoDB connection error:', err));


// ============================================
// نموذج إعدادات الموقع (Site Settings)
// ============================================
const siteSettingsSchema = new mongoose.Schema({
    logo: { type: String, default: '/assets/img/logo.svg' },
    siteName: { type: String, default: 'MGZon' },
    primaryColor: { type: String, default: '#1d4ed8' },
    secondaryColor: { type: String, default: '#8b5cf6' },
    navbarLinks: [{
        label: { type: String, required: true },
        href: { type: String, required: true },
        order: { type: Number, default: 0 }
    }],
    footerText: { type: String, default: '© MGZon. All rights reserved' },
    updatedAt: { type: Date, default: Date.now }
});

const SiteSettings = mongoose.model('SiteSettings', siteSettingsSchema);


const projectSchema = new mongoose.Schema({
    title: { type: String, required: true },
    description: { type: String, required: true },
    image: { type: String },
    rating: { type: String },
    stars: { type: Number },
    links: [{ 
        option: String, 
        value: String, 
        isPrivate: { type: Boolean, default: false } 
    }],
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    isPublic: { type: Boolean, default: true },
    
    // ✅ دعم GitHub import
    githubData: { type: mongoose.Schema.Types.Mixed, default: null },
    importedFrom: { type: String, enum: ['github', 'gitlab', 'manual', null], default: null },
    githubId: { type: String, sparse: true, index: true },
    
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

// تحديث updatedAt تلقائياً
projectSchema.pre('save', function(next) {
    this.updatedAt = Date.now();
    next();
});

const Project = mongoose.model('Project', projectSchema);

const commentSchema = new mongoose.Schema({
    projectId: { type: mongoose.Schema.Types.ObjectId, ref: 'Project', required: true }, // ✅ تغيير من Mixed إلى ObjectId
    projectOwnerId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true }, // ✅ صاحب المشروع
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    rating: { type: Number, required: true, min: 1, max: 5 },
    text: { type: String, required: true },
    timestamp: { type: Date, default: Date.now },
    likes: [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }],
    parentCommentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Comment', default: null },
    replies: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Comment' }],
    isEdited: { type: Boolean, default: false },
    editedAt: { type: Date },
    reportCount: { type: Number, default: 0 },
    hidden: { type: Boolean, default: false },
    visibility: { type: String, enum: ['public', 'logged-in', 'only-me'], default: 'public' },
    notified: { type: Boolean, default: false },
    reports: [{
        userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        reporterUsername: { type: String },
        reason: { type: String },
        reportedAt: { type: Date, default: Date.now },
        resolved: { type: Boolean, default: false },
        resolvedAt: { type: Date },
        resolvedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        adminNote: { type: String }
    }]
});
const Comment = mongoose.model('Comment', commentSchema);


// ============================================
// Message Report Schema - تقارير الرسائل المخالفة
// ============================================
const messageReportSchema = new mongoose.Schema({
    messageId: { type: mongoose.Schema.Types.ObjectId, ref: 'Message', required: true },
    reporterId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    reporterUsername: { type: String },
    reportedUserId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    reason: { type: String, required: true },
    messageContent: { type: String },
    messageAttachments: [{ type: mongoose.Schema.Types.Mixed }],
    conversationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Conversation' },
    status: { type: String, enum: ['pending', 'resolved', 'dismissed'], default: 'pending' },
    resolution: { type: String, enum: ['dismiss', 'warn', 'delete', 'hide', null], default: null },
    adminNote: { type: String },
    resolvedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
    resolvedAt: { type: Date },
    reportedAt: { type: Date, default: Date.now }
});

messageReportSchema.index({ messageId: 1 });
messageReportSchema.index({ reporterId: 1 });
messageReportSchema.index({ status: 1 });
messageReportSchema.index({ reportedAt: -1 });

const MessageReport = mongoose.model('MessageReport', messageReportSchema);


const postSchema = new mongoose.Schema({
    userId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    },
    content: {
        type: String,
        required: true,
        maxlength: 5000
    },
    images: [{
        url: String,
        publicId: String,
        width: Number,
        height: Number
    }],
    video: {
        url: String,
        publicId: String,
        duration: Number
    },
    likes: [{
        userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        likedAt: { type: Date, default: Date.now }
    }],
    comments: [{
        userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        text: String,
        createdAt: { type: Date, default: Date.now },
        likes: [{
            userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
            likedAt: { type: Date, default: Date.now }
         }],
        edited: { type: Boolean, default: false },
        editedAt: Date,

        reports: [{
            userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
            reason: { type: String, default: 'No reason provided' },
            reportedAt: { type: Date, default: Date.now }
        }],
        reportCount: { type: Number, default: 0 },
        hidden: { type: Boolean, default: false },
      replies: [{
               userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
               text: String,
               createdAt: { type: Date, default: Date.now },
               likes: [{
                  userId: {
                     type: mongoose.Schema.Types.ObjectId,
                     ref: 'User'
                  },
                  likedAt: {
                     type: Date,
                     default: Date.now
                  }
               }],
               edited: { type: Boolean, default: false },
               editedAt: Date,
               reports: [{
                  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
                  reason: { type: String, default: 'No reason provided' },
                  reportedAt: { type: Date, default: Date.now }
               }],
               reportCount: { type: Number, default: 0 },
               hidden: { type: Boolean, default: false },
               
               // ✅ ✅ ✅ المفتاح: الردود تحت الردود (Self-Referencing)
               replies: { 
                  type: Array, 
                  default: [] 
               }
      }]


    }],
    shares: [{
        userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        sharedAt: { type: Date, default: Date.now }
    }],
    saves: [{
        userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        savedAt: { type: Date, default: Date.now }
    }],
    visibility: {
        type: String,
        enum: ['public', 'followers', 'only-me'],
        default: 'public'
    },
    tags: [String],
    mentions: [{
        userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        username: String,
        position: Number
    }],

    sharedFrom: {
        originalPostId: { type: mongoose.Schema.Types.ObjectId, ref: 'Post' },
        originalAuthorId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        originalAuthorName: { type: String },
        sharedAt: { type: Date, default: Date.now }
    },
    pinned: { type: Boolean, default: false },
    pinnedAt: Date,
    isEdited: { type: Boolean, default: false },
    editedAt: Date,
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});


// Indexes for performance
postSchema.index({ userId: 1, createdAt: -1 });
postSchema.index({ createdAt: -1 });
postSchema.index({ tags: 1 });
postSchema.index({ 'mentions.userId': 1 });

postSchema.pre('save', function(next) {
    this.updatedAt = Date.now();
    next();
});

const Post = mongoose.model('Post', postSchema);



const jobSchema = new mongoose.Schema({
    // صاحب الوظيفة (اللي منشئها)
    employerId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    },
    
    title: {
        type: String,
        required: true,
        trim: true
    },
    description: {
        type: String,
        required: true
    },
    requirements: {
        type: String,
        required: true
    },
    responsibilities: {
        type: String
    },
    
    // تفاصيل الوظيفة
    category: {
        type: String,
        enum: ['technology', 'design', 'marketing', 'sales', 'customer-service', 'finance', 'hr', 'education', 'healthcare', 'other'],
        required: true
    },
    jobType: {
        type: String,
        enum: ['full-time', 'part-time', 'contract', 'freelance', 'internship', 'remote'],
        required: true
    },
    experienceLevel: {
        type: String,
        enum: ['entry', 'junior', 'mid', 'senior', 'lead', 'executive'],
        required: true
    },
    
    // الموقع
    location: {
        type: String,
        required: true
    },
    isRemote: {
        type: Boolean,
        default: false
    },
    
    // الراتب
    salaryMin: {
        type: Number
    },
    salaryMax: {
        type: Number
    },
    salaryCurrency: {
        type: String,
        default: 'USD'
    },
    isSalaryNegotiable: {
        type: Boolean,
        default: false
    },
    
    // مهارات مطلوبة
    requiredSkills: [{
        type: String,
        trim: true
    }],
    
    // التعليم
    educationLevel: {
        type: String,
        enum: ['high-school', 'associate', 'bachelor', 'master', 'phd', 'not-specified'],
        default: 'not-specified'
    },
    
    // عدد الوظائف المتاحة
    vacancies: {
        type: Number,
        default: 1
    },
    
    // تاريخ النشر والانتهاء
    postedAt: {
        type: Date,
        default: Date.now
    },
    deadline: {
        type: Date,
        required: true
    },
    
    // حالة الوظيفة
    status: {
        type: String,
        enum: ['active', 'paused', 'closed', 'expired'],
        default: 'active'
    },
    
    // عدد المشاهدات والمتقدمين
    views: {
        type: Number,
        default: 0
    },
    applicationsCount: {
        type: Number,
        default: 0
    },
    
    // هل الوظيفة مدفوعة (للإعلانات المميزة)
    isFeatured: {
        type: Boolean,
        default: false
    },
    featuredUntil: {
        type: Date
    },
    
    // Company info (if employer is a company)
    companyName: {
        type: String
    },
    companyLogo: {
        type: String
    },
    companyWebsite: {
        type: String
    },
    
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

// Indexes for better performance
jobSchema.index({ title: 'text', description: 'text', requirements: 'text' });
jobSchema.index({ category: 1, jobType: 1, experienceLevel: 1 });
jobSchema.index({ location: 1 });
jobSchema.index({ status: 1, deadline: 1 });
jobSchema.index({ employerId: 1 });
jobSchema.index({ isFeatured: 1, featuredUntil: 1 });

jobSchema.pre('save', function(next) {
    this.updatedAt = Date.now();
    next();
});

const Job = mongoose.model('Job', jobSchema);

const jobApplicationSchema = new mongoose.Schema({
    jobId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'Job',
        required: true
    },
    applicantId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    },
    
    // بيانات المتقدم
    fullName: {
        type: String,
        required: true
    },
    email: {
        type: String,
        required: true
    },
    phone: {
        type: String
    },
    
    // الملفات المرفقة
    resume: {
        url: String,
        publicId: String,
        fileName: String
    },
    coverLetter: {
        type: String
    },
    portfolio: {
        type: String
    },
    linkedin: {
        type: String
    },
    github: {
        type: String
    },
    
    // أسئلة إضافية
    answers: [{
        question: String,
        answer: String
    }],
    
    // حالة التقديم
    status: {
        type: String,
        enum: ['pending', 'reviewed', 'shortlisted', 'interview', 'accepted', 'rejected', 'withdrawn'],
        default: 'pending'
    },
    
    // ملاحظات صاحب الوظيفة
    employerNotes: {
        type: String
    },
    rating: {
        type: Number,
        min: 1,
        max: 5
    },
    
    // مراحل المقابلة
    interviews: [{
        scheduledAt: Date,
        type: { type: String, enum: ['phone', 'video', 'onsite', 'technical'] },
        meetingLink: String,
        notes: String,
        status: { type: String, enum: ['scheduled', 'completed', 'cancelled', 'no-show'], default: 'scheduled' }
    }],
    
    appliedAt: {
        type: Date,
        default: Date.now
    },
    updatedAt: {
        type: Date,
        default: Date.now
    }
});

// منع التقديم المتكرر لنفس الوظيفة
jobApplicationSchema.index({ jobId: 1, applicantId: 1 }, { unique: true });
jobApplicationSchema.index({ jobId: 1, status: 1 });
jobApplicationSchema.index({ applicantId: 1 });

jobApplicationSchema.pre('save', function(next) {
    this.updatedAt = Date.now();
    next();
});

const JobApplication = mongoose.model('JobApplication', jobApplicationSchema);

const jobSaveSchema = new mongoose.Schema({
    jobId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'Job',
        required: true
    },
    userId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    },
    savedAt: {
        type: Date,
        default: Date.now
    }
});

jobSaveSchema.index({ jobId: 1, userId: 1 }, { unique: true });

const JobSave = mongoose.model('JobSave', jobSaveSchema);

const jobCategorySchema = new mongoose.Schema({
    name: {
        type: String,
        required: true,
        unique: true
    },
    nameAr: String,
    icon: String,
    color: String,
    order: { type: Number, default: 0 },
    isActive: { type: Boolean, default: true }
});

const JobCategory = mongoose.model('JobCategory', jobCategorySchema);

const storySchema = new mongoose.Schema({
    userId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true,
        index: true
    },
    media: {
        url: { type: String, default: null },
        publicId: { type: String, default: null },
        type: { 
            type: String, 
            enum: ['image', 'video', 'audio', 'none'], 
            default: 'none' 
        }
    },

    filter: {
        type: String,
        default: 'none',
        enum: ['none', 'vintage', 'noir', 'cool', 'warm', 'dramatic', 
               'dreamy', 'vivid', 'fade', 'sepia', 'grayscale', 'blur',
               'grain', 'vignette', 'neon', 'retro', 'cinematic', 'pastel']
    },
    // ✅ حقل جديد لضبط قوة الفلتر
    filterIntensity: {
        type: Number,
        default: 0.5,
        min: 0,
        max: 1
    },
    text: { 
        type: String, 
        maxlength: 2000,
        default: ''
    },
    backgroundColor: { 
        type: String, 
        default: '#000000' 
    },
    textColor: { 
        type: String, 
        default: '#ffffff' 
    },
        allowDownload: {
        type: Boolean,
        default: false
    },

    audio: {
        url: { type: String, default: null },
        publicId: { type: String, default: null },
        duration: { type: Number, default: 0 },  // مدة التسجيل بالثواني
        waveform: { type: Array, default: [] }   // شكل الموجة للتسجيل
    },
    // ✅ حقل جديد لدعم الفلاتر
    filterApplied: {
        type: Boolean,
        default: false
    },


    textStyle: {
        fontSize: { type: Number, default: 32 },     // حجم الخط
        fontFamily: { type: String, default: 'Inter' }, // نوع الخط
        fontWeight: { type: String, default: '700' },  // سمك الخط
        textAlign: { type: String, default: 'center' }, // محاذاة النص
        position: {                                    // موضع النص
            x: { type: Number, default: 50 },          // % من العرض (50 = منتصف)
            y: { type: Number, default: 50 }           // % من الارتفاع (50 = منتصف)
        },
        rotation: { type: Number, default: 0 },        // دوران النص
        opacity: { type: Number, default: 1 },         // شفافية النص
        textShadow: { type: String, default: '0 2px 10px rgba(0,0,0,0.5)' },
        background: { type: String, default: 'transparent' }, // خلفية النص
        padding: { type: String, default: '0' },
        borderRadius: { type: String, default: '0' },
        maxWidth: { type: Number, default: 90 }        // % من عرض القصة
    },
    views: [{
        userId: { 
            type: mongoose.Schema.Types.ObjectId, 
            ref: 'User' 
        },
        viewedAt: { 
            type: Date, 
            default: Date.now 
        }
    }],
    reactions: [{
        userId: { 
            type: mongoose.Schema.Types.ObjectId, 
            ref: 'User' 
        },
        type: { 
            type: String, 
            enum: ['❤️', '😂', '😮', '😢', '😡'], 
            default: '❤️' 
        },
        createdAt: { 
            type: Date, 
            default: Date.now 
        }
    }],
    quickReactions: {
        likes: { type: Number, default: 0 },
        hearts: { type: Number, default: 0 },
        laughs: { type: Number, default: 0 },
        wows: { type: Number, default: 0 },
        sads: { type: Number, default: 0 },
        angrys: { type: Number, default: 0 }
    },
    visibility: {
        type: String,
        enum: ['public', 'followers', 'only-me'],
        default: 'followers'
    },
    replies: [{
        userId: { 
            type: mongoose.Schema.Types.ObjectId, 
            ref: 'User' 
        },
        text: { type: String, maxlength: 200 },
        createdAt: { type: Date, default: Date.now }
    }],
    // ✅ حقل جديد: لمنع تكرار إرسال الإشعارات
    notificationSent: { 
        type: Boolean, 
        default: false 
    },
    createdAt: { 
        type: Date, 
        default: Date.now,
        index: true
    },
    expiresAt: { 
        type: Date, 
        default: () => new Date(Date.now() + 24 * 60 * 60 * 1000)
    }
});

// فهارس محسّنة
storySchema.index({ userId: 1, createdAt: -1 });
storySchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
storySchema.index({ 'audio.url': 1 });
storySchema.index({ filter: 1 });


// فيريتول (Virtual) لحساب عدد المشاهدات
storySchema.virtual('viewsCount').get(function() {
    return this.views?.length || 0;
});

// فيريتول لحساب عدد التفاعلات
storySchema.virtual('reactionsCount').get(function() {
    return this.reactions?.length || 0;
});

// طريقة للتحقق مما إذا كانت القصة منتهية
storySchema.methods.isExpired = function() {
    return new Date() > this.expiresAt;
};

// طريقة للتحقق مما إذا كان المستخدم قد شاهد القصة
storySchema.methods.hasViewed = function(userId) {
    return this.views?.some(v => v.userId.toString() === userId.toString());
};

const Story = mongoose.model('Story', storySchema);

const reportSchema = new mongoose.Schema({
    reporterId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true,
        index: true
    },
    targetType: {
        type: String,
        enum: ['post', 'comment', 'user', 'profile'],
        required: true,
        index: true
    },
    targetId: {
        type: mongoose.Schema.Types.ObjectId,
        required: true,
        index: true
    },
    reason: {
        type: String,
        enum: ['spam', 'harassment', 'hate_speech', 'violence', 'nudity', 'misinformation', 'other'],
        required: true
    },
    details: {
        type: String,
        maxLength: 500,
        default: ''
    },
    status: {
        type: String,
        enum: ['pending', 'reviewed', 'resolved', 'dismissed'],
        default: 'pending',
        index: true
    },
    adminNotes: {
        type: String,
        maxLength: 1000,
        default: ''
    },
    resolvedBy: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User'
    },
    resolvedAt: {
        type: Date
    }
}, {
    timestamps: true
});

// Indexes for faster queries
reportSchema.index({ targetType: 1, targetId: 1, status: 1 });
reportSchema.index({ reporterId: 1, createdAt: -1 });

// Check if user already reported this content
reportSchema.statics.hasUserReported = async function(userId, targetType, targetId) {
    const existing = await this.findOne({
        reporterId: userId,
        targetType,
        targetId,
        status: { $in: ['pending', 'reviewed'] }
    });
    return !!existing;
};

// Get report count for a target
reportSchema.statics.getReportCount = async function(targetType, targetId) {
    return await this.countDocuments({
        targetType,
        targetId,
        status: 'pending'
    });
};

const Report = mongoose.model('Report', reportSchema);


const notificationSchema = new mongoose.Schema({
    userId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    },
    type: {
        type: String,
        enum: [
            'like', 'comment', 'share', 'follow', 'mention','report',
            'report_resolved', 'post_approved', 'system', 'message', 
            'reply', 'admin_report', 'admin_info', 'warning', 'rating', 
            'application', 'new_order', 'order_status_update', 'product_sold', 
            'store_follow',
            'subscription_expiring',    // قبل انتهاء الاشتراك بـ 7,3,1 يوم
            'subscription_expired',     // بعد ما ينتهي الاشتراك
            'subscription_approved',    // لما المسؤول يوافق على الاشتراك
            'subscription_rejected',    // لما المسؤول يرفض الاشتراك
            'subscription_pending',     // اشتراك جديد في انتظار الموافقة
            'subscription_cancelled'    // لما المستخدم يلغي الاشتراك
        ],
        required: true
    },
    actorId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User'
    },
    actorName: String,
    actorAvatar: String,
    targetId: { type: String },
    targetType: { type: String },
    content: String,
    read: { type: Boolean, default: false },
    createdAt: { type: Date, default: Date.now }
});

notificationSchema.index({ userId: 1, createdAt: -1 });
notificationSchema.index({ userId: 1, read: 1 });
notificationSchema.index({ type: 1, createdAt: -1 });

const Notification = mongoose.model('Notification', notificationSchema);

const followSchema = new mongoose.Schema({
    followerId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    },
    followingId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    },
    status: {
        type: String,
        enum: ['pending', 'accepted', 'blocked'],
        default: 'accepted'
    },
    createdAt: { type: Date, default: Date.now }
});

// Unique compound index
followSchema.index({ followerId: 1, followingId: 1 }, { unique: true });
followSchema.index({ followingId: 1, createdAt: -1 });

const Follow = mongoose.model('Follow', followSchema);


// ============================================
// 🛒 DIGITAL STORE MODELS
// ============================================

// 1. نموذج المنتج (Product)
const productSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    type: { type: String, enum: ['digital', 'project', 'service'], required: true },
    title: { type: String, required: true },
    description: { type: String, required: true },
    price: { type: Number, required: true, min: 0 },
    currency: { type: String, default: 'USD' },
    
    // Digital Product Fields (ملفات للتحميل)
    fileUrl: { type: String },
    fileSize: { type: Number },
    
    // Service Fields (خدمات)
    deliveryTime: { type: String }, // مثلاً "3-5 business days"
    
    // Common Fields
    images: [{ type: String }],
    tags: [String],
    isActive: { type: Boolean, default: true },
    salesCount: { type: Number, default: 0 },
    averageRating: { type: Number, default: 0 },
    reviews: [{
        userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        rating: { type: Number, min: 1, max: 5 },
        comment: { type: String, maxlength: 500 },
        createdAt: { type: Date, default: Date.now }
    }],
    
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

// Indexes for better performance
productSchema.index({ userId: 1, type: 1, isActive: 1 });
productSchema.index({ userId: 1, createdAt: -1 });
productSchema.index({ tags: 1 });

const Product = mongoose.model('Product', productSchema);

// 2. نموذج الطلب (Order)
const orderSchema = new mongoose.Schema({
    orderNumber: { type: String, unique: true },
    buyerId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    sellerId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    items: [{
        productId: { type: mongoose.Schema.Types.ObjectId, ref: 'Product' },
        productType: { type: String },
        title: { type: String },
        quantity: { type: Number, default: 1 },
        price: { type: Number },
        fileUrl: { type: String },
        downloadCount: { type: Number, default: 0 } 
    }],

    trackingNumber: { type: String }, // للشحن
    cancelledAt: { type: Date },
    cancellationReason: { type: String },
    downloadableFiles: [{
        fileName: String,
        fileUrl: String,
        expiresAt: Date,
        downloadCount: { type: Number, default: 0 }
    }],
    subtotal: { type: Number, required: true },
    totalAmount: { type: Number, required: true },
    currency: { type: String, default: 'USD' },
    status: { 
        type: String, 
        enum: ['pending', 'paid', 'processing', 'completed', 'cancelled', 'refunded'],
        default: 'pending'
    },
    paymentMethod: { type: String }, // paypal, stripe, vodafone, instapay, bank
    paymentDetails: { type: mongoose.Schema.Types.Mixed },
    buyerNotes: { type: String, maxlength: 500 },
    sellerNotes: { type: String, maxlength: 500 },
    deliveredAt: { type: Date },
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

// Generate unique order number before saving
orderSchema.pre('save', async function(next) {
    if (!this.orderNumber) {
        const date = new Date();
        const timestamp = date.getTime().toString().slice(-8);
        const random = Math.floor(Math.random() * 1000).toString().padStart(3, '0');
        this.orderNumber = `ORD-${timestamp}-${random}`;
    }
    next();
});


orderSchema.index({ status: 1 });

const Order = mongoose.model('Order', orderSchema);

// 3. نموذج إعدادات المتجر (Store Settings)
/**
 * نموذج إعدادات المتجر - يدعم القوالب، الاشتراكات، الإحصائيات المتقدمة
 * @version 3.0.0
 */

const storeSettingsSchema = new mongoose.Schema({
    // ============================================
    // المعلومات الأساسية
    // ============================================
    userId: { 
        type: mongoose.Schema.Types.ObjectId, 
        ref: 'User', 
        required: true, 
        unique: true,
        index: true
    },
    enabled: { 
        type: Boolean, 
        default: false
    },
    
    // ============================================
    // معلومات المتجر العامة
    // ============================================
    storeName: { type: String, default: '', trim: true, maxlength: 100 },
    storeLogo: { type: String, default: '' },
    storeBanner: { type: String, default: '' },
    storeDescription: { type: String, default: '', maxlength: 500 },
    contactEmail: { type: String, default: '', lowercase: true, trim: true },
    
    // ============================================
    // العملة والإعدادات المالية
    // ============================================
    currency: { type: String, default: 'USD', uppercase: true },
    currencySymbol: { type: String, default: '$' },
    
    // إعدادات الدفع المتقدمة
    paymentSettings: {
        currencyPosition: { type: String, enum: ['left', 'right'], default: 'left' },
        decimalPlaces: { type: Number, default: 2, min: 0, max: 4 },
        thousandsSeparator: { type: String, default: ',' },
        decimalSeparator: { type: String, default: '.' },
        enableCOD: { type: Boolean, default: false },
        enableInstallments: { type: Boolean, default: false },
        installmentProviders: [{ type: String }],
        minOrderAmount: { type: Number, default: 0 },
        freeShippingThreshold: { type: Number, default: 0 },
        taxRate: { type: Number, default: 0, min: 0, max: 100 },
        shippingCost: { type: Number, default: 0 }
    },
    
    // طرق الدفع
    paymentMethods: [{
        type: { 
            type: String, 
            enum: ['paypal', 'stripe', 'vodafone', 'instapay', 'bank', 'cod'] 
        },
        label: { type: String },
        details: {
            // 📱 للدفع المباشر
            phone: { type: String },        // Vodafone/InstaPay
            email: { type: String },        // PayPal
            
            // 🏦 للتحويل البنكي
            bankName: { type: String },
            accountName: { type: String },
            accountNumber: { type: String },
            iban: { type: String },
            
            // 💳 لـ Stripe
            accountId: { type: String },
            webhookSecret: { type: String }, // ⭐ whsec_xxx (مهم جداً!)
            publishableKey: { type: String },
            secretKey: { type: String },
            
            // 💰 لـ PayPal
            webhookId: { type: String },
            clientId: { type: String },
            clientSecret: { type: String }
        },
        isActive: { type: Boolean, default: true },
        createdAt: { type: Date, default: Date.now }
    }],
    
    // ============================================
    // 🎨 إعدادات التصميم (Theme)
    // ============================================
    activeThemeId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'StoreTheme',
        default: null
    },
    
    // الألوان الأساسية
    primaryColor: { type: String, default: '#3b82f6', match: /^#[0-9A-Fa-f]{6}$/ },
    secondaryColor: { type: String, default: '#8b5cf6', match: /^#[0-9A-Fa-f]{6}$/ },
    
    // الألوان الموسعة
    colorPalette: {
        primaryHover: { type: String, default: '#2563eb' },
        secondaryHover: { type: String, default: '#7c3aed' },
        buttonText: { type: String, default: '#ffffff' },
        linkColor: { type: String, default: '#3b82f6' },
        linkHover: { type: String, default: '#2563eb' },
        headingColor: { type: String, default: '#1f2937' },
        bodyColor: { type: String, default: '#374151' },
        borderColor: { type: String, default: '#e5e7eb' },
        successColor: { type: String, default: '#10b981' },
        errorColor: { type: String, default: '#ef4444' },
        warningColor: { type: String, default: '#f59e0b' }
    },
    
    // الخطوط
    fontFamily: { type: String, default: 'Inter, sans-serif' },
    typography: {
        headingFont: { type: String, default: 'Inter, sans-serif' },
        baseFontSize: { type: String, default: '16px', match: /^\d+(px|rem)$/ },
        enableGoogleFonts: { type: Boolean, default: true }
    },
    
    // التخطيط
    borderRadius: { type: Number, default: 16, min: 0, max: 48 },
    shadowType: { type: String, enum: ['none', 'sm', 'md', 'lg', 'xl'], default: 'md' },
    animationType: { type: String, enum: ['none', 'lift', 'scale', 'glow'], default: 'lift' },
    glassEffect: { type: Boolean, default: false },
    
    // الخلفية
    backgroundType: { 
        type: String, 
        enum: ['default', 'dots', 'grid', 'cross', 'gradient', 'image'], 
        default: 'default' 
    },
    backgroundValue: { type: String, default: '' },
    
    // ============================================
    // 🖼️ BACKGROUNDS & GALLERY
    // ============================================

    // الخلفيات المخصصة التي رفعها المستخدم
    customBackgrounds: [{
        id: { type: String, required: true },
        name: { type: String, default: 'Custom Background' },
        url: { type: String, required: true },
        category: { type: String, default: 'custom' },
        type: { type: String, enum: ['image', 'gif', 'gradient'], default: 'image' },
        uploadedAt: { type: Date, default: Date.now },
        isActive: { type: Boolean, default: true }
    }],

    // سجل الخلفيات التي طبقها المستخدم
    backgroundHistory: [{
        url: { type: String, required: true },
        name: { type: String },
        appliedAt: { type: Date, default: Date.now },
        duration: { type: Number, default: 0 } // المدة التي استخدمت فيها (بالأيام)
    }],

    // الخلفية الحالية
    currentBackground: {
        url: { type: String, default: '' },
        name: { type: String, default: '' },
        type: { type: String, enum: ['image', 'gif', 'gradient'], default: 'image' },
        appliedAt: { type: Date, default: Date.now }
    },
    // CSS مخصص
    customCss: { type: String, default: '', maxlength: 100000 },
    
    // إعدادات التخطيط المتقدمة
    layoutSettings: {
        // الأساسية
        headerLayout: { type: String, enum: ['default', 'centered', 'minimal', 'transparent'], default: 'default' },
        footerLayout: { type: String, enum: ['default', 'minimal', 'columns'], default: 'default' },
        sidebarPosition: { type: String, enum: ['left', 'right', 'none'], default: 'none' },
        productsPerRowMobile: { type: Number, default: 2, min: 1, max: 2 },
        productsPerRowTablet: { type: Number, default: 3, min: 1, max: 4 },
        productsPerRowDesktop: { type: Number, default: 4, min: 1, max: 6 },
        enableStickyAddToCart: { type: Boolean, default: true },
        enableQuickView: { type: Boolean, default: true },
        enableCompareProducts: { type: Boolean, default: false },
        enableWishlist: { type: Boolean, default: false },
        enableRecentlyViewed: { type: Boolean, default: true },
        enableProductReviews: { type: Boolean, default: true },
        
        // قالب التخطيط (محدث)
        layoutTemplate: { 
            type: String, 
            enum: ['default', 'sidebar-left', 'sidebar-right', 'product-focused', 'minimal', 'magazine', 'compact', 'dark-store'], 
            default: 'default' 
        },
        
        // أنماط البطاقات و Hero
        cardStyle: { type: String, enum: ['default', 'compact', 'minimal', 'detailed'], default: 'default' },
        heroStyle: { type: String, enum: ['default', 'large', 'fullscreen', 'minimal', 'none'], default: 'default' },
        
        // إظهار/إخفاء الأقسام
        showStats: { type: Boolean, default: true },
        showAnalytics: { type: Boolean, default: true },
        showHero: { type: Boolean, default: true },
        showFeatured: { type: Boolean, default: true },
        showCategories: { type: Boolean, default: true },
        
        // الثيم ونمط العرض
        theme: { type: String, enum: ['light', 'dark', 'auto'], default: 'light' },
        productViewType: { type: String, enum: ['grid', 'list', 'masonry'], default: 'grid' },
        
        // إعدادات الـ compact layout
        compactMode: {
            enabled: { type: Boolean, default: false },
            hidePrices: { type: Boolean, default: false },
            hideRatings: { type: Boolean, default: false },
            hideDescription: { type: Boolean, default: false },
            showQuickAdd: { type: Boolean, default: true }
        },
        
        // إعدادات الـ magazine layout
        magazineMode: {
            showHeroSlider: { type: Boolean, default: true },
            heroSlidesCount: { type: Number, default: 3, min: 1, max: 5 },
            showFeaturedGrid: { type: Boolean, default: true },
            showLatestPosts: { type: Boolean, default: true },
            postsCount: { type: Number, default: 3, min: 1, max: 6 }
        },
        
        // إعدادات الـ dark store
        darkStoreMode: {
            neonAccents: { type: Boolean, default: true },
            accentColor: { type: String, default: '#00d4ff', match: /^#[0-9A-Fa-f]{6}$/ },
            glowEffect: { type: Boolean, default: true },
            blurEffect: { type: Boolean, default: true }
        },
        
        // ترتيب الأقسام المخصص
        sectionsOrder: [{ type: String }],
        
        // إعدادات متقدمة
        advanced: {
            containerMaxWidth: { type: String, default: '1400px' },
            enableParallax: { type: Boolean, default: false },
            enableParticles: { type: Boolean, default: false },
            customBackgroundImage: { type: String, default: '' }
        }
    },
    // ============================================
    // سلوك المنتجات
    // ============================================
    productViewType: { type: String, enum: ['modal', 'page'], default: 'modal' },
    autoApproveReviews: { type: Boolean, default: false },
    
    // ============================================
    // Page Builder
    // ============================================
    pageBuilder: {
        type: mongoose.Schema.Types.Mixed,
        default: {
            sections: [
                { id: 'hero', type: 'hero', enabled: true, order: 1, content: { title: 'Welcome to my store', subtitle: '', buttonText: 'Shop Now', buttonLink: '#products' } },
                { id: 'featured', type: 'featured', enabled: true, order: 2, title: 'Featured Products', limit: 6 },
                { id: 'products', type: 'products', enabled: true, order: 3, title: 'All Products', layout: 'grid' },
                { id: 'categories', type: 'categories', enabled: true, order: 4, title: 'Categories' },
                { id: 'testimonials', type: 'testimonials', enabled: true, order: 5, title: 'What Customers Say' },
                { id: 'faq', type: 'faq', enabled: true, order: 6, title: 'Frequently Asked Questions' },
                { id: 'contact', type: 'contact', enabled: true, order: 7, title: 'Contact Me' }
            ]
        }
    },
    
    pagesOrder: {
        type: mongoose.Schema.Types.Mixed,
        default: {
            products: 1,
            about: 2,
            contact: 3
        }
    },
    
    // ============================================
    // التواصل الاجتماعي
    // ============================================
    socialLinks: {
        instagram: { type: String, default: '' },
        facebook: { type: String, default: '' },
        twitter: { type: String, default: '' },
        tiktok: { type: String, default: '' },
        linkedin: { type: String, default: '' },
        youtube: { type: String, default: '' },
        whatsapp: { type: String, default: '' },
        telegram: { type: String, default: '' }
    },
    
    // ============================================
    // SEO والإحصائيات
    // ============================================
    seoSettings: {
        metaTitleTemplate: { type: String, default: '{{title}} | {{storeName}}' },
        metaDescriptionTemplate: { type: String, default: '' },
        productTitleTemplate: { type: String, default: '{{title}} - {{storeName}}' },
        enableBreadcrumbs: { type: Boolean, default: true },
        sitemapEnabled: { type: Boolean, default: true },
        robotsTxt: { type: String, default: '' },
        canonicalUrl: { type: String, default: '' }
    },
    
    socialMediaSettings: {
        facebookPixel: { type: String, default: '' },
        googleAnalytics: { type: String, default: '' },
        tiktokPixel: { type: String, default: '' },
        twitterPixel: { type: String, default: '' },
        linkedInInsight: { type: String, default: '' }
    },
    
    // ============================================
    // العلامة التجارية
    // ============================================
    branding: {
        favicon: { type: String, default: '' },
        watermark: { type: String, default: '' },
        customDomain: { type: String, default: '' },
        customDomainVerified: { type: Boolean, default: false },
        removeBranding: { type: Boolean, default: false } // إزالة علامة MGZon
    },
    
    // ============================================
    // إعدادات الأداء
    // ============================================
    performanceSettings: {
        enableLazyLoad: { type: Boolean, default: true },
        enableImageOptimization: { type: Boolean, default: true },
        enablePreload: { type: Boolean, default: true },
        cacheTTL: { type: Number, default: 3600 }, // ثواني
        enableServiceWorker: { type: Boolean, default: false }
    },
    
    // ============================================
    // إعدادات الإشعارات
    // ============================================
    notificationSettings: {
        newOrderEmail: { type: Boolean, default: true },
        newOrderSMS: { type: Boolean, default: false },
        lowStockAlert: { type: Boolean, default: true },
        lowStockThreshold: { type: Number, default: 5 },
        dailySummaryEmail: { type: Boolean, default: false },
        weeklyReportEmail: { type: Boolean, default: true },
        sendInvoiceEmail: { type: Boolean, default: true }
    },
    
    // ============================================
    // إعدادات الأمان
    // ============================================
    securitySettings: {
        enableCaptcha: { type: Boolean, default: false },
        captchaSiteKey: { type: String, default: '' },
        enable2FA: { type: Boolean, default: false },
        ipWhitelist: [{ type: String }],
        ipBlacklist: [{ type: String }],
        rateLimitPerMinute: { type: Number, default: 60 }
    },
    
    // ============================================
    // الإحصائيات (مدمجة)
    // ============================================
    productsCount: { type: Number, default: 0 },
    followersCount: { type: Number, default: 0 },
    averageRating: { type: Number, default: 0, min: 0, max: 5 },
    
    extendedStats: {
        totalViews: { type: Number, default: 0 },
        totalUniqueVisitors: { type: Number, default: 0 },
        totalOrders: { type: Number, default: 0 },
        totalSales: { type: Number, default: 0 },
        totalShares: { type: Number, default: 0 },
        conversionRate: { type: Number, default: 0 },
        averageOrderValue: { type: Number, default: 0 },
        topReferrers: [{ source: String, count: Number }],
        dailyStats: { type: mongoose.Schema.Types.Mixed, default: {} },
        monthlyStats: { type: mongoose.Schema.Types.Mixed, default: {} }
    },
    
    // ============================================
    // حدود المنتجات (بناءً على الاشتراك)
    // ============================================
    limits: {
        maxProducts: { type: Number, default: 0 },
        maxDigitalProducts: { type: Number, default: 0 },
        maxProjects: { type: Number, default: 0 },
        maxServices: { type: Number, default: 0 },
        maxPages: { type: Number, default: 0 },
        maxStorageMB: { type: Number, default: 100 },
        maxBandwidthGB: { type: Number, default: 10 }
    },
    
    // ============================================
    // حالة الاشتراك (مخزنة مؤقتاً)
    // ============================================
    subscriptionStatus: {
        isActive: { type: Boolean, default: false },
        planId: { type: mongoose.Schema.Types.ObjectId, ref: 'SubscriptionPlan' },
        planName: { type: String, default: '' },
        expiresAt: { type: Date },
        cachedAt: { type: Date, default: Date.now }
    },
    
    // ============================================
    // أكواد الخصم العامة للمتجر
    // ============================================
    storeCoupons: [{
        code: { type: String, uppercase: true, trim: true },
        discount: { type: Number, min: 0, max: 100 },
        discountType: { type: String, enum: ['percentage', 'fixed'], default: 'percentage' },
        minPurchase: { type: Number, default: 0 },
        maxDiscount: { type: Number },
        validFrom: { type: Date, default: Date.now },
        validUntil: { type: Date },
        usageLimit: { type: Number },
        usedCount: { type: Number, default: 0 },
        isActive: { type: Boolean, default: true }
    }],
    
    // ============================================
    // مناطق الشحن
    // ============================================
    shippingZones: [{
        name: { type: String, required: true },
        countries: [{ type: String }],
        cities: [{ type: String }],
        cost: { type: Number, default: 0 },
        freeShippingAbove: { type: Number, default: 0 },
        estimatedDays: { type: String, default: '3-7 business days' }
    }],
    
    // ============================================
    // إعدادات النسخ الاحتياطي
    // ============================================
    backupSettings: {
        autoBackup: { type: Boolean, default: false },
        backupFrequency: { type: String, enum: ['daily', 'weekly', 'monthly'], default: 'weekly' },
        lastBackupAt: { type: Date },
        backupSize: { type: Number, default: 0 },
        backupLocation: { type: String, default: '' }
    },
    
    // ============================================
    // إعدادات التصدير
    // ============================================
    exportSettings: {
        enableCSVExport: { type: Boolean, default: true },
        enableJSONExport: { type: Boolean, default: true },
        enablePDFExport: { type: Boolean, default: true },
        exportEmailReports: { type: Boolean, default: false },
        exportEmail: { type: String, default: '' }
    },
    
    // ============================================
    // إعدادات متقدمة أخرى
    // ============================================
    enableGuestCheckout: { type: Boolean, default: true },
    enableCookiesConsent: { type: Boolean, default: true },
    enableTermsCheckbox: { type: Boolean, default: true },
    termsUrl: { type: String, default: '' },
    privacyUrl: { type: String, default: '' },
    
    createdAt: { type: Date, default: Date.now, immutable: true },
    updatedAt: { type: Date, default: Date.now }
}, {
    timestamps: true,
    toJSON: { virtuals: true },
    toObject: { virtuals: true }
});

// ============================================
// ✅ Indexes محسنة
// ============================================
storeSettingsSchema.index({ userId: 1 }, { unique: true });
storeSettingsSchema.index({ enabled: 1 });
storeSettingsSchema.index({ storeName: 1 });
storeSettingsSchema.index({ averageRating: -1 });
storeSettingsSchema.index({ productsCount: -1 });
storeSettingsSchema.index({ followersCount: -1 });
storeSettingsSchema.index({ createdAt: -1 });
storeSettingsSchema.index({ 'subscriptionStatus.isActive': 1 });
storeSettingsSchema.index({ 'subscriptionStatus.expiresAt': 1 });
storeSettingsSchema.index({ 'branding.customDomain': 1 });
storeSettingsSchema.index({ 'extendedStats.totalViews': -1 });
storeSettingsSchema.index({ 'extendedStats.totalSales': -1 });

// ============================================
// ✅ Virtuals
// ============================================
storeSettingsSchema.virtual('storeUrl').get(function() {
    return `${FRONTEND_URL}/shop/${this.userId}`;
});


storeSettingsSchema.virtual('hasCustomTheme').get(function() {
    return !!this.activeThemeId;
});

storeSettingsSchema.virtual('isSubscriptionActive').get(function() {
    if (!this.subscriptionStatus.isActive) return false;
    if (!this.subscriptionStatus.expiresAt) return true;
    return new Date() < this.subscriptionStatus.expiresAt;
});

// ============================================
// ✅ Pre-save Middleware
// ============================================
storeSettingsSchema.pre('save', function(next) {
    this.updatedAt = Date.now();
    
    // تحديث رمز العملة تلقائياً
    const currencySymbols = {
        'USD': '$', 'EUR': '€', 'GBP': '£', 'EGP': 'ج.م',
        'SAR': '﷼', 'AED': 'د.إ', 'CAD': 'C$', 'AUD': 'A$',
        'JPY': '¥', 'CNY': '¥', 'INR': '₹', 'BRL': 'R$'
    };
    
    if (this.currency && currencySymbols[this.currency]) {
        this.currencySymbol = currencySymbols[this.currency];
    }
    
    // تنظيف الروابط
    if (this.socialLinks) {
        Object.keys(this.socialLinks).forEach(key => {
            if (this.socialLinks[key]) {
                this.socialLinks[key] = this.socialLinks[key].trim();
            }
        });
    }
    
    // تنظيف الأكواد المكررة في storeCoupons
    if (this.storeCoupons && this.storeCoupons.length > 0) {
        const uniqueCodes = new Map();
        for (const coupon of this.storeCoupons) {
            if (!uniqueCodes.has(coupon.code)) {
                uniqueCodes.set(coupon.code, coupon);
            }
        }
        this.storeCoupons = Array.from(uniqueCodes.values());
    }
    
    next();
});

// ============================================
// ✅ Static Methods
// ============================================

/**
 * جلب أو إنشاء إعدادات المتجر لمستخدم
 */
storeSettingsSchema.statics.getOrCreate = async function(userId) {
    let settings = await this.findOne({ userId });
    
    if (!settings) {
        settings = new this({ userId });
        await settings.save();
    }
    
    return settings;
};

/**
 * تحديث إحصائيات المتجر
 */
storeSettingsSchema.statics.updateStats = async function(userId, stats) {
    const updateData = {};
    
    if (stats.productsCount !== undefined) updateData.productsCount = stats.productsCount;
    if (stats.followersCount !== undefined) updateData.followersCount = stats.followersCount;
    if (stats.averageRating !== undefined) updateData.averageRating = stats.averageRating;
    if (stats.totalViews !== undefined) updateData['extendedStats.totalViews'] = stats.totalViews;
    if (stats.totalSales !== undefined) updateData['extendedStats.totalSales'] = stats.totalSales;
    if (stats.totalOrders !== undefined) updateData['extendedStats.totalOrders'] = stats.totalOrders;
    
    return this.findOneAndUpdate(
        { userId },
        { $inc: updateData, $set: { updatedAt: Date.now() } },
        { new: true }
    );
};

/**
 * جلب المتاجر الأكثر مبيعاً
 */
storeSettingsSchema.statics.getTopStores = async function(limit = 10) {
    return this.find({ enabled: true })
        .sort({ 'extendedStats.totalSales': -1 })
        .limit(limit)
        .select('userId storeName storeLogo productsCount followersCount extendedStats.totalSales');
};

/**
 * جلب المتاجر النشطة (مع اشتراك ساري)
 */
storeSettingsSchema.statics.getActiveStores = async function(limit = 50) {
    const now = new Date();
    return this.find({
        enabled: true,
        'subscriptionStatus.isActive': true,
        $or: [
            { 'subscriptionStatus.expiresAt': { $exists: false } },
            { 'subscriptionStatus.expiresAt': { $gte: now } }
        ]
    }).limit(limit);
};

// ============================================
// ✅ Instance Methods
// ============================================

/**
 * تحديث إحصائيات الاشتراك
 */
storeSettingsSchema.methods.updateSubscriptionStatus = async function(subscription) {
    this.subscriptionStatus = {
        isActive: subscription.status === 'active',
        planId: subscription.planId,
        planName: subscription.planName,
        expiresAt: subscription.endDate,
        cachedAt: new Date()
    };
    
    // تحديث الحدود بناءً على الخطة
    if (subscription.plan) {
        this.limits = {
            maxProducts: subscription.plan.features?.maxProducts || 0,
            maxDigitalProducts: subscription.plan.features?.maxDigitalProducts || 0,
            maxProjects: subscription.plan.features?.maxProjects || 0,
            maxServices: subscription.plan.features?.maxServices || 0,
            maxPages: subscription.plan.features?.maxPages || 0,
            maxStorageMB: subscription.plan.features?.maxStorageMB || 100,
            maxBandwidthGB: subscription.plan.features?.maxBandwidthGB || 10
        };
        
        this.branding.removeBranding = subscription.plan.features?.removeBranding || false;
    }
    
    await this.save();
};

/**
 * التحقق من وجود منتج في المتجر
 */
storeSettingsSchema.methods.canAddProduct = async function(type) {
    if (!this.subscriptionStatus.isActive) return false;
    
    const currentCounts = {
        product: this.productsCount,
        digital: await mongoose.model('Product').countDocuments({ userId: this.userId, type: 'digital', isActive: true }),
        project: await mongoose.model('Product').countDocuments({ userId: this.userId, type: 'project', isActive: true }),
        service: await mongoose.model('Product').countDocuments({ userId: this.userId, type: 'service', isActive: true })
    };
    
    const limits = this.limits;
    
    if (limits.maxProducts > 0 && currentCounts.product >= limits.maxProducts) {
        return false;
    }
    
    if (type === 'digital' && limits.maxDigitalProducts > 0 && currentCounts.digital >= limits.maxDigitalProducts) {
        return false;
    }
    
    if (type === 'project' && limits.maxProjects > 0 && currentCounts.project >= limits.maxProjects) {
        return false;
    }
    
    if (type === 'service' && limits.maxServices > 0 && currentCounts.service >= limits.maxServices) {
        return false;
    }
    
    return true;
};

/**
 * تسجيل مشاهدة للمتجر
 */
storeSettingsSchema.methods.trackView = async function() {
    this.extendedStats.totalViews += 1;
    await this.save();
};

/**
 * تسجيل عملية بيع
 */
storeSettingsSchema.methods.trackSale = async function(amount) {
    this.extendedStats.totalSales += amount;
    this.extendedStats.totalOrders += 1;
    
    // تحديث متوسط قيمة الطلب
    this.extendedStats.averageOrderValue = this.extendedStats.totalSales / this.extendedStats.totalOrders;
    
    // تحديث نسبة التحويل (يمكن تحديثها لاحقاً مع عدد الزوار)
    if (this.extendedStats.totalUniqueVisitors > 0) {
        this.extendedStats.conversionRate = (this.extendedStats.totalOrders / this.extendedStats.totalUniqueVisitors) * 100;
    }
    
    await this.save();
};

/**
 * التحقق من صحة كوبون الخصم
 */
storeSettingsSchema.methods.validateCoupon = async function(code, cartTotal) {
    const coupon = this.storeCoupons?.find(c => c.code === code.toUpperCase() && c.isActive);
    
    if (!coupon) return { valid: false, message: 'Invalid coupon code' };
    
    const now = new Date();
    if (coupon.validUntil && now > coupon.validUntil) {
        return { valid: false, message: 'Coupon has expired' };
    }
    
    if (coupon.validFrom && now < coupon.validFrom) {
        return { valid: false, message: 'Coupon not yet active' };
    }
    
    if (coupon.usageLimit && coupon.usedCount >= coupon.usageLimit) {
        return { valid: false, message: 'Coupon usage limit reached' };
    }
    
    if (cartTotal < coupon.minPurchase) {
        return { valid: false, message: `Minimum purchase of ${this.currencySymbol}${coupon.minPurchase} required` };
    }
    
    let discount = 0;
    if (coupon.discountType === 'percentage') {
        discount = (cartTotal * coupon.discount) / 100;
        if (coupon.maxDiscount && discount > coupon.maxDiscount) {
            discount = coupon.maxDiscount;
        }
    } else {
        discount = Math.min(coupon.discount, cartTotal);
    }
    
    return {
        valid: true,
        discount: discount,
        finalTotal: cartTotal - discount,
        coupon: coupon
    };
};

const StoreSettings = mongoose.model('StoreSettings', storeSettingsSchema);


/**
 * نموذج قوالب المتجر - يدعم القوالب المخصصة والافتراضية
 * @version 2.0.0
 */

const storeThemeSchema = new mongoose.Schema({
    userId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true,
        unique: true,
        index: true
    },
    
    // معلومات القالب الأساسية
    name: {
        type: String,
        default: 'Default Theme',
        trim: true,
        maxlength: 100
    },
    isActive: {
        type: Boolean,
        default: true,
        index: true
    },
    version: {
        type: String,
        default: '1.0.0',
        match: /^\d+\.\d+\.\d+$/
    },
    
    // تصميم القالب (Layout)
    layout: {
        type: String,
        enum: ['full-width', 'boxed', 'fluid', 'dashboard', 'minimal'],
        default: 'full-width'
    },
    
    // قوالب HTML مخصصة
    customTemplates: {
        header: { type: String, default: '', maxlength: 50000 },
        footer: { type: String, default: '', maxlength: 50000 },
        sidebar: { type: String, default: '', maxlength: 50000 },
        productCard: { type: String, default: '', maxlength: 20000 },
        categoryCard: { type: String, default: '', maxlength: 20000 }
    },
    
    // ملف القالب المرفوع (ZIP)
    uploadedTheme: {
        filename: { type: String },
        originalName: { type: String },
        fileUrl: { type: String },
        fileSize: { type: Number },
        fileHash: { type: String }, // للتأكد من عدم تكرار الرفع
        mimeType: { type: String },
        uploadedAt: { type: Date, default: Date.now },
        extractedFiles: {
            htmlFiles: [{ name: String, size: Number }],
            cssFiles: [{ name: String, size: Number }],
            jsFiles: [{ name: String, size: Number }],
            imageFiles: [{ name: String, size: Number, url: String }]
        }
    },
    
    // إعدادات القالب
    settings: {
        containerWidth: {
            type: String,
            default: '1280px',
            match: /^\d+(px|rem|em|%|vw|vh)$/
        },
        containerPadding: {
            type: String,
            default: '20px'
        },
        showBreadcrumb: {
            type: Boolean,
            default: true
        },
        stickyHeader: {
            type: Boolean,
            default: false
        },
        backToTop: {
            type: Boolean,
            default: true
        },
        showSearchBar: {
            type: Boolean,
            default: true
        },
        showCategories: {
            type: Boolean,
            default: true
        },
        productsPerRow: {
            type: Number,
            enum: [2, 3, 4, 6],
            default: 4
        },
        productsPerPage: {
            type: Number,
            min: 6,
            max: 48,
            default: 12
        },
        enableLazyLoad: {
            type: Boolean,
            default: true
        },
        enableAnimations: {
            type: Boolean,
            default: true
        }
    },
    
    // ألوان القالب (CSS Variables)
    colors: {
        primary: { type: String, default: '#3b82f6', match: /^#[0-9A-Fa-f]{6}$/ },
        secondary: { type: String, default: '#8b5cf6', match: /^#[0-9A-Fa-f]{6}$/ },
        accent: { type: String, default: '#f59e0b', match: /^#[0-9A-Fa-f]{6}$/ },
        background: { type: String, default: '#ffffff', match: /^#[0-9A-Fa-f]{6}$/ },
        text: { type: String, default: '#1f2937', match: /^#[0-9A-Fa-f]{6}$/ },
        textLight: { type: String, default: '#6b7280', match: /^#[0-9A-Fa-f]{6}$/ },
        border: { type: String, default: '#e5e7eb', match: /^#[0-9A-Fa-f]{6}$/ },
        success: { type: String, default: '#10b981', match: /^#[0-9A-Fa-f]{6}$/ },
        error: { type: String, default: '#ef4444', match: /^#[0-9A-Fa-f]{6}$/ },
        warning: { type: String, default: '#f59e0b', match: /^#[0-9A-Fa-f]{6}$/ }
    },
    
    // خطوط القالب
    typography: {
        fontFamily: {
            type: String,
            default: 'Inter, sans-serif',
            enum: ['Inter, sans-serif', 'Poppins, sans-serif', 'Roboto, sans-serif', 'Open Sans, sans-serif', 'Playfair Display, serif']
        },
        headingFont: {
            type: String,
            default: 'Inter, sans-serif'
        },
        baseFontSize: {
            type: String,
            default: '16px',
            match: /^\d+(px|rem)$/
        },
        enableGoogleFonts: {
            type: Boolean,
            default: true
        }
    },
    
    // CSS/JS المخصص
    customAssets: {
        css: { type: String, default: '', maxlength: 100000 },
        js: { type: String, default: '', maxlength: 100000 },
        headHtml: { type: String, default: '', maxlength: 10000 },
        bodyHtml: { type: String, default: '', maxlength: 10000 }
    },
    
    // تحسين محركات البحث (SEO للقالب نفسه)
    seo: {
        metaTitle: { type: String, maxlength: 70 },
        metaDescription: { type: String, maxlength: 160 },
        metaKeywords: { type: String, maxlength: 200 },
        ogImage: { type: String },
        twitterCard: { type: String, default: 'summary_large_image' },
        canonicalUrl: { type: String },
        structuredData: { type: mongoose.Schema.Types.Mixed, default: {} }
    },
    
    // إحصائيات استخدام القالب
    stats: {
        views: { type: Number, default: 0 },
        lastUsed: { type: Date },
        templateChanges: { type: Number, default: 0 },
        lastChangeAt: { type: Date }
    },
    
    // حالة القالب
    isDeleted: {
        type: Boolean,
        default: false,
        index: true
    },
    deletedAt: {
        type: Date
    },
    
    createdAt: { type: Date, default: Date.now, immutable: true },
    updatedAt: { type: Date, default: Date.now }
}, {
    timestamps: true,
    toJSON: { virtuals: true },
    toObject: { virtuals: true }
});

// ============================================
// Indexes لتحسين الأداء
// ============================================
storeThemeSchema.index({ userId: 1, isActive: 1 });
storeThemeSchema.index({ 'stats.views': -1 });
storeThemeSchema.index({ updatedAt: -1 });
storeThemeSchema.index({ isDeleted: 1 });

// ============================================
// Virtuals
// ============================================
storeThemeSchema.virtual('isCustomTheme').get(function() {
    return !!this.uploadedTheme?.fileUrl;
});

storeThemeSchema.virtual('themeUrl').get(function() {
    const baseUrl = process.env.BASE_URL || 'https://mgzon-server.hf.space';
    return `${baseUrl}/api/store/theme/${this.userId}`;
});

// ============================================
// Middleware: قبل الحفظ
// ============================================
storeThemeSchema.pre('save', function(next) {
    this.updatedAt = Date.now();
    
    // تنظيف HTML من الأكواد الضارة
    if (this.customTemplates.header) {
        this.customTemplates.header = sanitizeHtml(this.customTemplates.header);
    }
    if (this.customTemplates.footer) {
        this.customTemplates.footer = sanitizeHtml(this.customTemplates.footer);
    }
    
    // توليد hash للملف إذا لم يكن موجوداً
    if (this.uploadedTheme && this.uploadedTheme.fileUrl && !this.uploadedTheme.fileHash) {
        this.uploadedTheme.fileHash = createHash('md5')
            .update(this.uploadedTheme.fileUrl + this.userId)
            .digest('hex');
    }
    
    next();
});

// ============================================
// Static Methods
// ============================================

/**
 * جلب القالب النشط لمستخدم معين
 * @param {string} userId - معرف المستخدم
 * @returns {Promise<Object>} - القالب النشط
 */
storeThemeSchema.statics.getActiveTheme = async function(userId) {
    let theme = await this.findOne({ userId, isActive: true, isDeleted: false });
    
    if (!theme) {
        // إنشاء قالب افتراضي
        theme = new this({ userId });
        await theme.save();
    }
    
    // تحديث إحصائيات الاستخدام
    theme.stats.views += 1;
    theme.stats.lastUsed = new Date();
    await theme.save();
    
    return theme;
};

/**
 * نسخ قالب من مستخدم إلى آخر
 * @param {string} sourceUserId - مصدر القالب
 * @param {string} targetUserId - المستخدم المستهدف
 * @returns {Promise<Object>} - القالب الجديد
 */
storeThemeSchema.statics.cloneTheme = async function(sourceUserId, targetUserId) {
    const sourceTheme = await this.findOne({ userId: sourceUserId, isActive: true });
    if (!sourceTheme) {
        throw new Error('Source theme not found');
    }
    
    const themeData = sourceTheme.toObject();
    delete themeData._id;
    delete themeData.userId;
    delete themeData.createdAt;
    delete themeData.updatedAt;
    delete themeData.stats;
    
    const newTheme = new this({
        ...themeData,
        userId: targetUserId,
        name: `${sourceTheme.name} (Copy)`,
        stats: { views: 0, templateChanges: 0 }
    });
    
    await newTheme.save();
    return newTheme;
};

/**
 * إعادة تعيين القالب إلى الإعدادات الافتراضية
 * @param {string} userId - معرف المستخدم
 * @returns {Promise<Object>} - القالب المعاد تعيينه
 */
storeThemeSchema.statics.resetToDefault = async function(userId) {
    await this.deleteOne({ userId });
    return this.getActiveTheme(userId);
};

// ============================================
// Instance Methods
// ============================================

/**
 * تطبيق القالب على HTML المحتوى
 * @param {string} content - المحتوى الأصلي
 * @returns {string} - المحتوى بعد تطبيق القالب
 */
storeThemeSchema.methods.applyToContent = function(content) {
    let result = content;
    
    // تطبيق الهيدر المخصص
    if (this.customTemplates.header) {
        result = this.customTemplates.header + result;
    }
    
    // تطبيق الفوتر المخصص
    if (this.customTemplates.footer) {
        result = result + this.customTemplates.footer;
    }
    
    // إضافة CSS المخصص
    if (this.customAssets.css) {
        const cssTag = `<style id="store-theme-css">${this.customAssets.css}</style>`;
        result = result.replace('</head>', `${cssTag}</head>`);
    }
    
    // إضافة JS المخصص
    if (this.customAssets.js) {
        const jsTag = `<script id="store-theme-js">${this.customAssets.js}<\/script>`;
        result = result.replace('</body>', `${jsTag}</body>`);
    }
    
    // تطبيق ألوان CSS Variables
    const colorVariables = Object.entries(this.colors)
        .map(([key, value]) => `--store-${key}: ${value};`)
        .join('\n');
    
    const colorStyle = `<style>:root { ${colorVariables} }</style>`;
    result = result.replace('</head>', `${colorStyle}</head>`);
    
    return result;
};

/**
 * تسجيل تغيير في القالب
 */
storeThemeSchema.methods.recordChange = async function() {
    this.stats.templateChanges += 1;
    this.stats.lastChangeAt = new Date();
    await this.save();
};

// ============================================
// دالة مساعدة لتنظيف HTML
// ============================================
function sanitizeHtml(html) {
    if (!html) return '';
    
    // إزالة الـ Script tags والأكواد الضارة
    return html
        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
        .replace(/javascript:/gi, '')
        .replace(/on\w+="[^"]*"/gi, '')
        .replace(/on\w+='[^']*'/gi, '');
}

const StoreTheme = mongoose.model('StoreTheme', storeThemeSchema);



const reviewSchema = new mongoose.Schema({
    storeId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    productId: { type: mongoose.Schema.Types.ObjectId, ref: 'Product' },
    author: { type: String, required: true },
    rating: { type: Number, min: 1, max: 5, required: true },
    comment: { type: String, maxlength: 500 },
    isApproved: { type: Boolean, default: true },
    createdAt: { type: Date, default: Date.now }
});
const Review = mongoose.model('Review', reviewSchema);

// ============================================
// 🗂️ STORE PAGES MODEL - صفحات المتجر المخصصة (محدث بالكامل)
// ============================================

/**
 * نموذج الصفحات - يدعم Shortcodes، الإصدارات، القفل، والإحصائيات المتقدمة
 * @version 3.0.0
 */

const pageSchema = new mongoose.Schema({
    // ============================================
    // المعلومات الأساسية
    // ============================================
    storeId: { 
        type: mongoose.Schema.Types.ObjectId, 
        ref: 'User', 
        required: true,
        index: true
    },
    
    slug: { 
        type: String, 
        required: true,
        lowercase: true,
        trim: true,
        match: /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
        index: true
    },
    title: { 
        type: String, 
        required: true,
        trim: true,
        maxlength: 100 
    },
    
    // ============================================
    // المحتوى والتخصيص
    // ============================================
    content: { 
        type: String, 
        default: '' 
    },
    rawContent: {
        type: String,
        default: ''
    },
    css: { 
        type: String, 
        default: '' 
    },
    js: { 
        type: String, 
        default: '' 
    },
    
    // ============================================
    // نوع الصفحة وحالتها
    // ============================================
    type: { 
        type: String, 
        enum: ['default', 'custom', 'uploaded'], 
        default: 'custom' 
    },
    isDefault: { 
        type: Boolean, 
        default: false 
    },
    isEnabled: { 
        type: Boolean, 
        default: true,
        index: true
    },
    order: { 
        type: Number, 
        default: 0 
    },
    
    // ============================================
    // الملفات المرفوعة
    // ============================================
    uploadedFile: {
        filename: { type: String },
        originalName: { type: String },
        fileUrl: { type: String },
        fileSize: { type: Number },
        mimeType: { type: String },
        uploadedAt: { type: Date, default: Date.now }
    },
    
    thumbnail: {
        type: String,
        default: ''
    },
    
    // ============================================
    // Shortcodes
    // ============================================
    hasShortcodes: {
        type: Boolean,
        default: false,
        index: true
    },
    shortcodesList: [{
        name: { type: String },
        count: { type: Number, default: 0 }
    }],
    
    // ============================================
    // SEO والبيانات المنظمة
    // ============================================
    seo: {
        title: { type: String, maxlength: 70 },
        description: { type: String, maxlength: 250 },
        keywords: { type: String },
        ogImage: { type: String },
        noindex: { type: Boolean, default: false },
        nofollow: { type: Boolean, default: false }
    },
    
    structuredData: {
        type: mongoose.Schema.Types.Mixed,
        default: null
    },
    
    tags: [{
        type: String,
        trim: true,
        lowercase: true,
        index: true
    }],
    
    // ============================================
    // الصلاحيات والرؤية
    // ============================================
    visibility: {
        type: String,
        enum: ['public', 'logged-in', 'only-owner'],
        default: 'public',
        index: true
    },
    
    permissions: {
        canEdit: [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }],
        canView: [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }]
    },
    
    settings: {
        showInNav: { type: Boolean, default: true },
        showInFooter: { type: Boolean, default: false },
        openInNewTab: { type: Boolean, default: false },
        requireAuth: { type: Boolean, default: false },
        passwordProtected: { type: Boolean, default: false },
        password: { type: String, default: '' }
    },
    
    // ============================================
    // الجدولة والإصدارات
    // ============================================
    scheduledAt: { type: Date, index: true },
    expiresAt: { type: Date, index: true },
    
    schemaVersion: {
        type: String,
        default: '3.0.0'
    },
    
    versions: [{
        version: { type: Number },
        content: { type: String },
        css: { type: String },
        js: { type: String },
        createdAt: { type: Date, default: Date.now }
    }],
    
    // ============================================
    // قفل التحرير
    // ============================================
    lockedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
    lockedAt: { type: Date },
    
    // ============================================
    // من قام بالإنشاء والتعديل
    // ============================================
    createdBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
    updatedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
    
    // ============================================
    // إحصائيات (مدمجة)
    // ============================================
    stats: {
        views: { type: Number, default: 0 },
        uniqueViews: { type: Number, default: 0 },
        lastViewedAt: { type: Date },
        avgTimeOnPage: { type: Number, default: 0 },
        bounceRate: { type: Number, default: 0 },
        shares: { type: Number, default: 0 }
    },
    
    // مصادر الزوار (آخر 50 فقط)
    referrers: [{ 
        source: { type: String }, 
        count: { type: Number, default: 0 },
        lastVisit: { type: Date }
    }],
    
    // الزوار الفريدين (TTL index: تنتهي بعد 24 ساعة)
    uniqueVisitors: [{
        ip: { type: String },
        timestamp: { type: Date, default: Date.now }
    }],
    
    createdAt: { type: Date, default: Date.now, immutable: true },
    updatedAt: { type: Date, default: Date.now }
}, {
    timestamps: true,
    toJSON: { virtuals: true },
    toObject: { virtuals: true }
});

// ============================================
// ✅ Indexes محسنة
// ============================================
pageSchema.index({ storeId: 1, slug: 1 }, { unique: true });
pageSchema.index({ storeId: 1, isEnabled: 1, order: 1 });
pageSchema.index({ storeId: 1, type: 1 });
pageSchema.index({ 'stats.views': -1 });
pageSchema.index({ scheduledAt: 1 });
pageSchema.index({ expiresAt: 1 });
pageSchema.index({ 'uniqueVisitors.timestamp': 1 }, { expireAfterSeconds: 86400 }); // TTL index

// ============================================
// ✅ Virtuals
// ============================================
pageSchema.virtual('url').get(function() {
    const slugPath = this.slug === 'products' ? '' : this.slug;
    return `${FRONTEND_URL}/shop/${this.storeId}/${slugPath}`;
});

pageSchema.virtual('isLocked').get(function() {
    if (!this.lockedAt) return false;
    return (Date.now() - this.lockedAt) < 30 * 60 * 1000; // 30 دقيقة
});

pageSchema.virtual('shortcodeNames').get(function() {
    return this.shortcodesList.map(s => s.name);
});

// ============================================
// ✅ Pre-save Middleware
// ============================================
pageSchema.pre('save', function(next) {
    this.updatedAt = Date.now();

    // تنظيف slug
    if (this.slug) {
        this.slug = this.slug.toLowerCase().replace(/[^a-z0-9-]/g, '-');
    }

    // كشف Shortcodes وحفظها
    if (this.content) {
        // تنظيف HTML من event handlers الخطيرة
        this.content = this.content.replace(/\s(on\w+)=("[^"]*"|'[^']*'|[^\s>]+)/gi, '');
        
        // كشف الـ Shortcodes
        const shortcodeRegex = /\[(\w+)(?:\s+[^\]]*)?\]/g;
        const foundShortcodes = new Map();
        let match;
        
        while ((match = shortcodeRegex.exec(this.content)) !== null) {
            const name = match[1];
            foundShortcodes.set(name, (foundShortcodes.get(name) || 0) + 1);
        }
        
        this.hasShortcodes = foundShortcodes.size > 0;
        this.shortcodesList = Array.from(foundShortcodes.entries()).map(([name, count]) => ({ name, count }));
        
        // حفظ نسخة احتياطية إذا لم تكن موجودة
        if (!this.rawContent && this.hasShortcodes) {
            this.rawContent = this.content;
        }
    }

    // تنظيف CSS
    if (this.css) {
        this.css = this.css
            .replace(/expression\s*\(/gi, '')
            .replace(/behavior\s*:/gi, '')
            .replace(/javascript\s*:/gi, '');
    }

    // تنظيف JS
    if (this.js) {
        this.js = this.js
            .replace(/document\.write\s*\(/gi, '')
            .replace(/eval\s*\(/gi, '');
    }

    // تنظيف uniqueVisitors (الاحتفاظ بآخر 100 فقط)
    if (this.uniqueVisitors && this.uniqueVisitors.length > 100) {
        this.uniqueVisitors = this.uniqueVisitors.slice(-100);
    }

    // تنظيف referrers (الاحتفاظ بآخر 50 فقط)
    if (this.referrers && this.referrers.length > 50) {
        this.referrers = this.referrers.slice(-50);
    }

    next();
});

// ============================================
// ✅ Static Methods
// ============================================

/**
 * جلب الصفحات النشطة لمتجر معين
 */
pageSchema.statics.getActivePages = function(storeId) {
    const now = new Date();
    return this.find({ 
        storeId, 
        isEnabled: true,
        visibility: 'public',
        $or: [
            { scheduledAt: { $exists: false } },
            { scheduledAt: { $lte: now } }
        ],
        $or: [
            { expiresAt: { $exists: false } },
            { expiresAt: { $gte: now } }
        ]
    }).sort({ order: 1 });
};

/**
 * جلب الصفحات التي تحتوي على Shortcode معين
 */
pageSchema.statics.findByShortcode = function(storeId, shortcodeName) {
    return this.find({
        storeId,
        hasShortcodes: true,
        'shortcodesList.name': shortcodeName,
        isEnabled: true
    }).select('slug title shortcodesList stats.views');
};

/**
 * الحصول على أكثر الـ Shortcodes استخداماً
 */
pageSchema.statics.getTopShortcodes = function(storeId, limit = 10) {
    return this.aggregate([
        { $match: { storeId, hasShortcodes: true } },
        { $unwind: '$shortcodesList' },
        { $group: { 
            _id: '$shortcodesList.name', 
            totalCount: { $sum: '$shortcodesList.count' },
            pagesCount: { $sum: 1 }
        }},
        { $sort: { totalCount: -1 } },
        { $limit: limit }
    ]);
};

/**
 * البحث في الصفحات (Full-text search)
 */
pageSchema.statics.searchPages = function(storeId, query, options = {}) {
    const searchRegex = new RegExp(query, 'i');
    return this.find({
        storeId,
        isEnabled: true,
        $or: [
            { title: searchRegex },
            { content: searchRegex },
            { tags: searchRegex },
            { 'seo.keywords': searchRegex }
        ]
    })
    .sort({ 'stats.views': -1 })
    .limit(options.limit || 20)
    .select('slug title stats.views thumbnail');
};

/**
 * الحصول على إحصائيات الصفحات للمتجر
 */
pageSchema.statics.getStoreStats = function(storeId) {
    return this.aggregate([
        { $match: { storeId } },
        { $group: {
            _id: null,
            totalPages: { $sum: 1 },
            totalViews: { $sum: '$stats.views' },
            totalUniqueViews: { $sum: '$stats.uniqueViews' },
            totalShares: { $sum: '$stats.shares' },
            pagesWithShortcodes: { $sum: { $cond: ['$hasShortcodes', 1, 0] } },
            avgTimeOnPage: { $avg: '$stats.avgTimeOnPage' },
            avgBounceRate: { $avg: '$stats.bounceRate' }
        }}
    ]);
};

// ============================================
// ✅ Instance Methods
// ============================================

/**
 * زيادة عدد المشاهدات
 */
pageSchema.methods.incrementViews = async function(ip, userId = null) {
    this.stats.views += 1;
    
    if (!userId) {
        this.stats.uniqueViews += 1;
        
        // إضافة IP فريد (إذا لم يكن موجوداً في آخر 24 ساعة)
        const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
        const existingVisitor = this.uniqueVisitors.find(v => v.ip === ip && v.timestamp > oneDayAgo);
        if (!existingVisitor) {
            this.uniqueVisitors.push({ ip, timestamp: new Date() });
        }
    }
    
    this.stats.lastViewedAt = new Date();
    await this.save();
};

/**
 * إضافة مصدر زائر
 */
pageSchema.methods.addReferrer = async function(source) {
    if (!source) return;
    
    const existing = this.referrers.find(r => r.source === source);
    if (existing) {
        existing.count += 1;
        existing.lastVisit = new Date();
    } else {
        this.referrers.push({ source, count: 1, lastVisit: new Date() });
    }
    
    await this.save();
};

/**
 * قفل الصفحة للتحرير
 */
pageSchema.methods.lock = async function(userId) {
    if (this.isLocked && this.lockedBy?.toString() !== userId?.toString()) {
        throw new Error('Page is currently being edited by another user');
    }
    
    this.lockedBy = userId;
    this.lockedAt = new Date();
    await this.save();
};

/**
 * إلغاء قفل الصفحة
 */
pageSchema.methods.unlock = async function(userId) {
    if (this.lockedBy?.toString() === userId?.toString()) {
        this.lockedBy = null;
        this.lockedAt = null;
        await this.save();
    }
};

/**
 * إنشاء نسخة جديدة من الصفحة
 */
pageSchema.methods.createVersion = async function() {
    const nextVersion = (this.versions.length || 0) + 1;
    
    this.versions.push({
        version: nextVersion,
        content: this.content,
        css: this.css,
        js: this.js,
        createdAt: new Date()
    });
    
    // الاحتفاظ بآخر 50 نسخة فقط
    if (this.versions.length > 50) {
        this.versions = this.versions.slice(-50);
    }
    
    await this.save();
    return nextVersion;
};

/**
 * استعادة نسخة سابقة
 */
pageSchema.methods.restoreVersion = async function(versionNumber) {
    const version = this.versions.find(v => v.version === versionNumber);
    if (!version) {
        throw new Error('Version not found');
    }
    
    this.content = version.content;
    this.css = version.css;
    this.js = version.js;
    this.updatedAt = new Date();
    
    await this.save();
    return true;
};

/**
 * مشاركة الصفحة (زيادة عدد المشاركات)
 */
pageSchema.methods.incrementShares = async function() {
    this.stats.shares += 1;
    await this.save();
};

/**
 * تحديث وقت المكوث على الصفحة
 */
pageSchema.methods.updateTimeOnPage = async function(timeSpentSeconds) {
    const currentAvg = this.stats.avgTimeOnPage || 0;
    const totalViews = this.stats.views || 1;
    this.stats.avgTimeOnPage = (currentAvg * (totalViews - 1) + timeSpentSeconds) / totalViews;
    await this.save();
};

/**
 * تحديث نسبة الارتداد
 */
pageSchema.methods.updateBounceRate = async function(bounced) {
    const totalViews = this.stats.views || 1;
    const currentBounces = Math.round((this.stats.bounceRate || 0) * totalViews / 100);
    const newBounces = currentBounces + (bounced ? 1 : 0);
    this.stats.bounceRate = (newBounces / totalViews) * 100;
    await this.save();
};

const Page = mongoose.model('Page', pageSchema);


// ============================================
// 📋 SUBSCRIPTION MODELS
// ============================================

// 1. نموذج خطط الاشتراك (Subscription Plans)
const subscriptionPlanSchema = new mongoose.Schema({
    name: { type: String, required: true, unique: true }, // e.g., "Starter", "Pro", "Business"
    nameAr: { type: String }, // اسم الخطة بالعربية
    description: { type: String },
    descriptionAr: { type: String },
    price: { type: Number, required: true, min: 0 },
    currency: { type: String, default: 'USD' },
    currencySymbol: { type: String, default: '$' },
    duration: { type: String, enum: ['monthly', 'yearly', 'lifetime'], default: 'monthly' },
    durationDays: { type: Number, default: 30 }, // عدد أيام الاشتراك
    
    // مميزات الخطة
    features: {
        storeEnabled: { type: Boolean, default: false },      // هل يسمح بإنشاء متجر؟
        maxProducts: { type: Number, default: 0 },            // عدد المنتجات المسموحة (0 = غير محدود)
        maxDigitalProducts: { type: Number, default: 0 },
        maxProjects: { type: Number, default: 0 },
        maxServices: { type: Number, default: 0 },
        pageBuilderEnabled: { type: Boolean, default: false }, // هل يسمح ب Page Builder؟
        customDomain: { type: Boolean, default: false },      // هل يسمح بنطاق مخصص؟
        analyticsEnabled: { type: Boolean, default: false },  // هل يسمح بالتحليلات المتقدمة؟
        prioritySupport: { type: Boolean, default: false },   // دعم أولوية
        removeBranding: { type: Boolean, default: false },    // إزالة علامة MGZon
        teamMembers: { type: Number, default: 1 },            // عدد أعضاء الفريق المسموحين
        apiAccess: { type: Boolean, default: false },         // وصول API
        customCss: { type: Boolean, default: false },         // CSS مخصص
        advancedAnalytics: { type: Boolean, default: false }, // تحليلات متقدمة
        exportData: { type: Boolean, default: false }         // تصدير البيانات
    },
    
    // إعدادات التجربة المجانية
    hasFreeTrial: { type: Boolean, default: false },
    freeTrialDays: { type: Number, default: 0 },
    
    // إعدادات العرض
    badge: { type: String, enum: ['popular', 'best-value', 'enterprise', null], default: null },
    badgeColor: { type: String, default: '#10b981' },
    icon: { type: String, default: 'bx-star' },
    isActive: { type: Boolean, default: true },
    order: { type: Number, default: 0 },
    
    // صلاحيات مخصصة (JSON للمستقبل)
    customPermissions: { type: mongoose.Schema.Types.Mixed, default: {} },
    
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

subscriptionPlanSchema.index({ isActive: 1, order: 1 });
subscriptionPlanSchema.index({ name: 1 });

const SubscriptionPlan = mongoose.model('SubscriptionPlan', subscriptionPlanSchema);

// 2. نموذج طرق دفع الاشتراكات (Platform Payment Methods)
const platformPaymentMethodSchema = new mongoose.Schema({
    name: { type: String, required: true, unique: true }, // e.g., "Bank Misr", "Vodafone Cash"
    nameAr: { type: String },
    type: { type: String, enum: ['bank', 'mobile_wallet', 'online'], required: true },
    icon: { type: String, default: 'bx-bank' },
    instructions: { type: String }, // تعليمات الدفع
    instructionsAr: { type: String },
    
    // بيانات الحساب حسب النوع
    bankDetails: {
        bankName: { type: String },
        accountName: { type: String },
        accountNumber: { type: String },
        iban: { type: String },
        swiftCode: { type: String },
        branch: { type: String }
    },
    mobileWalletDetails: {
        provider: { type: String }, // Vodafone, InstaPay, etc.
        phoneNumber: { type: String }
    },
    onlineDetails: {
        provider: { type: String }, // Stripe, PayPal, etc.
        apiKey: { type: String },
        webhookSecret: { type: String },
        isActive: { type: Boolean, default: false }
    },
    
    isActive: { type: Boolean, default: true },
    order: { type: Number, default: 0 },
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

const PlatformPaymentMethod = mongoose.model('PlatformPaymentMethod', platformPaymentMethodSchema);

// 3. نموذج اشتراكات المستخدمين (User Subscriptions)
const userSubscriptionSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    planId: { type: mongoose.Schema.Types.ObjectId, ref: 'SubscriptionPlan', required: true },
    
    // تفاصيل الاشتراك
    status: { 
        type: String, 
        enum: ['pending', 'active', 'expired', 'cancelled', 'refunded'],
        default: 'pending'
    },
    startDate: { type: Date },
    endDate: { type: Date },
    
    // التجربة المجانية
    isTrial: { type: Boolean, default: false },
    trialEndDate: { type: Date },
    
    // الدفع
    paymentMethod: { type: String },
    paymentDetails: { type: mongoose.Schema.Types.Mixed },
    paymentProof: { type: String }, // رابط صورة إثبات الدفع
    paymentProofPublicId: { type: String },
    amount: { type: Number },
    currency: { type: String, default: 'USD' },
    transactionId: { type: String },
    
    // ملاحظات الإدارة
    adminNotes: { type: String },
    approvedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
    approvedAt: { type: Date },
    
    // التجديد التلقائي
    autoRenew: { type: Boolean, default: false },
    cancelledAt: { type: Date },
    cancellationReason: { type: String },
    
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

userSubscriptionSchema.index({ userId: 1, status: 1 });
userSubscriptionSchema.index({ endDate: 1 });
userSubscriptionSchema.index({ status: 1, endDate: 1 });

const UserSubscription = mongoose.model('UserSubscription', userSubscriptionSchema);

// 4. نموذج إعدادات نظام الاشتراكات
const subscriptionSettingsSchema = new mongoose.Schema({
    // إعدادات التجربة المجانية العامة
    defaultFreeTrialDays: { type: Number, default: 14 },
    allowFreeTrialForExistingUsers: { type: Boolean, default: true },
    
    // إعدادات العمولة
    commissionEnabled: { type: Boolean, default: false },
    commissionRate: { type: Number, default: 0 }, // نسبة مئوية
    
    // إعدادات الدفع
    currency: { type: String, default: 'USD' },
    currencySymbol: { type: String, default: '$' },
    
    // إعدادات البريد الإلكتروني
    sendInvoiceEmail: { type: Boolean, default: true },
    sendReminderEmail: { type: Boolean, default: true },
    reminderDays: { type: Number, default: 7 },
    
    // إعدادات الإشعارات
    notifyAdminOnNewSubscription: { type: Boolean, default: true },
    notifyUserOnStatusChange: { type: Boolean, default: true },
    
    updatedAt: { type: Date, default: Date.now }
});

const SubscriptionSettings = mongoose.model('SubscriptionSettings', subscriptionSettingsSchema);

// 5. نموذج أرباح الاشتراكات (Subscription Earnings)
const subscriptionEarningsSchema = new mongoose.Schema({
    subscriptionId: { type: mongoose.Schema.Types.ObjectId, ref: 'UserSubscription' },
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
    planId: { type: mongoose.Schema.Types.ObjectId, ref: 'SubscriptionPlan' },
    amount: { type: Number },
    currency: { type: String, default: 'USD' },
    status: { type: String, enum: ['pending', 'completed', 'refunded'], default: 'pending' },
    paymentMethod: { type: String },
    transactionId: { type: String },
    payoutStatus: { type: String, enum: ['pending', 'processing', 'completed', 'failed'], default: 'pending' },
    payoutDate: { type: Date },
    adminNotes: { type: String },
    createdAt: { type: Date, default: Date.now }
});

const SubscriptionEarnings = mongoose.model('SubscriptionEarnings', subscriptionEarningsSchema);

// مؤشرات لتحسين الأداء
userSubscriptionSchema.index({ userId: 1, status: 1 });
userSubscriptionSchema.index({ endDate: 1 });
userSubscriptionSchema.index({ status: 1, endDate: 1 });
subscriptionPlanSchema.index({ isActive: 1, order: 1 });
platformPaymentMethodSchema.index({ isActive: 1, order: 1 });
subscriptionEarningsSchema.index({ createdAt: -1 });
subscriptionEarningsSchema.index({ status: 1 });


// 4. نموذج الإيرادات (Earnings)
const earningsSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, unique: true },
    totalSales: { type: Number, default: 0 },
    totalEarnings: { type: Number, default: 0 },
    pendingPayout: { type: Number, default: 0 },
    lifetimeEarnings: { type: Number, default: 0 },
    
    transactions: [{
        orderId: { type: mongoose.Schema.Types.ObjectId, ref: 'Order' },
        amount: { type: Number },
        type: { type: String, enum: ['sale', 'refund', 'payout'] },
        status: { type: String, enum: ['pending', 'completed', 'failed'] },
        notes: { type: String },
        createdAt: { type: Date, default: Date.now }
    }],
    
    monthlyStats: [{
        month: { type: String }, // "2024-01"
        sales: { type: Number, default: 0 },
        earnings: { type: Number, default: 0 }
    }],
    
    updatedAt: { type: Date, default: Date.now }
});

const Earnings = mongoose.model('Earnings', earningsSchema);


const couponSchema = new mongoose.Schema({
    storeId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    code: { type: String, required: true, uppercase: true, unique: true },
    discountType: { type: String, enum: ['percentage', 'fixed'], default: 'percentage' },
    discountValue: { type: Number, required: true }, // 10 for 10% or 10 for $10
    minPurchase: { type: Number, default: 0 },
    maxDiscount: { type: Number }, // أقصى خصم للمنتجات
    validFrom: { type: Date, default: Date.now },
    validUntil: { type: Date },
    usageLimit: { type: Number }, // عدد مرات الاستخدام
    usageCount: { type: Number, default: 0 },
    applicableProducts: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Product' }], // empty = all products
    isActive: { type: Boolean, default: true },
    createdAt: { type: Date, default: Date.now }
});

const Coupon = mongoose.model('Coupon', couponSchema);

// ============================================
// 📦 Platform Bank Model
// ============================================
const platformBankSchema = new mongoose.Schema({
    bankName: { type: String, required: true },
    accountName: { type: String, required: true },
    accountNumber: { type: String, required: true },
    iban: { type: String },
    swiftCode: { type: String },
    isActive: { type: Boolean, default: true },
    order: { type: Number, default: 0 },
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

const PlatformBank = mongoose.model('PlatformBank', platformBankSchema);

const storeFollowSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true }, // المتابع
    storeId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true }, // صاحب المتجر
    createdAt: { type: Date, default: Date.now }
});

storeFollowSchema.index({ userId: 1, storeId: 1 }, { unique: true });

const StoreFollow = mongoose.model('StoreFollow', storeFollowSchema);



// 5. نموذج عربة التسوق
const cartSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, unique: true },
    stores: {
        type: Map,
        of: new mongoose.Schema({
            storeId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
            storeName: { type: String, default: '' },
            storeLogo: { type: String, default: '' },
            items: [{
                productId: { type: mongoose.Schema.Types.ObjectId, ref: 'Product' },
                title: { type: String, required: true },
                price: { type: Number, required: true },
                quantity: { type: Number, default: 1, min: 1, max: 99 },
                image: { type: String, default: '/assets/img/default-product.png' },
                productType: { type: String, enum: ['digital', 'project', 'service'], default: 'digital' }
            }],
            subtotal: { type: Number, default: 0 },
            itemCount: { type: Number, default: 0 },
            createdAt: { type: Date, default: Date.now },
            updatedAt: { type: Date, default: Date.now }
        }),
        default: {}
    },
    totalItems: { type: Number, default: 0 },
    totalStores: { type: Number, default: 0 },
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

cartSchema.methods.calculateTotals = function() {
    let totalItems = 0;
    let totalStores = 0;
    for (let [storeId, storeData] of this.stores) {
        let storeTotal = 0;
        let storeItemCount = 0;
        for (const item of storeData.items) {
            storeTotal += item.price * item.quantity;
            storeItemCount += item.quantity;
        }
        storeData.subtotal = storeTotal;
        storeData.itemCount = storeItemCount;
        storeData.updatedAt = new Date();
        this.stores.set(storeId, storeData);
        totalItems += storeItemCount;
        totalStores++;
    }
    this.totalItems = totalItems;
    this.totalStores = totalStores;
    this.updatedAt = new Date();
};

const Cart = mongoose.model('Cart', cartSchema);

// Schema for layout presets (if not exists, create model)
const layoutPresetSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    name: { type: String, required: true },
    sectionOrder: [{ type: mongoose.Schema.Types.Mixed }],
    theme: {
        primaryColor: { type: String, default: '#3b82f6' },
        fontFamily: { type: String, default: 'Inter' }
    },
    createdAt: { type: Date, default: Date.now }
});

const LayoutPreset = mongoose.models.LayoutPreset || mongoose.model('LayoutPreset', layoutPresetSchema);




const userSchema = new mongoose.Schema({
    username: { type: String, sparse: true },
    email: { type: String, required: true },
    password: { type: String },
    isAdmin: { type: Boolean, default: false },
    googleId: String,
    googleAccessToken: String,
    projectProgress: { type: mongoose.Schema.Types.Mixed, default: {} },
    googleRefreshToken: String,
    facebookId: String,
    facebookAccessToken: String,
    facebookRefreshToken: String,
    githubId: String,
    githubAccessToken: String,
    githubRefreshToken: String,
    mgzonId: String,
    mgzonAccessToken: String,
    mgzonRefreshToken: String,
    emailVerified: { type: Boolean, default: false },
    otp: String,
    otpExpires: Date,
    refreshTokens: [{ token: String, createdAt: { type: Date, default: Date.now } }],
    notifications: [{
        message: { type: String, required: true },
        type: { type: String, enum: ['info', 'warning', 'success', 'admin_report', 'admin_info', 'warning', 'report'], default: 'info' },
        link: { type: String, default: '' },
        read: { type: Boolean, default: false },
        createdAt: { type: Date, default: Date.now },
        metadata: { type: mongoose.Schema.Types.Mixed, default: {} }
    }],

    profile: {
        type: mongoose.Schema.Types.Mixed,
        default: {
            gender: { type: String, enum: ['male', 'female', 'other'], default: 'male' },
            showGender: { type: Boolean, default: false },

            storeEnabled: { type: Boolean, default: false },


            badges: {
                type: {
                    // 🥇 برونزيات المشاهدات (Profile Views)
                    views: {
                        silver: { type: Boolean, default: false },   // 20 مشاهدة
                        gold: { type: Boolean, default: false },     // 100 مشاهدة
                        red: { type: Boolean, default: false },      // 200 مشاهدة
                    },
                    // ❤️ برونزيات الإعجابات (Post Likes)
                    likes: {
                        bronze: { type: Boolean, default: false },   // 10 إعجابات
                        red: { type: Boolean, default: false },      // 128 إعجاب
                        silver: { type: Boolean, default: false },   // 512 إعجاب
                        gold: { type: Boolean, default: false },     // 4096 إعجاب
                    },
                    
                    // 💬 برونزيات التفاعل (Comments/Replies)
                    interaction: {
                        bronze: { type: Boolean, default: false },   // 10 ردود
                    },
                    ratings: { 
                        bronze: { type: Boolean, default: false },
                        silver: { type: Boolean, default: false },
                        gold: { type: Boolean, default: false },
                        platinum: { type: Boolean, default: false }
                    },
                    unlockedAt: { type: Date, default: null },
                    updatedAt: { type: Date, default: Date.now }
                },
                default: {
                    views: { silver: false, gold: false, red: false },
                    likes: { bronze: false, silver: false, gold: false, red: false },
                    interaction: { bronze: false },
                    unlockedAt: null,
                    ratings: { bronze: false, silver: false, gold: false, platinum: false },
                    updatedAt: Date.now
                }
            },

            // ✅ إعدادات إظهار/إخفاء الأقسام
            sectionVisibility: {
                about: true,
                experience: true,
                education: true,
                certificates: true,
                skills: true,
                projects: true,
                interests: true,
                contactInfo: true,
                socialLinks: true,
                stats: true,
                activity: true,
                contributionGraph: true,
                alsoViewed: true,
                suggestions: true,
                pages: true,
                jobApplications: true,
                analytics: true
            },
            sectionOrder: [],  
            // ✅ الأقسام المخصصة (Custom Sections)
            customSections: {
                type: [{
                    _id: { type: mongoose.Schema.Types.ObjectId, default: () => new mongoose.Types.ObjectId() },
                    name: { type: String, required: true },
                    type: { type: String, enum: ['text', 'skills', 'links'], default: 'text' },
                    content: { type: mongoose.Schema.Types.Mixed, default: {} },
                    isVisible: { type: Boolean, default: true },

                    settings: {
                        // Style settings
                        fontSize: { type: String, enum: ['xs', 'sm', 'base', 'lg', 'xl', '2xl'], default: 'base' },
                        textColor: { type: String, default: '' },
                        backgroundColor: { type: String, default: '' },
                        textAlign: { type: String, enum: ['left', 'center', 'right'], default: 'left' },
                        padding: { type: String, enum: ['sm', 'md', 'lg'], default: 'md' },
                        borderRadius: { type: String, enum: ['none', 'sm', 'md', 'lg', 'xl'], default: 'md' },
                        shadow: { type: String, enum: ['none', 'sm', 'md', 'lg', 'xl'], default: 'none' },
                        animation: { type: String, enum: ['none', 'fade-up', 'fade-down', 'zoom-in', 'slide-left', 'slide-right'], default: 'none' },
                        icon: { type: String, default: '' },
                        
                        // Layout settings
                        columns: { type: Number, min: 1, max: 4, default: 1 },
                        showDivider: { type: Boolean, default: true },
                        dividerColor: { type: String, default: '' },
                        
                        // Advanced
                        customClass: { type: String, default: '' },
                        customCss: { type: String, default: '' }
                    },
                    createdAt: { type: Date, default: Date.now },
                    updatedAt: { type: Date, default: Date.now }
                }],
                default: []
            },

            designSettings: {
                primaryColor: { type: String, default: '#3b82f6' },
                secondaryColor: { type: String, default: '#8b5cf6' },
                fontFamily: { type: String, default: 'Inter, sans-serif' },
                borderRadius: { type: Number, default: 16 },
                zoomLevel: { type: Number, default: 100 },
                shadowType: { type: String, default: 'md' },
                animationType: { type: String, default: 'none' },
                glassEffect: { type: Boolean, default: false },
                backgroundType: { type: String, default: 'default' }, // default, dots, grid, cross, gradient, image
                backgroundValue: { type: String, default: '' },
                customCss: { type: String, default: '' }
            },

            // ✅ إضافة إعدادات شكل لكل قسم
            sectionStyleSettings: {},

            sectionNames: {
                type: mongoose.Schema.Types.Mixed,
                default: {
                    about: 'About / Bio',
                    experience: 'Experience',
                    education: 'Education',
                    certificates: 'Licenses & certificates',
                    skills: 'Skills & expertise',
                    projects: 'Projects',
                    interests: 'Interests',
                    contactInfo: 'Contact info',
                    activity: 'Activity',
                    contributionGraph: 'Contribution Graph',
                    alsoViewed: 'Who viewed also viewed',
                    suggestions: 'People you may know',
                    pages: 'You might like',
                    analytics: 'Analytics',
                    jobApplications: 'Job Applications'
                }
            },
            // ✅ إعدادات AI Bot (جوه الـ default)
            aiBot: {
                enabled: false,                                    // هل البوت مفعل؟
                provider: 'mgzon',                                 // mgzon ولا custom
                customApiKey: '',                                  // مفتاح HuggingFace الخاص
                customModel: 'Qwen/Qwen2.5-7B-Instruct',           // الموديل المخصص
                temperature: 0.7,                                  // إبداعية الردود (0-1)
                maxTokens: 400,                                    // أقصى طول للرد
                systemPrompt: '',                                  // برومبت مخصص
                totalQueries: 0,                                   // عدد الأسئلة المستلمة
                lastQueryAt: null                                  // آخر سؤال
            },
            
        }
    },

    interactionsSettings: {
        type: {
            showToPublic: { type: Boolean, default: true },
            showToLoggedIn: { type: Boolean, default: true },
            showOnlyToOwner: { type: Boolean, default: false },
            showToSpecificUsers: [{ type: String }],
            hideProjects: [{ type: Number }],
            hideComments: [{ type: mongoose.Schema.Types.ObjectId }]
        },
        default: {
            showToPublic: true,
            showToLoggedIn: true,
            showOnlyToOwner: false,
            showToSpecificUsers: [],
            hideProjects: [],
            hideComments: []
        }
    }
}, {
    minimize: false,
});

// userSchema.index({ username: 1 }, { unique: true, sparse: true });

// userSchema.index({ 'profile.nickname': 1 }, { unique: true, sparse: true });

userSchema.index({ email: 1 }, { unique: true });
const User = mongoose.model('User', userSchema);



// Product indexes
productSchema.index({ salesCount: -1 });
productSchema.index({ createdAt: -1 });

// Order indexes
orderSchema.index({ buyerId: 1, createdAt: -1 });
orderSchema.index({ sellerId: 1, createdAt: -1 });
orderSchema.index({ orderNumber: 1 });
orderSchema.index({ status: 1, createdAt: -1 });

// Coupon indexes
couponSchema.index({ storeId: 1, code: 1 });
couponSchema.index({ validUntil: 1 });

// StoreFollow indexes
storeFollowSchema.index({ storeId: 1 });



// ============================================
// AI Conversations Schema - لتسجيل محادثات البوت
// ============================================
const aiConversationSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    visitorIp: { type: String, default: '' },
    question: { type: String, required: true },
    answer: { type: String, required: true },
    provider: { type: String, enum: ['mgzon', 'custom'], default: 'mgzon' },
    language: { type: String, default: 'ar' },
    responseTime: { type: Number, default: 0 }, // وقت الاستجابة بالمللي ثانية
    timestamp: { type: Date, default: Date.now }
});

aiConversationSchema.index({ userId: 1, timestamp: -1 });
aiConversationSchema.index({ userId: 1, provider: 1 });

const AIConversation = mongoose.model('AIConversation', aiConversationSchema);


const skillSchema = new mongoose.Schema({
    name: { type: String, required: true },
    icon: { type: String, required: true },
    percentage: { type: Number, required: true },
});
const Skill = mongoose.model('Skill', skillSchema);

const conversationSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
    messages: [{ role: String, content: String, timestamp: { type: Date, default: Date.now } }],

        participants: [{
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    }],
    lastMessage: {
        text: String,
        senderId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        readBy: [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }],
        createdAt: { type: Date, default: Date.now }
    },
    unreadCount: {
        type: Map,
        of: Number,
        default: {}
    },
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }

});


conversationSchema.index({ participants: 1 });
conversationSchema.index({ updatedAt: -1 });

const Conversation = mongoose.model('Conversation', conversationSchema);




const messageSchema = new mongoose.Schema({
    conversationId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'Conversation',
        required: true
    },
    senderId: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    },
    text: {
        type: String,
        required: true,
        maxlength: 5000
    },
    attachments: [{
        type: { type: String, enum: ['image', 'file', 'audio'], default: 'image' },
        url: String,
        publicId: String,
        name: String,
        size: Number
    }],
    readBy: [{
        userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        readAt: { type: Date, default: Date.now }
    }],
    reactions: {
        type: Map,
        of: [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }],
        default: {}
    },
    isPinned: { type: Boolean, default: false },
    pinnedAt: { type: Date },
    isForwarded: { type: Boolean, default: false },
    originalMessageId: { type: mongoose.Schema.Types.ObjectId, ref: 'Message' },
    hidden: { type: Boolean, default: false },

    isDeleted: { type: Boolean, default: false },
    deletedFor: [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }],
    replyTo: { type: mongoose.Schema.Types.ObjectId, ref: 'Message' },
    createdAt: { type: Date, default: Date.now }
});

messageSchema.index({ conversationId: 1, createdAt: -1 });

const Message = mongoose.model('Message', messageSchema);



// ============================================
// Rating System Schema - تقييم المستخدمين
// ============================================
const ratingSchema = new mongoose.Schema({
    targetUserId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true }, // المستخدم المقيم
    raterUserId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },   // المستخدم الذي قام بالتقييم
    rating: { type: Number, required: true, min: 1, max: 5 },
    review: { type: String, maxlength: 500 },
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

// منع التقييم المتكرر من نفس المستخدم لنفس الشخص
ratingSchema.index({ targetUserId: 1, raterUserId: 1 }, { unique: true });

const Rating = mongoose.model('Rating', ratingSchema);

// ============================================
// Profile Analytics Schema - تحليلات الملف الشخصي
// ============================================
const profileAnalyticsSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, unique: true },
    profileViews: [{ 
        viewerId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
        viewerIp: String,
        viewedAt: { type: Date, default: Date.now }
    }],
    postImpressions: [{ 
        postId: { type: mongoose.Schema.Types.ObjectId, ref: 'Post' },
        viewedAt: { type: Date, default: Date.now }
    }],
    searchAppearances: [{ 
        searchQuery: String,
        appearedAt: { type: Date, default: Date.now }
    }],
    lastUpdated: { type: Date, default: Date.now }
});

profileAnalyticsSchema.index({ userId: 1 });
profileAnalyticsSchema.index({ 'profileViews.viewedAt': -1 });

const ProfileAnalytics = mongoose.model('ProfileAnalytics', profileAnalyticsSchema);

// ============================================
// Also Viewed Schema - محدث مع دعم الزوار
// ============================================
const alsoViewedSchema = new mongoose.Schema({
    targetUserId: { 
        type: mongoose.Schema.Types.ObjectId, 
        ref: 'User', 
        required: true 
    },
    viewerId: { 
        type: mongoose.Schema.Types.ObjectId, 
        ref: 'User', 
        default: null 
    },
    viewerIp: { 
        type: String, 
        default: null 
    },
    viewedAt: { 
        type: Date, 
        default: Date.now 
    }
});

// ✅ فهارس محسنة (من غير تكرار)
alsoViewedSchema.index({ targetUserId: 1, viewerId: 1 }, { 
    unique: true, 
    sparse: true,
    partialFilterExpression: { viewerId: { $ne: null } }  // ✅ فقط للمستخدمين المسجلين
});

// ✅ للزوار (IP) - من غير unique عشان الزوار الكتير
alsoViewedSchema.index({ targetUserId: 1, viewerIp: 1, viewedAt: -1 });

// ✅ للأقدمية
alsoViewedSchema.index({ targetUserId: 1, viewedAt: -1 });

const AlsoViewed = mongoose.model('AlsoViewed', alsoViewedSchema);

// ============================================
// Page Suggestions Schema - اقتراحات الصفحات
// ============================================
const pageSuggestionSchema = new mongoose.Schema({
    name: { type: String, required: true },
    nameAr: String,
    description: String,
    logo: { type: String, default: '/assets/img/default-page.png' },
    url: { type: String, required: true },
    category: { type: String, enum: ['technology', 'education', 'business', 'design', 'marketing', 'other'], default: 'other' },
    followers: [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }],
    isActive: { type: Boolean, default: true },
    createdAt: { type: Date, default: Date.now }
});

const PageSuggestion = mongoose.model('PageSuggestion', pageSuggestionSchema);



// ============================================
// UNIFIED USERS ENDPOINTS - البحث في كل الموديلات
// ============================================

// ============================================
// GET /api/users/search - بحث عام عن المستخدمين (بدون userId إجباري)
// ============================================
app.get('/api/users/search', async (req, res) => {
    try {
        const { 
            query = '', 
            page = 1, 
            limit = 20,
            category = '',
            skill = ''
        } = req.query;
        
        // ✅ البحث بـ 2 حروف أو أكثر فقط
        if (!query || query.length < 2) {
            return res.status(400).json({ error: 'Search query must be at least 2 characters' });
        }
        
        const skip = (parseInt(page) - 1) * parseInt(limit);
        const limitNum = parseInt(limit);
        
        // ✅ بناء query البحث الرئيسي (من غير شرط userId)
        let searchQuery = {
            $or: [
                { 'profile.nickname': { $regex: query, $options: 'i' } },
                { username: { $regex: query, $options: 'i' } },
                { 'profile.jobTitle': { $regex: query, $options: 'i' } },
                { 'profile.bio': { $regex: query, $options: 'i' } },
                { 'profile.skills.name': { $regex: query, $options: 'i' } }
            ]
        };
        
        // ✅ إضافة فلتر المجال (category)
        if (category && category !== 'all' && category !== '') {
            const categoryMap = {
                'technology': ['Technology', 'Software', 'Development', 'Programming', 'IT', 'Tech'],
                'design': ['Design', 'UI/UX', 'Graphic Design', 'Product Design'],
                'marketing': ['Marketing', 'Digital Marketing', 'SEO', 'Social Media'],
                'business': ['Business', 'Management', 'Sales', 'Finance', 'Consulting'],
                'education': ['Education', 'Teaching', 'Training', 'Instruction']
            };
            
            const keywords = categoryMap[category] || [category];
            const categoryRegex = keywords.map(k => new RegExp(k, 'i'));
            searchQuery['profile.jobTitle'] = { $in: categoryRegex };
        }
        
        // ✅ إضافة فلتر المهارة (skill)
        if (skill && skill !== 'all' && skill !== '') {
            searchQuery['profile.skills.name'] = { $regex: skill, $options: 'i' };
        }
        
        // ✅ تنفيذ البحث
        const users = await User.find(searchQuery)
            .select('username profile email createdAt')
            .skip(skip)
            .limit(limitNum)
            .lean();
        
        // ✅ جلب الـ current user ID من التوكن (للمتابعة فقط - مش إجباري)
        const authHeader = req.headers['authorization'];
        let currentUserId = null;
        let followingIds = new Set();
        
        if (authHeader) {
            try {
                const token = authHeader.split(' ')[1];
                const payload = jwt.verify(token, JWT_SECRET);
                currentUserId = payload.userId;
                
                const following = await Follow.find({ 
                    followerId: currentUserId, 
                    status: 'accepted' 
                }).select('followingId');
                followingIds = new Set(following.map(f => f.followingId.toString()));
            } catch (e) {
                // مستخدم غير مسجل أو توكن غير صالح - نكمل عادي
                console.log('User not logged in or invalid token');
            }
        }
        
        // ✅ تجميع البيانات من عدة موديلات
        const usersWithStats = await Promise.all(users.map(async (user) => {
            const [
                postsCount,
                projectsCount,
                jobsCount,
                followersCount,
                followingCount
            ] = await Promise.all([
                Post.countDocuments({ userId: user._id }),
                Project.countDocuments({ userId: user._id, isPublic: true }),
                Job.countDocuments({ employerId: user._id, status: 'active' }),
                Follow.countDocuments({ followingId: user._id, status: 'accepted' }),
                Follow.countDocuments({ followerId: user._id, status: 'accepted' })
            ]);
            
            return {
                _id: user._id,
                username: user.username,
                email: user.email,
                profile: {
                    nickname: user.profile?.nickname || user.username,
                    avatar: user.profile?.avatar || '/assets/img/default-avatar.png',
                    jobTitle: user.profile?.jobTitle || 'Professional',
                    bio: user.profile?.bio || 'No bio available',
                    skills: user.profile?.skills || []
                },
                stats: {
                    posts: postsCount,
                    projects: projectsCount,
                    jobs: jobsCount,
                    followers: followersCount,
                    following: followingCount
                },
                isFollowing: followingIds.has(user._id.toString()),
                joinedAt: user.createdAt
            };
        }));
        
        const total = await User.countDocuments(searchQuery);
        
        res.json({
            success: true,
            data: usersWithStats,
            pagination: {
                page: parseInt(page),
                limit: limitNum,
                total: total,
                pages: Math.ceil(total / limitNum),
                hasNext: skip + limitNum < total,
                hasPrev: parseInt(page) > 1
            }
        });
        
    } catch (error) {
        console.error(`Error searching users: ${error.message}`);
        res.status(500).json({ error: 'Failed to search users' });
    }
});


// ============================================
// 🛒 STORE SEARCH API ENDPOINTS
// ============================================




// ============================================
// GET /api/store/search - Global Optimized Search with Instant-ready
// ============================================
app.get('/api/store/search', async (req, res) => {
    try {
        const { q, limit = 5 } = req.query;
        const search = (q || '').trim();
        const lim = Math.min(parseInt(limit), 20); // الحد الأقصى 20 لكل قسم

        if (search.length < 2) {
            return res.json({
                success: true,
                products: [],
                stores: [],
                users: [],
                jobs: [],
                posts: [],
                total: { products: 0, stores: 0, users: 0, jobs: 0, posts: 0 }
            });
        }

        const regex = new RegExp(search, 'i');

        // ============================================
        // PROMISES
        // ============================================
        const productsPromise = Product.find({
            isActive: true,
            $or: [
                { title: regex },
                { description: regex },
                { tags: regex }
            ]
        })
        .limit(lim)
        .select('title price type images userId')
        .populate('userId', 'username profile.nickname')
        .lean();

        const storesPromise = StoreSettings.find({
            enabled: true,
            $or: [
                { storeName: regex },
                { storeDescription: regex }
            ]
        })
        .limit(lim)
        .populate('userId', 'username profile.nickname profile.avatar')
        .lean();

        const usersPromise = User.find({
            $or: [
                { username: regex },
                { 'profile.nickname': regex },
                { 'profile.jobTitle': regex },
                { 'profile.skills.name': regex },
                { 'profile.bio': regex }
            ]
        })
        .limit(lim)
        .select('username profile.nickname profile.avatar profile.jobTitle profile.bio')
        .lean();

        const jobsPromise = Job.find({
            status: 'active',
            $or: [
                { title: regex },
                { description: regex },
                { companyName: regex },
                { requiredSkills: regex }
            ]
        })
        .limit(lim)
        .select('title companyName location jobType salaryMin salaryMax isRemote')
        .lean();

        const postsPromise = Post.find({
            visibility: 'public',
            $or: [
                { content: regex },
                { tags: regex }
            ]
        })
        .limit(lim)
        .select('content images userId createdAt likes')
        .populate('userId', 'username profile.nickname profile.avatar')
        .sort({ createdAt: -1 })
        .lean();

        // ============================================
        // EXECUTE IN PARALLEL
        // ============================================
        const [products, stores, users, jobs, posts] = await Promise.all([
            productsPromise,
            storesPromise,
            usersPromise,
            jobsPromise,
            postsPromise
        ]);

        // ============================================
        // FORMAT DATA
        // ============================================
        const formattedProducts = products.map(p => ({
            _id: p._id,
            title: p.title,
            price: p.price,
            type: p.type,
            image: p.images?.[0] || null,
            storeNickname: p.userId?.profile?.nickname || p.userId?.username,
            url: `/product.html?id=${p._id}&owner=${p.userId?.profile?.nickname || p.userId?.username}`
        }));

        const formattedStores = stores.map(s => ({
            _id: s._id,
            storeName: s.storeName || s.userId?.profile?.nickname || s.userId?.username,
            storeLogo: s.storeLogo || null,
            nickname: s.userId?.profile?.nickname || s.userId?.username,
            productsCount: s.productsCount || 0,
            followersCount: s.followersCount || 0,
            averageRating: s.averageRating || 0,
            url: `/shop/${s.userId?.profile?.nickname || s.userId?.username}`
        }));

        const formattedUsers = users.map(u => ({
            _id: u._id,
            name: u.profile?.nickname || u.username,
            avatar: u.profile?.avatar || '/assets/img/default-avatar.png',
            jobTitle: u.profile?.jobTitle || 'Professional',
            bio: u.profile?.bio?.substring(0, 100) || '',
            url: `/profile/${u.profile?.nickname || u.username}`
        }));

        const formattedJobs = jobs.map(j => ({
            _id: j._id,
            title: j.title,
            company: j.companyName,
            location: j.location,
            jobType: j.jobType,
            isRemote: j.isRemote || false,
            salary: j.salaryMin ? `${j.salaryMin} - ${j.salaryMax}` : null,
            url: `/job-details.html?id=${j._id}`
        }));

        const formattedPosts = posts.map(p => ({
            _id: p._id,
            content: p.content?.slice(0, 150) + (p.content?.length > 150 ? '...' : ''),
            image: p.images?.[0]?.url || null,
            author: {
                name: p.userId?.profile?.nickname || p.userId?.username,
                avatar: p.userId?.profile?.avatar || '/assets/img/default-avatar.png'
            },
            likesCount: p.likes?.length || 0,
            createdAt: p.createdAt,
            url: `/post.html?id=${p._id}`
        }));

        // ============================================
        // RESPONSE
        // ============================================
        res.json({
            success: true,
            products: formattedProducts,
            stores: formattedStores,
            users: formattedUsers,
            jobs: formattedJobs,
            posts: formattedPosts,
            total: {
                products: formattedProducts.length,
                stores: formattedStores.length,
                users: formattedUsers.length,
                jobs: formattedJobs.length,
                posts: formattedPosts.length
            }
        });

    } catch (error) {
        console.error('Global search error:', error);
        res.status(500).json({ error: 'Failed to search' });
    }
});

// ============================================
// GET /api/store/search/products - بحث المنتجات
// ============================================
app.get('/api/store/search/products', async (req, res) => {
    try {
        const { q, type, priceRange, page = 1, limit = 12 } = req.query;
        
        // بناء query البحث
        let query = { isActive: true };
        
        // بحث بنص المنتج
        if (q && q.trim().length > 0) {
            query.$or = [
                { title: { $regex: q, $options: 'i' } },
                { description: { $regex: q, $options: 'i' } },
                { tags: { $in: [new RegExp(q, 'i')] } }
            ];
        }
        
        // فلتر حسب نوع المنتج (digital, project, service)
        if (type && type !== 'all') {
            query.type = type;
        }
        
        // فلتر حسب السعر
        if (priceRange && priceRange !== '') {
            if (priceRange === '0-10') {
                query.price = { $gte: 0, $lte: 10 };
            } else if (priceRange === '10-25') {
                query.price = { $gte: 10, $lte: 25 };
            } else if (priceRange === '25-50') {
                query.price = { $gte: 25, $lte: 50 };
            } else if (priceRange === '50-100') {
                query.price = { $gte: 50, $lte: 100 };
            } else if (priceRange === '100+') {
                query.price = { $gte: 100 };
            }
        }
        
        // حساب pagination
        const skip = (parseInt(page) - 1) * parseInt(limit);
        const total = await Product.countDocuments(query);
        
        // جلب المنتجات مع بيانات البائع
        const products = await Product.find(query)
            .populate('userId', 'username profile.nickname profile.avatar storeName')
            .sort({ createdAt: -1 })
            .skip(skip)
            .limit(parseInt(limit));
        
        // تنسيق البيانات للـ frontend
        const formattedProducts = products.map(product => {
            // حساب متوسط التقييم
            let averageRating = 0;
            if (product.reviews && product.reviews.length > 0) {
                const sum = product.reviews.reduce((acc, review) => acc + review.rating, 0);
                averageRating = sum / product.reviews.length;
            }
            
            return {
                _id: product._id,
                title: product.title,
                description: product.description,
                price: product.price,
                type: product.type,
                images: product.images || [],
                tags: product.tags || [],
                salesCount: product.salesCount || 0,
                reviews: product.reviews || [],
                averageRating: averageRating,
                currencySymbol: product.currencySymbol || '$',
                storeNickname: product.userId?.profile?.nickname || product.userId?.username,
                seller: {
                    id: product.userId?._id,
                    nickname: product.userId?.profile?.nickname || product.userId?.username,
                    avatar: product.userId?.profile?.avatar
                },
                createdAt: product.createdAt,
                updatedAt: product.updatedAt
            };
        });
        
        res.json({
            success: true,
            products: formattedProducts,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total: total,
                pages: Math.ceil(total / limit)
            }
        });
        
    } catch (error) {
        console.error('Error searching products:', error);
        res.status(500).json({ error: 'Failed to search products' });
    }
});

// ============================================
// GET /api/store/search/stores - Optimized Fast Search
// ============================================
app.get('/api/store/search/stores', async (req, res) => {
    try {
        const { q, sort, page = 1, limit = 12 } = req.query;

        // 🔥 1. Build query
        const query = { enabled: true };

        if (q && q.trim()) {
            query.$or = [
                { storeName: { $regex: q.trim(), $options: 'i' } },
                { storeDescription: { $regex: q.trim(), $options: 'i' } }
            ];
        }

        // 🔥 2. Pagination
        const pageNum = parseInt(page);
        const limitNum = parseInt(limit);
        const skip = (pageNum - 1) * limitNum;

        // 🔥 3. Base query
        let storesQuery = StoreSettings.find(query)
            .populate('userId', 'username profile.nickname profile.avatar');

        // 🔥 4. Sorting (ONLY cached fields)
        switch (sort) {
            case 'top-rated':
                storesQuery.sort({ averageRating: -1 });
                break;

            case 'most-products':
                storesQuery.sort({ productsCount: -1 });
                break;

            case 'newest':
                storesQuery.sort({ createdAt: -1 });
                break;

            default:
                storesQuery.sort({ storeName: 1 });
        }

        // 🔥 5. Execute query
        const stores = await storesQuery
            .skip(skip)
            .limit(limitNum)
            .lean();

        const total = await StoreSettings.countDocuments(query);

        // 🔥 6. Response (NO calculations at all)
        const result = stores.map(store => ({
            _id: store._id,
            userId: store.userId?._id,

            storeName: store.storeName || store.userId?.profile?.nickname || store.userId?.username,
            storeLogo: store.storeLogo || null,
            storeBanner: store.storeBanner || null,
            storeDescription: store.storeDescription || '',

            nickname: store.userId?.profile?.nickname || store.userId?.username,
            username: store.userId?.username,
            avatar: store.userId?.profile?.avatar,

            // ⚡ cached values only
            productsCount: store.productsCount || 0,
            followersCount: store.followersCount || 0,
            averageRating: Number((store.averageRating || 0).toFixed(1)),

            enabled: store.enabled,
            createdAt: store.createdAt,
            updatedAt: store.updatedAt
        }));

        // 🔥 7. Response
        res.json({
            success: true,
            stores: result,
            pagination: {
                page: pageNum,
                limit: limitNum,
                total,
                pages: Math.ceil(total / limitNum),
                hasNext: skip + limitNum < total,
                hasPrev: pageNum > 1
            }
        });

    } catch (error) {
        console.error('Error searching stores:', error);
        res.status(500).json({ error: 'Failed to search stores' });
    }
});

// ============================================

// GET /api/profile/project-progress
app.get('/api/profile/project-progress', authenticateToken, async (req, res) => {
    const { project } = req.query;
    const user = await User.findById(req.user.userId);
    const projects = user.profile?.projectProgress || {};
    res.json(projects[project] || {});
});

// POST /api/profile/project-progress  
app.post('/api/profile/project-progress', authenticateToken, async (req, res) => {
    const { projectName, ...data } = req.body;
    const user = await User.findById(req.user.userId);
    if (!user.profile) user.profile = {};
    if (!user.profile.projectProgress) user.profile.projectProgress = {};
    user.profile.projectProgress[projectName] = data;
    await user.save();
    res.json({ success: true });
});


// MGZon Strategy
passport.use(new MGZonStrategy({
    clientID: process.env.MGZON_CLIENT_ID,
    clientSecret: process.env.MGZON_CLIENT_SECRET,
    callbackURL: `${process.env.BASE_URL}/auth/mgz/callback`,
    scope: ['profile:read', 'profile:write'],
    passReqToCallback: true
}, async (req, accessToken, refreshToken, profile, done) => {
    try {
        // البحث عن المستخدم باستخدام البريد الإلكتروني أولاً
        let user = await User.findOne({ email: profile.email });
        
        if (user) {
            // إذا وُجد، قم بتحديث معلومات MGZon الخاصة به
            logger.info(`User found with email ${user.email}. Updating MGZon ID and tokens.`);
            user.mgzonId = profile.id;
            user.mgzonAccessToken = accessToken;
            if (refreshToken) user.mgzonRefreshToken = refreshToken;
            await user.save();
            return done(null, user);
        } else {
            // إذا لم يُوجد، قم بإنشاء مستخدم جديد
            logger.info(`No user found for email ${profile.email}. Creating new user.`);
            user = await User.create({
                mgzonId: profile.id,
                email: profile.email,
                username: profile.name,
                mgzonAccessToken: accessToken,
                mgzonRefreshToken: refreshToken,
                profile: { nickname: profile.nickname || profile.email.split('@')[0] }
            });
            return done(null, user);
        }
    } catch (error) {
        logger.error(`MGZon strategy error: ${error.message}`);
        return done(error, null);
    }
}));


passport.use(new GoogleStrategy({
    clientID: GOOGLE_CLIENT_ID,
    clientSecret: GOOGLE_CLIENT_SECRET,
    callbackURL: `${process.env.BASE_URL}/auth/google/callback`,
    scope: ['profile', 'email'],
    passReqToCallback: true
}, async (req, accessToken, refreshToken, profile, done) => {
    try {
        // البحث عن المستخدم باستخدام البريد الإلكتروني أولاً
        let user = await User.findOne({ email: profile.emails[0].value });
        
        if (user) {
            // إذا وُجد، قم بتحديث معلومات Google الخاصة به
            logger.info(`User found with email ${user.email}. Updating Google ID and tokens.`);
            user.googleId = profile.id;
            user.googleAccessToken = accessToken;
            if (refreshToken) user.googleRefreshToken = refreshToken;
            await user.save();
            return done(null, user);
        } else {
            // إذا لم يُوجد، قم بإنشاء مستخدم جديد
            logger.info(`No user found for email ${profile.emails[0].value}. Creating new user.`);
            user = await User.create({
                googleId: profile.id,
                email: profile.emails[0].value,
                username: profile.displayName,
                googleAccessToken: accessToken,
                googleRefreshToken: refreshToken
            });
            return done(null, user);
        }
    } catch (error) {
        logger.error(`Google strategy error: ${error.message}`);
        return done(error, null);
    }
}));


passport.use(new FacebookStrategy({
    clientID: FACEBOOK_CLIENT_ID,
    clientSecret: FACEBOOK_CLIENT_SECRET,
    callbackURL: `${process.env.BASE_URL}/auth/facebook/callback`,
    profileFields: ['id', 'emails', 'displayName', 'photos', 'posts', 'friends'],
    scope: ['email', 'public_profile'],
    passReqToCallback: true
}, async (req, accessToken, refreshToken, profile, done) => {
    try {
        const email = profile.emails?.[0]?.value || `${profile.id}@facebook.com`;
        // البحث عن المستخدم باستخدام البريد الإلكتروني أولاً
        let user = await User.findOne({ email: email });
        
        if (user) {
            // إذا وُجد، قم بتحديث معلومات Facebook الخاصة به
            logger.info(`User found with email ${user.email}. Updating Facebook ID and token.`);
            user.facebookId = profile.id;
            user.facebookAccessToken = accessToken;
            if (refreshToken) user.refreshTokens.push({ token: refreshToken });
            await user.save();
            return done(null, user);
        } else {
            // إذا لم يُوجد، قم بإنشاء مستخدم جديد
            logger.info(`No user found for email ${email}. Creating new user.`);
            user = await User.create({
                facebookId: profile.id,
                email: email,
                username: profile.displayName,
                facebookAccessToken: accessToken
            });
            return done(null, user);
        }
    } catch (error) {
        logger.error(`Facebook strategy error: ${error.message}`);
        return done(error, null);
    }
}));

// ============================================
// GitHub Strategy
// ============================================
passport.use(new GitHubStrategy({
    clientID: GITHUB_CLIENT_ID,
    clientSecret: GITHUB_CLIENT_SECRET,
    callbackURL: `${process.env.BASE_URL}/auth/github/callback`,
    scope: ['user:email', 'repo'],
    passReqToCallback: true
}, async (req, accessToken, refreshToken, profile, done) => {
    try {
        const email = profile.emails?.[0]?.value || `${profile.id}@github.com`;
        
        let user = await User.findOne({ email: email });
        
        if (user) {
            logger.info(`User found with email ${user.email}. Updating GitHub ID and tokens.`);
            user.githubId = profile.id;
            user.githubAccessToken = accessToken;
            user.githubUsername = profile.username;
            if (refreshToken) user.githubRefreshToken = refreshToken;
            await user.save();
            return done(null, user);
        } else {
            logger.info(`No user found for email ${email}. Creating new user.`);
            user = await User.create({
                githubId: profile.id,
                email: email,
                username: profile.displayName || profile.username,
                githubAccessToken: accessToken,
                githubUsername: profile.username,
                githubRefreshToken: refreshToken
            });
            return done(null, user);
        }
    } catch (error) {
        logger.error(`GitHub strategy error: ${error.message}`);
        return done(error, null);
    }
}));


// ============================================
// دوال مساعدة متقدمة لجلب بيانات GitHub
// ============================================

// جلب محتوى README وتحويله من Base64 (يدعم صيغ متعددة)
async function fetchReadme(owner, repo, token) {
    const readmeFiles = ['README.md', 'README.rst', 'README.txt', 'README', 'readme.md'];
    
    for (const readmeFile of readmeFiles) {
        try {
            const response = await axios.get(`https://api.github.com/repos/${owner}/${repo}/contents/${readmeFile}`, {
                headers: { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github.v3.raw' }
            });
            if (response.data) {
                // إذا كان الـ response نص عادي (raw)
                if (typeof response.data === 'string') {
                    return { content: response.data, type: readmeFile, url: `https://github.com/${owner}/${repo}/blob/master/${readmeFile}` };
                }
                // إذا كان base64
                if (response.data.content) {
                    const content = Buffer.from(response.data.content, 'base64').toString('utf-8');
                    return { content, type: readmeFile, url: response.data.html_url };
                }
            }
        } catch (error) {
            continue;
        }
    }
    return null;
}

// جلب آخر الـ Commits مع تفاصيل كاملة
async function fetchRecentCommits(owner, repo, token, limit = 10) {
    try {
        const response = await axios.get(`https://api.github.com/repos/${owner}/${repo}/commits?per_page=${limit}`, {
            headers: { Authorization: `Bearer ${token}` }
        });
        return response.data.map(commit => ({
            sha: commit.sha.substring(0, 7),
            fullSha: commit.sha,
            message: commit.commit.message.split('\n')[0],
            fullMessage: commit.commit.message,
            author: {
                name: commit.commit.author.name,
                email: commit.commit.author.email,
                date: commit.commit.author.date,
                avatar: commit.author?.avatar_url || null,
                url: commit.author?.html_url || null
            },
            url: commit.html_url,
            stats: {
                additions: commit.stats?.additions || 0,
                deletions: commit.stats?.deletions || 0,
                total: commit.stats?.total || 0
            },
            files: commit.files?.map(f => ({ filename: f.filename, status: f.status })) || []
        }));
    } catch (error) {
        return [];
    }
}

// جلب آخر إصدار (Release) مع تفاصيل
async function fetchLatestRelease(owner, repo, token) {
    try {
        const response = await axios.get(`https://api.github.com/repos/${owner}/${repo}/releases/latest`, {
            headers: { Authorization: `Bearer ${token}` }
        });
        return {
            tag: response.data.tag_name,
            name: response.data.name,
            body: response.data.body || '',
            bodyHtml: response.data.body_html || null,
            url: response.data.html_url,
            publishedAt: response.data.published_at,
            createdAt: response.data.created_at,
            assets: response.data.assets?.map(asset => ({
                name: asset.name,
                size: asset.size,
                downloadCount: asset.download_count,
                url: asset.browser_download_url
            })) || [],
            isPrerelease: response.data.prerelease,
            isDraft: response.data.draft
        };
    } catch (error) {
        return null;
    }
}

// جلب عدد المشاهدات والنسخ (للمستودعات العامة)
async function fetchTraffic(owner, repo, token) {
    try {
        const [views, clones] = await Promise.all([
            axios.get(`https://api.github.com/repos/${owner}/${repo}/traffic/views`, {
                headers: { Authorization: `Bearer ${token}` }
            }),
            axios.get(`https://api.github.com/repos/${owner}/${repo}/traffic/clones`, {
                headers: { Authorization: `Bearer ${token}` }
            })
        ]);
        return {
            views: {
                count: views.data.count || 0,
                uniques: views.data.uniques || 0,
                viewsByDay: views.data.views || []
            },
            clones: {
                count: clones.data.count || 0,
                uniques: clones.data.uniques || 0,
                clonesByDay: clones.data.clones || []
            }
        };
    } catch (error) {
        return null;
    }
}

// جلب المساهمين الرئيسيين
async function fetchContributors(owner, repo, token, limit = 10) {
    try {
        const response = await axios.get(`https://api.github.com/repos/${owner}/${repo}/contributors?per_page=${limit}`, {
            headers: { Authorization: `Bearer ${token}` }
        });
        return response.data.map(contributor => ({
            login: contributor.login,
            contributions: contributor.contributions,
            avatar: contributor.avatar_url,
            url: contributor.html_url,
            type: contributor.type
        }));
    } catch (error) {
        return [];
    }
}

// جلب الروابط الاجتماعية من package.json (للمشاريع Node.js)
async function fetchPackageJson(owner, repo, token) {
    try {
        const response = await axios.get(`https://api.github.com/repos/${owner}/${repo}/contents/package.json`, {
            headers: { Authorization: `Bearer ${token}` }
        });
        if (response.data && response.data.content) {
            const content = Buffer.from(response.data.content, 'base64').toString('utf-8');
            const pkg = JSON.parse(content);
            return {
                name: pkg.name,
                version: pkg.version,
                description: pkg.description,
                homepage: pkg.homepage || null,
                bugs: pkg.bugs?.url || null,
                funding: pkg.funding?.url || null,
                repository: pkg.repository?.url || null,
                dependencies: Object.keys(pkg.dependencies || {}).length,
                devDependencies: Object.keys(pkg.devDependencies || {}).length,
                scripts: Object.keys(pkg.scripts || {}),
                keywords: pkg.keywords || [],
                author: typeof pkg.author === 'string' ? pkg.author : pkg.author?.name,
                license: pkg.license
            };
        }
    } catch (error) {
        return null;
    }
}

// جلب الإحصائيات الأساسية للمشروع
async function fetchProjectStats(owner, repo, token) {
    try {
        const [issues, pulls, forks, stars] = await Promise.all([
            axios.get(`https://api.github.com/repos/${owner}/${repo}/issues?state=open&per_page=1&filter=all`, {
                headers: { Authorization: `Bearer ${token}` }
            }),
            axios.get(`https://api.github.com/repos/${owner}/${repo}/pulls?state=open&per_page=1`, {
                headers: { Authorization: `Bearer ${token}` }
            }),
            axios.get(`https://api.github.com/repos/${owner}/${repo}/forks?per_page=1`, {
                headers: { Authorization: `Bearer ${token}` }
            }),
            axios.get(`https://api.github.com/repos/${owner}/${repo}/stargazers?per_page=1`, {
                headers: { Authorization: `Bearer ${token}` }
            })
        ]);
        
        // استخراج العدد من الـ Link header
        const parseLinkHeader = (linkHeader) => {
            if (!linkHeader) return 0;
            const match = linkHeader.match(/&page=(\d+)>; rel="last"/);
            return match ? parseInt(match[1]) : 0;
        };
        
        return {
            openIssues: parseInt(issues.headers.link ? parseLinkHeader(issues.headers.link) : issues.data.length) || 0,
            openPulls: parseInt(pulls.headers.link ? parseLinkHeader(pulls.headers.link) : pulls.data.length) || 0,
            forksCount: parseInt(forks.headers.link ? parseLinkHeader(forks.headers.link) : forks.data.length) || 0,
            starsCount: parseInt(stars.headers.link ? parseLinkHeader(stars.headers.link) : stars.data.length) || 0
        };
    } catch (error) {
        return null;
    }
}

// جلب روابط المشروع من ملفات متعددة
async function fetchProjectLinks(owner, repo, token) {
    const links = [];
    
    // محاولة جلب روابط من README
    const readme = await fetchReadme(owner, repo, token);
    if (readme && readme.content) {
        // البحث عن روابط الـ Demo في الـ README
        const demoPatterns = [
            /(?:demo|live|website|preview):\s*\[?\]?\(?(https?:\/\/[^\s\)]+)/gi,
            /(https?:\/\/(?:[^\s]*)\.(?:vercel|netlify|heroku|github|pages|app)(?:[^\s]*))/gi
        ];
        for (const pattern of demoPatterns) {
            const matches = readme.content.matchAll(pattern);
            for (const match of matches) {
                if (match[1] && !links.find(l => l.value === match[1])) {
                    links.push({ option: 'Live Demo', value: match[1] });
                }
            }
        }
    }
    
    // محاولة جلب من package.json
    const packageJson = await fetchPackageJson(owner, repo, token);
    if (packageJson && packageJson.homepage) {
        links.push({ option: 'Website', value: packageJson.homepage });
    }
    
    return links;
}

// جلب معلومات الفرع الرئيسي والملفات
async function fetchBranchInfo(owner, repo, token) {
    try {
        const response = await axios.get(`https://api.github.com/repos/${owner}/${repo}/branches/${repo.default_branch}`, {
            headers: { Authorization: `Bearer ${token}` }
        });
        return {
            name: response.data.name,
            commit: {
                sha: response.data.commit.sha.substring(0, 7),
                url: response.data.commit.url
            },
            protected: response.data.protected || false
        };
    } catch (error) {
        return null;
    }
}

// ============================================
// GET /api/github/status - التحقق من حالة ربط GitHub
// ============================================
app.get('/api/github/status', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId).select('githubAccessToken githubUsername');
        res.json({
            connected: !!user?.githubAccessToken,
            githubUsername: user?.githubUsername || null
        });
    } catch (error) {
        logger.error(`Error checking GitHub status: ${error.message}`);
        res.status(500).json({ error: 'Failed to check GitHub status' });
    }
});

// ============================================
// POST /api/github/import-repo - استيراد مستودع متقدم (ذكي)
// ============================================
app.post('/api/github/import-repo', authenticateToken, async (req, res) => {
    const { repoId, repoName, repoFullName, repoDescription, repoUrl } = req.body;
    
    try {
        const user = await User.findById(req.user.userId);
        if (!user.githubAccessToken) {
            return res.status(400).json({ error: 'GitHub account not linked' });
        }

        // ✅ 1. جلب كامل تفاصيل الـ Repository
        const repoResponse = await axios.get(`https://api.github.com/repositories/${repoId}`, {
            headers: { 
                Authorization: `Bearer ${user.githubAccessToken}`,
                'User-Agent': 'MGZon-App',
                'Accept': 'application/vnd.github.v3+json'
            }
        });
        
        const repo = repoResponse.data;
        const [owner, repoNameOnly] = repo.full_name.split('/');

        // ✅ 2. جلب README الكامل (بدون قطع)
        const readmeData = await fetchReadme(owner, repoNameOnly, user.githubAccessToken);
        
        // ✅ 3. جلب اللغات بالتفصيل مع النسب المئوية
        const languagesResponse = await axios.get(repo.languages_url, {
            headers: { Authorization: `Bearer ${user.githubAccessToken}` }
        });
        const languagesData = languagesResponse.data;
        const totalBytes = Object.values(languagesData).reduce((a, b) => a + b, 0);
        const languages = Object.entries(languagesData).map(([name, bytes]) => ({
            name: name,
            bytes: bytes,
            percentage: ((bytes / totalBytes) * 100).toFixed(1)
        })).sort((a, b) => b.bytes - a.bytes);
        
        // ✅ 4. جلب آخر الـ Commits (آخر 10)
        const recentCommits = await fetchRecentCommits(owner, repoNameOnly, user.githubAccessToken, 10);
        
        // ✅ 5. جلب آخر إصدار (Release)
        const latestRelease = await fetchLatestRelease(owner, repoNameOnly, user.githubAccessToken);
        
        // ✅ 6. جلب المساهمين الرئيسيين (أول 10)
        const contributors = await fetchContributors(owner, repoNameOnly, user.githubAccessToken, 10);
        
        // ✅ 7. جلب معلومات package.json (للمشاريع Node.js)
        const packageInfo = await fetchPackageJson(owner, repoNameOnly, user.githubAccessToken);
        
        // ✅ 8. جلب إحصائيات المشاهدة والنسخ
        const traffic = await fetchTraffic(owner, repoNameOnly, user.githubAccessToken);
        
        // ✅ 9. جلب الإحصائيات الأساسية
        const stats = await fetchProjectStats(owner, repoNameOnly, user.githubAccessToken);
        
        // ✅ 10. جلب معلومات الفرع الرئيسي
        const branchInfo = await fetchBranchInfo(owner, repoNameOnly, user.githubAccessToken);
        
        // ✅ 11. جلب روابط إضافية من المشروع
        const extraLinks = await fetchProjectLinks(owner, repoNameOnly, user.githubAccessToken);
        
        // ✅ 12. صورة المشروع المتقدمة
        let projectImage = '/assets/img/default-project.png';
        // محاولة جلب صورة من Open Graph
        try {
            const socialImageUrl = `https://opengraph.githubassets.com/1/${repo.full_name}`;
            const imageTest = await axios.head(socialImageUrl, { timeout: 3000 });
            if (imageTest.status === 200) {
                projectImage = socialImageUrl;
            } else {
                projectImage = repo.owner.avatar_url;
            }
        } catch (e) {
            projectImage = repo.owner.avatar_url;
        }
        
        // ✅ 13. تجميع كامل البيانات الذكية (بدون استخدام spread داخل الـ object)
        const fullProjectData = {
            title: repo.name,
            description: readmeData?.content || repo.description || `Imported from GitHub: ${repo.name}`,
            rating: '',
            stars: repo.stargazers_count || 0,
            
            // ✅ البيانات المتقدمة من GitHub
            githubData: {
                // معلومات أساسية
                fullName: repo.full_name,
                owner: {
                    login: owner,
                    avatar: repo.owner.avatar_url,
                    url: repo.owner.html_url
                },
                starsCount: repo.stargazers_count,
                forksCount: repo.forks_count,
                watchersCount: repo.watchers_count,
                openIssuesCount: stats?.openIssues || repo.open_issues_count,
                openPullsCount: stats?.openPulls || 0,
                language: repo.language || 'Unknown',
                allLanguages: languages,
                license: repo.license?.name || null,
                
                // تواريخ
                createdAt: repo.created_at,
                updatedAt: repo.updated_at,
                pushedAt: repo.pushed_at,
                
                // معلومات تقنية
                size: repo.size,
                defaultBranch: repo.default_branch,
                branchInfo: branchInfo,
                hasWiki: repo.has_wiki,
                hasPages: repo.has_pages,
                hasIssues: repo.has_issues,
                hasProjects: repo.has_projects,
                hasDownloads: repo.has_downloads,
                archived: repo.archived,
                disabled: repo.disabled,
                visibility: repo.visibility,
                subscribersCount: repo.subscribers_count,
                networkCount: repo.network_count,
                topics: repo.topics || [],
                homepage: repo.homepage || null,
                
                // ✅ البيانات المتقدمة الجديدة
                readme: readmeData?.content || null,
                readmeType: readmeData?.type || null,
                readmeUrl: readmeData?.url || null,
                recentCommits: recentCommits,
                latestRelease: latestRelease,
                contributors: contributors,
                packageInfo: packageInfo,
                traffic: traffic,
                
                // ✅ الروابط الذكية
                links: {
                    issues: `${repo.html_url}/issues`,
                    pulls: `${repo.html_url}/pulls`,
                    commits: `${repo.html_url}/commits`,
                    contributors: `${repo.html_url}/contributors`,
                    releases: `${repo.html_url}/releases`,
                    network: `${repo.html_url}/network`,
                    security: `${repo.html_url}/security`,
                    insights: `${repo.html_url}/pulse`,
                    actions: `${repo.html_url}/actions`,
                    projects: `${repo.html_url}/projects`,
                    wiki: `${repo.html_url}/wiki`
                }
            },
            
            // ✅ الروابط في واجهة المشروع (الأساسية)
            links: [
                { option: 'GitHub Repository', value: repo.html_url },
                { option: 'GitHub Issues', value: `${repo.html_url}/issues` },
                { option: 'GitHub Pull Requests', value: `${repo.html_url}/pulls` },
                { option: 'Commits', value: `${repo.html_url}/commits` },
                { option: 'Contributors', value: `${repo.html_url}/contributors` }
            ],
            
            image: projectImage,
            isPublic: true,
            importedFrom: 'github',
            githubId: repo.id.toString(),
            githubFullName: repo.full_name
        };
        
        // ✅ ✅ ✅ إضافة الروابط الإضافية بعد تعريف fullProjectData (وده الفرق الأساسي)
        
        // إضافة الروابط المستخرجة تلقائياً من README و package.json
        if (extraLinks && extraLinks.length > 0) {
            fullProjectData.links.push(...extraLinks);
        }
        
        // إضافة رابط الـ Release إذا وجد
        if (latestRelease) {
            fullProjectData.links.push({ 
                option: `Latest Release: ${latestRelease.tag}`, 
                value: latestRelease.url 
            });
        }
        
        // إضافة رابط الـ Homepage إذا وجد
        if (repo.homepage) {
            fullProjectData.links.push({ 
                option: 'Live Demo / Website', 
                value: repo.homepage 
            });
        }
        
        // ✅ 14. حفظ البيانات في الـ User Profile
        let projectsList = [];
        if (user.profile.projects) {
            if (Array.isArray(user.profile.projects)) {
                projectsList = user.profile.projects;
            } else if (typeof user.profile.projects === 'object') {
                projectsList = Object.values(user.profile.projects);
            }
        }
        
        // التحقق من عدم التكرار
        const existingIndex = projectsList.findIndex(p => p.githubId === repo.id.toString());
        if (existingIndex !== -1) {
            projectsList[existingIndex] = { ...projectsList[existingIndex], ...fullProjectData };
        } else {
            projectsList.push(fullProjectData);
        }
        
        user.profile.projects = projectsList;
        
        // ✅ 15. حفظ في Project Collection أيضاً
        let existingProject = await Project.findOne({ githubId: repo.id.toString() });
        if (existingProject) {
            existingProject = Object.assign(existingProject, fullProjectData);
            existingProject.userId = user._id;
            await existingProject.save();
        } else {
            const project = new Project({
                ...fullProjectData,
                userId: user._id
            });
            await project.save();
        }
        
        await user.save();
        
        // ✅ إرسال الرد مع إحصائيات مفصلة
        res.json({ 
            success: true, 
            message: `✅ Repository "${repo.name}" imported successfully with full details!`,
            project: fullProjectData,
            stats: {
                stars: repo.stargazers_count,
                forks: repo.forks_count,
                language: repo.language,
                contributors: contributors.length,
                commits: recentCommits.length,
                hasReadme: !!readmeData,
                hasRelease: !!latestRelease,
                languagesCount: languages.length
            }
        });
        
    } catch (error) {
        logger.error(`Error importing GitHub repo: ${error.message}`);
        res.status(500).json({ error: 'Failed to import repository: ' + error.message });
    }
});
// ============================================
// DELETE /api/github/disconnect - فصل حساب GitHub
// ============================================
app.delete('/api/github/disconnect', authenticateToken, async (req, res) => {
    try {
        await User.findByIdAndUpdate(req.user.userId, { 
            $unset: { 
                githubAccessToken: "", 
                githubRefreshToken: "", 
                githubUsername: "",
                githubId: ""
            }
        });
        res.json({ success: true, message: 'GitHub account disconnected successfully' });
    } catch (error) {
        logger.error(`Error disconnecting GitHub: ${error.message}`);
        res.status(500).json({ error: 'Failed to disconnect GitHub account' });
    }
});

app.get('/api/github/repos', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        
        if (!user.githubAccessToken) {
            return res.status(400).json({ 
                success: false, 
                error: 'GitHub account not linked. Please connect your GitHub account first.',
                needsConnection: true
            });
        }

        // ✅ إضافة timeout و User-Agent
        const response = await axios.get('https://api.github.com/user/repos', {
            headers: { 
                Authorization: `Bearer ${user.githubAccessToken}`,
                'User-Agent': 'MGZon-App',
                'Accept': 'application/json'
            },
            timeout: 8000,
            params: {
                per_page: 100,
                sort: 'updated',
                direction: 'desc'
            }
        });

        const repos = response.data.map(repo => ({
            id: repo.id,
            name: repo.name,
            full_name: repo.full_name,
            description: repo.description || '',
            url: repo.html_url,
            clone_url: repo.clone_url,
            image: repo.owner.avatar_url,
            stars: repo.stargazers_count,
            forks: repo.forks_count,
            language: repo.language,
            updated_at: repo.updated_at
        }));

        res.json({ 
            success: true, 
            data: repos,
            count: repos.length
        });
        
    } catch (error) {
        if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT') {
            logger.error(`GitHub API timeout for user ${req.user.userId}`);
            return res.status(504).json({ 
                success: false, 
                error: 'GitHub API timeout. Please try again later.' 
            });
        }
        
        if (error.response?.status === 401) {
            // توكن منتهي - مسحه من قاعدة البيانات
            await User.findByIdAndUpdate(req.user.userId, { 
                $unset: { githubAccessToken: "", githubRefreshToken: "", githubUsername: "" }
            });
            return res.status(401).json({ 
                success: false, 
                error: 'GitHub token expired. Please reconnect your GitHub account.',
                needsConnection: true
            });
        }
        
        if (error.response?.status === 403) {
            const resetTime = error.response.headers['x-ratelimit-reset'];
            const waitTime = resetTime ? Math.ceil((resetTime * 1000 - Date.now()) / 1000) : 60;
            return res.status(429).json({ 
                success: false, 
                error: `GitHub API rate limit exceeded. Please try again in ${waitTime} seconds.` 
            });
        }
        
        logger.error(`Error fetching GitHub repos: ${error.message}`);
        res.status(500).json({ 
            success: false, 
            error: 'Failed to fetch GitHub repositories. Please try again.' 
        });
    }
});


app.get('/auth/github', (req, res, next) => {
    const state = Buffer.from(JSON.stringify({
        redirect_uri: req.query.redirect_uri,
        success_redirect: req.query.success_redirect
    })).toString('base64');
    passport.authenticate('github', { scope: ['user:email', 'repo'], state })(req, res, next);
});



// مسار بدء تسجيل الدخول عبر Facebook
app.get('/auth/facebook', (req, res, next) => {
    const state = Buffer.from(JSON.stringify({
        redirect_uri: req.query.redirect_uri,
        success_redirect: req.query.success_redirect
    })).toString('base64');
    passport.authenticate('facebook', { scope: ['email', 'public_profile'], state })(req, res, next);
});

// مسار بدء تسجيل الدخول عبر MGZon
app.get('/auth/mgz', (req, res, next) => {
    const state = Buffer.from(JSON.stringify({
        redirect_uri: req.query.redirect_uri,
        success_redirect: req.query.success_redirect
    })).toString('base64');
    passport.authenticate('mgzon', { scope: ['profile:read', 'profile:write'], state })(req, res, next);
});


app.get('/auth/google', (req, res, next) => {
    const state = Buffer.from(JSON.stringify({
        redirect_uri: req.query.redirect_uri,
        success_redirect: req.query.success_redirect
    })).toString('base64');
    passport.authenticate('google', { scope: ['profile', 'email'], state })(req, res, next);
});


// ============================================
// 🔐 MAGIC LINK AUTHENTICATION
// ============================================

// 📧 إرسال رابط سحري عبر البريد الإلكتروني
// ============================================
// 🔐 MAGIC LINK AUTHENTICATION - PRO VERSION
// ============================================

// 📧 إرسال رابط سحري عبر البريد الإلكتروني
app.post('/auth/magic-link', async (req, res) => {
    try {
        const { email } = req.body;
        
        if (!email) {
            return res.status(400).json({ 
                success: false, 
                error: 'Email is required' 
            });
        }

        // ✅ التحقق من صحة البريد الإلكتروني
        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        if (!emailRegex.test(email)) {
            return res.status(400).json({ 
                success: false, 
                error: 'Invalid email format' 
            });
        }

        // ✅ البحث عن المستخدم أو إنشاؤه
        let user = await User.findOne({ email: email });
        
        if (!user) {
            user = new User({
                email: email,
                username: email.split('@')[0],
                emailVerified: false,
                profile: {
                    nickname: email.split('@')[0]
                }
            });
            await user.save();
            logger.info(`New user created for magic link: ${email}`);
        }

        // ✅ استخراج اسم المستخدم للترحيب
        const userName = user.profile?.nickname || user.username || email.split('@')[0];

        // ✅ إنشاء رمز سحري (JWT)
        const magicToken = jwt.sign(
            { 
                userId: user._id, 
                email: user.email,
                purpose: 'magic-link'
            },
            JWT_SECRET,
            { expiresIn: '15m' }
        );

        // ✅ إنشاء رابط سحري
        const frontendUrl = process.env.FRONTEND_URL_XCV || 'https://xccv.vercel.app';
        const logoUrl = `${frontendUrl}/assets/img/logo.svg`;
        const magicLink = `${frontendUrl}/auth/callback?token=${magicToken}&provider=magic-link`;

        // ✅ إرسال البريد الإلكتروني عبر Brevo مع الشعار واسم المستخدم
        const htmlContent = `
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>Sign in to XCV</title>
            <style>
                /* ===== RESET ===== */
                * {
                    margin: 0;
                    padding: 0;
                    box-sizing: border-box;
                }
                
                body {
                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
                    background: #f0f2f5;
                    padding: 20px;
                    -webkit-font-smoothing: antialiased;
                }
                
                /* ===== CONTAINER ===== */
                .email-container {
                    max-width: 580px;
                    margin: 0 auto;
                    background: #ffffff;
                    border-radius: 20px;
                    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.08);
                    overflow: hidden;
                }
                
                /* ===== HEADER ===== */
                .email-header {
                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                    padding: 40px 40px 30px;
                    text-align: center;
                }
                
                .email-header .logo {
                    display: inline-block;
                    margin-bottom: 16px;
                }
                
                .email-header .logo img {
                    width: 64px;
                    height: 64px;
                    border-radius: 16px;
                    background: white;
                    padding: 8px;
                    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
                }
                
                .email-header h1 {
                    color: #ffffff;
                    font-size: 28px;
                    font-weight: 700;
                    letter-spacing: -0.5px;
                    margin-bottom: 6px;
                }
                
                .email-header p {
                    color: rgba(255, 255, 255, 0.85);
                    font-size: 16px;
                    font-weight: 400;
                }
                
                /* ===== BODY ===== */
                .email-body {
                    padding: 40px 40px 30px;
                }
                
                .email-body .greeting {
                    font-size: 20px;
                    font-weight: 600;
                    color: #1a1a2e;
                    margin-bottom: 8px;
                }
                
                .email-body .message {
                    color: #4a4a6a;
                    font-size: 16px;
                    line-height: 1.7;
                    margin-bottom: 28px;
                }
                
                /* ===== BUTTON ===== */
                .btn-container {
                    text-align: center;
                    margin: 30px 0 24px;
                }
                
                .btn-magic {
                    display: inline-block;
                    padding: 16px 48px;
                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                    color: #ffffff !important;
                    font-size: 17px;
                    font-weight: 600;
                    text-decoration: none;
                    border-radius: 50px;
                    box-shadow: 0 4px 16px rgba(102, 126, 234, 0.35);
                    transition: all 0.3s ease;
                }
                
                .btn-magic:hover {
                    transform: translateY(-2px);
                    box-shadow: 0 8px 28px rgba(102, 126, 234, 0.45);
                }
                
                /* ===== DIVIDER ===== */
                .divider {
                    display: flex;
                    align-items: center;
                    gap: 16px;
                    margin: 28px 0;
                    color: #9ca3af;
                    font-size: 13px;
                }
                
                .divider::before,
                .divider::after {
                    content: '';
                    flex: 1;
                    height: 1px;
                    background: #e5e7eb;
                }
                
                /* ===== LINK BOX ===== */
                .link-box {
                    background: #f8f9fc;
                    border-radius: 12px;
                    padding: 16px 20px;
                    border: 1px solid #e5e7eb;
                    margin-bottom: 20px;
                }
                
                .link-box .link-label {
                    font-size: 12px;
                    font-weight: 600;
                    color: #6b7280;
                    text-transform: uppercase;
                    letter-spacing: 0.5px;
                    margin-bottom: 8px;
                }
                
                .link-box .link-url {
                    font-family: 'Courier New', monospace;
                    font-size: 13px;
                    color: #1a1a2e;
                    word-break: break-all;
                    background: #ffffff;
                    padding: 10px 14px;
                    border-radius: 8px;
                    border: 1px solid #e5e7eb;
                }
                
                /* ===== INFO ===== */
                .info-grid {
                    display: grid;
                    grid-template-columns: 1fr 1fr;
                    gap: 12px;
                    margin: 24px 0 16px;
                }
                
                .info-item {
                    background: #f8f9fc;
                    border-radius: 10px;
                    padding: 14px 16px;
                    text-align: center;
                }
                
                .info-item .icon {
                    font-size: 20px;
                    display: block;
                    margin-bottom: 4px;
                }
                
                .info-item .label {
                    font-size: 11px;
                    font-weight: 600;
                    color: #6b7280;
                    text-transform: uppercase;
                    letter-spacing: 0.3px;
                }
                
                .info-item .value {
                    font-size: 14px;
                    font-weight: 600;
                    color: #1a1a2e;
                    margin-top: 2px;
                }
                
                /* ===== WARNING ===== */
                .warning-box {
                    background: #fef2f2;
                    border-radius: 10px;
                    padding: 14px 18px;
                    border-left: 4px solid #ef4444;
                    margin-top: 20px;
                }
                
                .warning-box p {
                    font-size: 13px;
                    color: #991b1b;
                    line-height: 1.5;
                }
                
                /* ===== FOOTER ===== */
                .email-footer {
                    background: #f8f9fc;
                    padding: 24px 40px;
                    text-align: center;
                    border-top: 1px solid #e5e7eb;
                }
                
                .email-footer p {
                    font-size: 13px;
                    color: #6b7280;
                    line-height: 1.6;
                }
                
                .email-footer .social-links {
                    display: flex;
                    justify-content: center;
                    gap: 16px;
                    margin-top: 12px;
                }
                
                .email-footer .social-links a {
                    color: #6b7280;
                    text-decoration: none;
                    font-size: 13px;
                }
                
                .email-footer .social-links a:hover {
                    color: #667eea;
                }
                
                /* ===== RESPONSIVE ===== */
                @media (max-width: 480px) {
                    .email-header {
                        padding: 30px 20px 24px;
                    }
                    
                    .email-header h1 {
                        font-size: 22px;
                    }
                    
                    .email-body {
                        padding: 28px 20px 24px;
                    }
                    
                    .info-grid {
                        grid-template-columns: 1fr;
                    }
                    
                    .btn-magic {
                        padding: 14px 32px;
                        font-size: 15px;
                        display: block;
                        text-align: center;
                    }
                    
                    .email-footer {
                        padding: 20px;
                    }
                }
            </style>
        </head>
        <body>
            <div class="email-container">
                <!-- HEADER -->
                <div class="email-header">
                    <div class="logo">
                        <img src="${logoUrl}" alt="XCV Logo" width="64" height="64">
                    </div>
                    <h1>Welcome to XCV</h1>
                    <p>Your professional profile platform</p>
                </div>
                
                <!-- BODY -->
                <div class="email-body">
                    <div class="greeting">Hello <strong>${userName}</strong>! 👋</div>
                    
                    <p class="message">
                        You're just one click away from accessing your professional profile.
                        Use the magic link below to sign in securely.
                    </p>
                    
                    <!-- BUTTON -->
                    <div class="btn-container">
                        <a href="${magicLink}" class="btn-magic">
                            ✨ Sign In with Magic Link
                        </a>
                    </div>
                    
                    <!-- DIVIDER -->
                    <div class="divider">or copy this link</div>
                    
                    <!-- LINK BOX -->
                    <div class="link-box">
                        <div class="link-label">📋 Magic Link</div>
                        <div class="link-url">${magicLink}</div>
                    </div>
                    
                    <!-- INFO -->
                    <div class="info-grid">
                        <div class="info-item">
                            <span class="icon">⏱️</span>
                            <div class="label">Expires In</div>
                            <div class="value">15 Minutes</div>
                        </div>
                        <div class="info-item">
                            <span class="icon">🔐</span>
                            <div class="label">Security</div>
                            <div class="value">Encrypted</div>
                        </div>
                    </div>
                    
                    <!-- WARNING -->
                    <div class="warning-box">
                        <p>
                            ⚠️ If you didn't request this email, you can safely ignore it.
                            No changes will be made to your account.
                        </p>
                    </div>
                </div>
                
                <!-- FOOTER -->
                <div class="email-footer">
                    <p>
                        &copy; ${new Date().getFullYear()} <strong>XCV</strong> — Professional Profile Platform
                    </p>
                    <p style="font-size: 12px; color: #9ca3af; margin-top: 4px;">
                        Built with ❤️ for professionals like you
                    </p>
                    <div class="social-links">
                        <a href="https://xccv.vercel.app">Home</a>
                        <a href="https://xccv.vercel.app/privacy">Privacy</a>
                        <a href="https://xccv.vercel.app/terms">Terms</a>
                        <a href="mailto:support@xccv.vercel.app">Support</a>
                    </div>
                </div>
            </div>
        </body>
        </html>
        `;

        const textContent = `
        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        ✨ WELCOME TO XCV ✨
        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        
        Hello ${userName}! 👋
        
        You're one click away from accessing your professional profile.
        
        🔗 YOUR MAGIC LINK:
        ${magicLink}
        
        ⏱️ Expires in: 15 minutes
        🔐 Security: Encrypted
        
        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        ⚠️ If you didn't request this email,
        please ignore it. No changes will be made.
        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        
        © ${new Date().getFullYear()} XCV — Professional Profile Platform
        Built with ❤️ for professionals like you
        `;

        // ✅ إرسال البريد عبر Brevo
        await sendEmailWithBrevo(
            email,
            '✨ Sign in to XCV with Magic Link',
            htmlContent,
            textContent
        );

        logger.info(`Magic link sent to: ${email}`);

        return res.json({
            success: true,
            message: 'Magic link sent to your email!',
            email: email
        });

    } catch (error) {
        logger.error(`Magic link error: ${error.message}`);
        Sentry.captureException(error);
        return res.status(500).json({
            success: false,
            error: 'Failed to send magic link. Please try again.'
        });
    }
});

// ============================================
// 🔐 VERIFY MAGIC LINK
// ============================================
app.get('/auth/verify-magic-link', async (req, res) => {
    try {
        const { token } = req.query;
        
        if (!token) {
            return res.status(400).json({
                success: false,
                error: 'Token is required'
            });
        }

        // ✅ التحقق من JWT
        const decoded = jwt.verify(token, JWT_SECRET);
        
        if (decoded.purpose !== 'magic-link') {
            return res.status(400).json({
                success: false,
                error: 'Invalid token purpose'
            });
        }

        // ✅ البحث عن المستخدم
        const user = await User.findById(decoded.userId);
        if (!user) {
            return res.status(404).json({
                success: false,
                error: 'User not found'
            });
        }

        // ✅ تحديث حالة التحقق
        user.emailVerified = true;
        
        // ✅ إنشاء توكن جديد للجلسة
        const accessToken = jwt.sign(
            { userId: user._id, email: user.email },
            JWT_SECRET,
            { expiresIn: '30d' }
        );

        const refreshToken = jwt.sign(
            { userId: user._id },
            REFRESH_TOKEN_SECRET || JWT_SECRET,
            { expiresIn: '90d' }
        );

        // ✅ حفظ Refresh Token
        user.refreshTokens = user.refreshTokens || [];
        user.refreshTokens.push({ token: refreshToken, createdAt: new Date() });
        await user.save();

        // ✅ إعادة التوجيه إلى الـ Frontend مع التوكن
        const frontendUrl = process.env.FRONTEND_URL_XCV || 'https://xccv.vercel.app';
        const redirectUri = req.query.redirect_uri || `${frontendUrl}/auth/callback`;

        return res.redirect(
            `${redirectUri}?token=${accessToken}&refreshToken=${refreshToken}&provider=magic-link`
        );

    } catch (error) {
        if (error.name === 'TokenExpiredError') {
            return res.status(401).json({
                success: false,
                error: 'Magic link has expired. Please request a new one.'
            });
        }
        
        logger.error(`Verify magic link error: ${error.message}`);
        Sentry.captureException(error);
        return res.status(500).json({
            success: false,
            error: 'Failed to verify magic link'
        });
    }
});

// ============================================
// 🔄 RESEND MAGIC LINK
// ============================================
app.post('/auth/resend-magic-link', async (req, res) => {
    try {
        const { email } = req.body;
        
        if (!email) {
            return res.status(400).json({
                success: false,
                error: 'Email is required'
            });
        }

        // ✅ إعادة إرسال الرابط السحري
        const user = await User.findOne({ email });
        if (!user) {
            return res.status(404).json({
                success: false,
                error: 'User not found'
            });
        }

        // ✅ إنشاء رمز جديد
        const magicToken = jwt.sign(
            { 
                userId: user._id, 
                email: user.email,
                purpose: 'magic-link'
            },
            JWT_SECRET,
            { expiresIn: '15m' }
        );

        const frontendUrl = process.env.FRONTEND_URL_XCV || 'https://xccv.vercel.app';
        const magicLink = `${frontendUrl}/auth/callback?token=${magicToken}&provider=magic-link`;

        // ✅ إرسال البريد
        await sendEmailWithBrevo(
            email,
            '✨ Your New Magic Link',
            `
            <h2>Here's your new magic link!</h2>
            <p>Click the link below to sign in:</p>
            <a href="${magicLink}" style="display:inline-block;padding:12px 24px;background:#667eea;color:white;text-decoration:none;border-radius:8px;">Sign In</a>
            <p>This link will expire in 15 minutes.</p>
            `,
            `Sign in with this magic link: ${magicLink}`
        );

        return res.json({
            success: true,
            message: 'New magic link sent!'
        });

    } catch (error) {
        logger.error(`Resend magic link error: ${error.message}`);
        return res.status(500).json({
            success: false,
            error: 'Failed to resend magic link'
        });
    }
});

app.get('/api/csrf-token', (req, res) => {
    const csrfToken = req.csrfToken ? req.csrfToken() : null;
    if (!csrfToken) {
        logger.error('Failed to generate CSRF token');
        Sentry.captureMessage('Failed to generate CSRF token', { extra: { endpoint: '/api/csrf-token', method: 'GET' } });
        return res.status(500).json({ error: 'Failed to generate CSRF token' });
    }
    res.json({ csrfToken });
});



app.post('/api/notifications/subscribe', authenticateToken, async (req, res) => {
    try {
        const subscription = req.body;
        const user = await User.findById(req.user.userId);
        user.notifications.push(subscription);
        await user.save();
        res.json({ message: 'Subscription added successfully' });
    } catch (error) {
        logger.error(`Error subscribing to notifications: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to subscribe to notifications' });
    }
});



app.get('/api/facebook/posts', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);

        if (!user.facebookAccessToken) {
            return res.status(400).json({ error: 'Facebook account not linked' });
        }

        let accessToken = user.facebookAccessToken;

        // Attempt to fetch posts
        let response;
        try {
            response = await axios.get('https://graph.facebook.com/v20.0/me?fields=posts{created_time,message,likes.summary(true),comments.summary(true),shares},name,email', {
                headers: { Authorization: `Bearer ${accessToken}` },
            });
        } catch (error) {
            if (error.response?.status === 401 && user.facebookRefreshToken) {
                try {
                    const refreshResponse = await axios.get('https://graph.facebook.com/v20.0/oauth/access_token', {
                        params: {
                            grant_type: 'fb_exchange_token',
                            client_id: process.env.FACEBOOK_CLIENT_ID,
                            client_secret: process.env.FACEBOOK_CLIENT_SECRET,
                            fb_exchange_token: user.facebookRefreshToken,
                        },
                    });
                    accessToken = refreshResponse.data.access_token;
                    if (refreshResponse.data.refresh_token) {
                        user.facebookRefreshToken = refreshResponse.data.refresh_token; // تحديث الـ refresh token
                    }
                    user.facebookAccessToken = accessToken;
                    await user.save();
                    // Retry the request
                    response = await axios.get('https://graph.facebook.com/v20.0/me?fields=posts{created_time,message,likes.summary(true),comments.summary(true),shares},name,email', {
                        headers: { Authorization: `Bearer ${accessToken}` },
                    });
                } catch (refreshError) {
                    logger.error(`Failed to refresh Facebook token: ${refreshError.message}`);
                    Sentry.captureException(refreshError);
                    return res.status(401).json({ error: 'Facebook access token expired. Please re-authenticate.' });
                }
            } else {
                throw error; // Re-throw if not a 401 or no refresh token
            }
        }

        const posts = response.data.posts.data.map(post => ({
            id: post.id,
            created_time: post.created_time,
            message: post.message || '',
            likes: post.likes?.summary?.total_count || 0,
            comments: post.comments?.summary?.total_count || 0,
            shares: post.shares?.count || 0,
        }));

        res.json({ posts, profile: { name: response.data.name, email: response.data.email } });
    } catch (error) {
        if (error.response?.status === 401) {
            return res.status(401).json({ error: 'Facebook access token expired. Please re-authenticate.' });
        }

        logger.error(`Error fetching Facebook posts: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to fetch Facebook posts' });
    }
});



app.post('/api/facebook/share-profile', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user.facebookAccessToken) {
            return res.status(400).json({ error: 'Facebook account not linked' });
        }

        const redirectUri = req.query.redirect_uri && allowedRedirectUris.includes(req.query.redirect_uri)
            ? req.query.redirect_uri
            : allowedRedirectUris[0];
        const profileUrl = `${redirectUri.split('/auth/callback')[0]}/profile/${user.profile.nickname || user.username}`;
        const message = `Check out my portfolio: ${profileUrl}`;

        const response = await axios.post('https://graph.facebook.com/v20.0/me/feed', {
            message,
            link: profileUrl
        }, {
            headers: { Authorization: `Bearer ${user.facebookAccessToken}` }
        });

        res.json({ message: 'Profile shared successfully', postId: response.data.id });
    } catch (error) {
        logger.error(`Error sharing profile on Facebook: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to share profile' });
    }
});


const facebookLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 10,
    message: 'Too many Facebook API requests, please try again later.'
});
app.use('/api/facebook', facebookLimiter);



app.post('/api/refresh-token', async (req, res) => {
    const { refreshToken } = req.body;
    if (!refreshToken) {
        return res.status(401).json({ error: 'Refresh token required' });
    }

    try {
        const user = await User.findOne({ 'refreshTokens.token': refreshToken });
        if (!user) {
            return res.status(403).json({ error: 'Invalid refresh token' });
        }

        const payload = jwt.verify(refreshToken, process.env.REFRESH_TOKEN_SECRET);
        const newAccessToken = jwt.sign(
            { userId: user._id, email: user.email },
            process.env.JWT_SECRET,
            { expiresIn: '30d' }
        );

        // Optionally rotate refresh token
        user.refreshTokens = user.refreshTokens.filter(token => token.token !== refreshToken);
        const newRefreshToken = jwt.sign(
            { userId: user._id },
            process.env.REFRESH_TOKEN_SECRET,
            { expiresIn: '90d' }
        );
        user.refreshTokens.push({ token: newRefreshToken, createdAt: new Date() });
        await user.save();

        res.json({ accessToken: newAccessToken, refreshToken: newRefreshToken });
    } catch (error) {
        logger.error(`Error refreshing token: ${error.message}`);
        Sentry.captureException(error);
        res.status(403).json({ error: 'Invalid or expired refresh token' });
    }
});




const handleAuthCallback = async (req, res, provider) => {
    try {
        const { token, refreshToken } = await generateTokens(req.user);
        const redirectUri = req.authData?.redirect_uri;
        const successRedirect = req.authData?.success_redirect || '';

        const normalizedRedirectUri = redirectUri?.trim().toLowerCase();

        const isAllowed = allowedRedirectUris
            .map(uri => uri.trim().toLowerCase())
            .includes(normalizedRedirectUri);

        if (!normalizedRedirectUri || !isAllowed) {
            logger.error(`Invalid redirect_uri for ${provider}: ${redirectUri || 'none'}`);
            return res.status(400).json({
                success: false,
                error: 'Invalid redirect URI'
            });
        }

        const baseUri = normalizedRedirectUri.split('/auth/callback')[0];
        const targetPath = successRedirect || '/auth/callback';

        logger.info(`${provider} auth successful for user: ${req.user.email}`);
        return res.redirect(
            `${baseUri}${targetPath}?token=${token}&refreshToken=${refreshToken}&provider=${provider.toLowerCase()}`
        );
    } catch (error) {
        logger.error(`${provider} callback error: ${error.message}`);
        Sentry.captureException(error);
        return res.status(500).json({ success: false, error: 'Authentication failed' });
    }
};

app.get(
    '/auth/mgz/callback',
    passport.authenticate('mgzon', { session: false }),
    (req, res) => {
        try {
            const authData = JSON.parse(Buffer.from(req.query.state, 'base64').toString());
            req.authData = authData;
            return handleAuthCallback(req, res, 'MGZon');
        } catch (error) {
            logger.error(`MGZon state parse error: ${error.message}`);
            return res.status(400).json({ success: false, error: 'Invalid OAuth state' });
        }
    }
);
app.get(
    '/auth/google/callback',
    passport.authenticate('google', { session: false }),
    (req, res) => {
        try {
            const authData = JSON.parse(Buffer.from(req.query.state, 'base64').toString());
            req.authData = authData;
            return handleAuthCallback(req, res, 'Google');
        } catch (error) {
            logger.error(`Google state parse error: ${error.message}`);
            return res.status(400).json({ success: false, error: 'Invalid OAuth state' });
        }
    }
);
app.get(
    '/auth/facebook/callback',
    passport.authenticate('facebook', { session: false }),
    (req, res) => {
        try {
            const authData = JSON.parse(Buffer.from(req.query.state, 'base64').toString());
            req.authData = authData;
            return handleAuthCallback(req, res, 'Facebook');
        } catch (error) {
            logger.error(`Facebook state parse error: ${error.message}`);
            return res.status(400).json({ success: false, error: 'Invalid OAuth state' });
        }
    }
);

app.get(
    '/auth/github/callback',
    passport.authenticate('github', { session: false }),
    (req, res) => {
        try {
            const authData = JSON.parse(Buffer.from(req.query.state, 'base64').toString());
            req.authData = authData;
            return handleAuthCallback(req, res, 'GitHub');
        } catch (error) {
            logger.error(`GitHub state parse error: ${error.message}`);
            return res.status(400).json({ success: false, error: 'Invalid OAuth state' });
        }
    }
);

// app.get('/auth/canva', (req, res) => {
//     const authUrl = `https://api.canva.com/v1/oauth/authorize?client_id=${process.env.CANVA_CLIENT_ID}&redirect_uri=${encodeURIComponent(process.env.BASE_URL + '/auth/canva/callback')}&response_type=code&scope=design:read,design:write,asset:private:read,asset:private:write`;
//     res.redirect(authUrl);
// });

// app.get('/auth/canva/callback', async (req, res) => {
//     const { code } = req.query;
//     try {
//         const response = await axios.post('https://api.canva.com/v1/oauth/token', {
//             client_id: process.env.CANVA_CLIENT_ID,
//             client_secret: process.env.CANVA_CLIENT_SECRET,
//             grant_type: 'authorization_code',
//             code,
//             redirect_uri: process.env.BASE_URL + '/auth/canva/callback'
//         });
//         const { access_token, refresh_token } = response.data;
//         // حفظ الـ tokens في قاعدة البيانات
//         const user = await User.findById(req.user.userId);
//         user.canvaAccessToken = access_token;
//         user.canvaRefreshToken = refresh_token;
//         await user.save();
//         res.redirect(`${process.env.WEB_URL}/auth/callback?token=${access_token}&provider=canva`);
//     } catch (error) {
//         logger.error(`Canva auth error: ${error.message}`);
//         Sentry.captureException(error);
//         res.status(500).redirect(`${process.env.WEB_URL}/login.html?error=${encodeURIComponent('Canva authentication failed')}`);
//     }
// });

// app.post('/webhooks/canva/uninstall', async (req, res) => {
//     const { userId } = req.body;
//     try {
//         const user = await User.findById(userId);
//         if (user) {
//             user.canvaAccessToken = null;
//             user.refreshTokens = null;
//             await user.save();
//             logger.info(`Canva app uninstalled for user ${userId}`);
//         }
//         res.sendStatus(200);
//     } catch (error) {
//         logger.error(`Error handling Canva uninstall webhook: ${error.message}`);
//         Sentry.captureException(error);
//         res.sendStatus(500);
//     }
// });


app.get('/api/test-sentry', (req, res) => {
    const error = new Error('Test Sentry error');
    throw error; // Will be caught by error handler and sent to Sentry
});




// const rateLimit = require('express-rate-limit');
const loginLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 5,
    message: 'Too many login attempts, please try again later.',
    validate: { trustProxy: false }
});
app.use('/api/login', loginLimiter);

async function generateTokens(user) {
    user.refreshTokens = user.refreshTokens.filter(t => new Date(t.createdAt) > new Date(Date.now() - 30 * 24 * 60 * 60 * 1000));
    if (user.refreshTokens.length >= 10) {
        user.refreshTokens.shift();
    }
    
    // ✅ ✅ ✅ أضف username و profile.nickname في الـ JWT
    const token = jwt.sign(
        { 
            userId: user._id, 
            isAdmin: user.isAdmin,
            username: user.username,
            'profile.nickname': user.profile?.nickname || user.username
        }, 
        JWT_SECRET, 
        { expiresIn: '30d' }
    );
    
    const refreshToken = jwt.sign(
        { 
            userId: user._id,
            username: user.username,
            'profile.nickname': user.profile?.nickname || user.username
        }, 
        process.env.REFRESH_TOKEN_SECRET, 
        { expiresIn: '90d' }
    );
    
    user.refreshTokens.push({ token: refreshToken, createdAt: new Date() });
    await user.save();
    return { token, refreshToken };
}

async function createAdminUser() {
    const adminExists = await User.findOne({ username: 'admin' });
    if (!adminExists) {
        const hashedPassword = await bcrypt.hash('admin123', 10);
        await User.create({
            username: 'admin',
            email: 'admin@elasfar.com',
            password: hashedPassword,
            isAdmin: true
        });
        logger.info('Admin user created');
    }
}
createAdminUser();






app.post('/api/google/save-cv', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user.googleAccessToken) {
            return res.status(400).json({ error: 'Google account not linked' });
        }

        const oauth2Client = new google.auth.OAuth2(
            process.env.GOOGLE_CLIENT_ID,
            process.env.GOOGLE_CLIENT_SECRET,
            `${process.env.BASE_URL}/auth/google/callback`
        );
        oauth2Client.setCredentials({ access_token: user.googleAccessToken });

        // Check if token is expired and try to refresh it
        if (user.googleRefreshToken) {
            try {
                const { credentials } = await oauth2Client.refreshAccessToken();
                user.googleAccessToken = credentials.access_token;
                await user.save();
                oauth2Client.setCredentials({ access_token: user.googleAccessToken });
            } catch (refreshError) {
                logger.error(`Failed to refresh Google token: ${refreshError.message}`);
                Sentry.captureException(refreshError);
                return res.status(401).json({ error: 'Google access token expired. Please re-authenticate.' });
            }
        }

        const drive = google.drive({ version: 'v3', auth: oauth2Client });

        // Create PDF with full CV details
        const doc = new jsPDF();
        doc.setFontSize(20);
        doc.text(user.profile.nickname || user.username, 10, 20);

        // Job Title
        if (user.profile.jobTitle) {
            doc.setFontSize(14);
            doc.text(user.profile.jobTitle, 10, 30);
        }

        // Bio
        if (user.profile.bio) {
            doc.setFontSize(12);
            doc.text('Bio:', 10, 40);
            doc.text(doc.splitTextToSize(user.profile.bio, 180), 10, 50);
        }

        // Contact Info
        let yOffset = user.profile.bio ? 70 : 40;
        if (user.profile.phone || user.profile.socialLinks) {
            doc.setFontSize(12);
            doc.text('Contact:', 10, yOffset);
            if (user.profile.phone) {
                doc.text(`Phone: ${user.profile.phone}`, 10, yOffset + 10);
                yOffset += 10;
            }
            Object.keys(user.profile.socialLinks).forEach((key, index) => {
                if (user.profile.socialLinks[key]) {
                    doc.text(`${key}: ${user.profile.socialLinks[key]}`, 10, yOffset + 10 * (index + 1));
                }
            });
            yOffset += 10 * (Object.keys(user.profile.socialLinks).length + 1);
        }

        // Education
        if (user.profile.education && user.profile.education.length > 0) {
            doc.setFontSize(12);
            doc.text('Education:', 10, yOffset);
            doc.autoTable({
                startY: yOffset + 10,
                head: [['Institution', 'Degree', 'Year']],
                body: user.profile.education.map(edu => [edu.institution, edu.degree, edu.year]),
            });
            yOffset = doc.lastAutoTable.finalY + 10;
        }

        // Experience
        if (user.profile.experience && user.profile.experience.length > 0) {
            doc.setFontSize(12);
            doc.text('Experience:', 10, yOffset);
            doc.autoTable({
                startY: yOffset + 10,
                head: [['Company', 'Role', 'Duration']],
                body: user.profile.experience.map(exp => [exp.company, exp.role, exp.duration]),
            });
            yOffset = doc.lastAutoTable.finalY + 10;
        }

        // Certificates
        if (user.profile.certificates && user.profile.certificates.length > 0) {
            doc.setFontSize(12);
            doc.text('Certificates:', 10, yOffset);
            doc.autoTable({
                startY: yOffset + 10,
                head: [['Name', 'Issuer', 'Year']],
                body: user.profile.certificates.map(cert => [cert.name, cert.issuer, cert.year]),
            });
            yOffset = doc.lastAutoTable.finalY + 10;
        }

        // Skills
        if (user.profile.skills && user.profile.skills.length > 0) {
            doc.setFontSize(12);
            doc.text('Skills:', 10, yOffset);
            doc.autoTable({
                startY: yOffset + 10,
                head: [['Name', 'Percentage']],
                body: user.profile.skills.map(skill => [skill.name, `${skill.percentage}%`]),
            });
            yOffset = doc.lastAutoTable.finalY + 10;
        }

        // Projects
        if (user.profile.projects && user.profile.projects.length > 0) {
            doc.setFontSize(12);
            doc.text('Projects:', 10, yOffset);
            doc.autoTable({
                startY: yOffset + 10,
                head: [['Title', 'Description', 'Links']],
                body: user.profile.projects.map(proj => [
                    proj.title,
                    proj.description,
                    proj.links.map(link => `${link.option}: ${link.value}`).join(', '),
                ]),
            });
        }

        const fileMetadata = {
            name: `${user.profile.nickname || user.username}_resume.pdf`,
            mimeType: 'application/pdf',
        };
        const media = {
            mimeType: 'application/pdf',
            body: doc.output('stream'),
        };

        const response = await drive.files.create({
            resource: fileMetadata,
            media,
            fields: 'id, webViewLink',
        });

        // Track CV save event in Google Analytics
        try {
            await axios.post('https://www.google-analytics.com/mp/collect', {
                measurement_id: process.env.GOOGLE_ANALYTICS_ID,
                api_secret: process.env.GOOGLE_ANALYTICS_API_SECRET,
                events: [{
                    name: 'save_cv',
                    params: {
                        userId: req.user.userId,
                        timestamp: new Date().toISOString(),
                    },
                }],
            }, {
                headers: { 'Content-Type': 'application/json' },
                timeout: 5000,
            });
            logger.info(`CV save tracked for user ${req.user.userId}`);
        } catch (analyticsError) {
            logger.error(`Failed to track CV save: ${analyticsError.message}`);
            Sentry.captureException(analyticsError);
        }

        res.json({
            message: 'CV saved to Google Drive',
            fileId: response.data.id,
            link: response.data.webViewLink,
        });
    } catch (error) {
        if (error.response?.status === 401) {
            return res.status(401).json({ error: 'Google access token expired. Please re-authenticate.' });
        }
        logger.error(`Error saving CV to Google Drive: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to save CV to Google Drive' });
    }
});


app.use((err, req, res, next) => {
    logger.error(`Unhandled error: ${err.stack}`);
    Sentry.captureException(err, { extra: { endpoint: req.originalUrl, method: req.method } });
    if (err.code === 'EBADCSRFTOKEN') {
        logger.warn(`Invalid CSRF token for ${req.originalUrl}`);
        return res.status(403).json({ error: 'Invalid CSRF token' });
    }
    if (err.name === 'MongoError' && err.code === 11000) {
        return res.status(400).json({ error: 'Duplicate key error', details: err.message });
    }
    if (err.name === 'MulterError') {
        return res.status(400).json({ error: 'File upload error', details: err.message });
    }
    if (err.name === 'JsonWebTokenError') {
        return res.status(401).json({ error: 'Invalid JWT token', details: err.message });
    }
    if (err.name === 'TokenExpiredError') {
        return res.status(401).json({ error: 'JWT token expired', details: err.message });
    }
    res.status(500).json({ error: 'Internal server error', details: err.message });
});

async function generateAIContext(question = '') {
    const projects = await Project.find().select('title description image rating stars links');
    const skills = await Skill.find();
    return `
        Website: Ibrahim Al-Asfar's personal portfolio.
        Description: A full-stack web developer portfolio showcasing projects, skills, and contact information.
        Skills: ${skills.map(s => `${s.name} (${s.percentage}%)`).join(', ')}
        Projects: ${projects.map(p => `${p.title}: ${p.description} (Links: ${p.links.map(l => l.option).join(', ')})`).join('\n')}
        ${question}
    `;
}

async function sendNotification(userId, message) {
    try {
        const user = await User.findById(userId);
        if (!user) {
            logger.error('User not found for notification:', userId);
            return;
        }
        await transporter.sendMail({
            from: EMAIL_USER,
            to: user.email,
            subject: 'New Notification',
            text: message
        });
        user.notifications.push(message);
        await user.save();
        logger.info(`Notification sent to ${user.email}: ${message}`);
    } catch (error) {
        logger.error('Error sending notification:', error);
    }
}
// ============================================
// STORE NOTIFICATION HELPER
// ============================================
async function sendStoreNotification(userId, type, content, link = '', actorId = null) {
    try {
        const notification = new Notification({
            userId,
            type,
            actorId,
            actorName: null,
            content,
            targetId: link,
            targetType: 'store',
            read: false
        });
        
        await notification.save();
        
        // إرسال عبر Socket.IO إذا كان المستخدم متصلاً
        const io = req.app.get('io');
        if (io) {
            io.to(`user_${userId}`).emit('new_notification', {
                type,
                content,
                link,
                createdAt: new Date()
            });
        }
        
        return notification;
    } catch (error) {
        console.error('Error sending store notification:', error);
        return null;
    }
}

async function authenticateToken(req, res, next) {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];

    if (!token) {
        logger.warn(`No token provided for endpoint: ${req.originalUrl}`);
        Sentry.captureMessage('No token provided', { extra: { endpoint: req.originalUrl, method: req.method } });
        return res.status(401).json({ error: 'Token is required' });
    }

    try {
        const payload = jwt.verify(token, process.env.JWT_SECRET);
        req.user = payload;
        Sentry.setUser({ id: payload.userId, email: payload.email });
        next();
    } catch (error) {
        if (error.name === 'TokenExpiredError') {
            const refreshToken = req.body.refreshToken || req.headers['x-refresh-token'] || req.cookies.refreshToken;
            if (!refreshToken) {
                logger.warn(`No refresh token provided for expired token at: ${req.originalUrl}`);
                Sentry.captureMessage('No refresh token provided for expired token', { extra: { endpoint: req.originalUrl, method: req.method } });
                return res.status(401).json({ error: 'Access token expired. Please provide a refresh token.' });
            }

            try {
                const decoded = jwt.verify(refreshToken, process.env.REFRESH_TOKEN_SECRET);
                const user = await User.findOne({ _id: decoded.userId, 'refreshTokens.token': refreshToken });
                if (!user) {
                    logger.warn(`Invalid refresh token for user ${decoded.userId}`);
                    Sentry.captureMessage('Invalid refresh token', { extra: { endpoint: req.originalUrl, method: req.method } });
                    return res.status(403).json({ error: 'Invalid refresh token' });
                }

                const newToken = jwt.sign({ userId: user._id, isAdmin: user.isAdmin, email: user.email }, process.env.JWT_SECRET, { expiresIn: '30d' });
                req.user = { userId: user._id, isAdmin: user.isAdmin, email: user.email };
                res.setHeader('X-New-Token', newToken);
                logger.info(`Token refreshed for user ${user._id}`);
                next();
            } catch (refreshError) {
                logger.error(`Failed to refresh token: ${refreshError.message}`);
                Sentry.captureException(refreshError, { extra: { endpoint: req.originalUrl, method: req.method } });
                return res.status(403).json({ error: 'Failed to refresh token' });
            }
        } else {
            logger.error(`Invalid token: ${error.message}`);
            Sentry.captureException(error, { extra: { endpoint: req.originalUrl, method: req.method } });
            return res.status(403).json({ error: 'Invalid token' });
        }
    }
}


// ✅ نسخة محسنة لـ Socket.IO (أضفها أو استبدل القديمة)
app.get('/api/verify-token', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId)
            .select('username profile.nickname profile.avatar profile.jobTitle profile.portfolioName isAdmin')
            .lean();
        
        if (!user) {
            return res.status(404).json({ valid: false, error: 'User not found' });
        }
        
        // ✅ إرجاع بيانات أكثر تفصيلاً لـ Socket.IO
        res.json({
            valid: true,
            userId: req.user.userId,
            username: user.username,
            isAdmin: user.isAdmin || false,
            profile: {
                nickname: user.profile?.nickname || user.username,
                avatar: user.profile?.avatar || '/assets/img/default-avatar.png',
                jobTitle: user.profile?.jobTitle || 'Professional',
                portfolioName: user.profile?.portfolioName || 'Portfolio'
            }
        });
    } catch (error) {
        logger.error(`Error in verify-token: ${error.message}`);
        res.status(500).json({ valid: false, error: 'Internal server error' });
    }
});

app.post('/api/logout', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) return res.status(404).json({ error: 'User not found' });
        const refreshToken = req.body.refreshToken;
        if (refreshToken) {
            user.refreshTokens = user.refreshTokens.filter(t => t.token !== refreshToken);
            await user.save();
        }
        res.json({ message: 'Logged out successfully' });
    } catch (error) {
        res.status(500).json({ error: 'Failed to logout: ' + error.message });
    }
});

app.post('/api/upload', authenticateToken, upload.single('file'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ error: 'No file uploaded' });
        }
        
        // ✅ التحقق من صيغة الملف
        const allowedTypes = ['image/jpeg', 'image/png', 'image/jpg', 'image/webp'];
        if (!allowedTypes.includes(req.file.mimetype)) {
            return res.status(400).json({ error: 'Only JPEG, PNG, WEBP images are allowed' });
        }
        
        // ✅ التحقق من الحجم (5MB)
        if (req.file.size > 5 * 1024 * 1024) {
            return res.status(400).json({ error: 'File size must be less than 5MB' });
        }
        
        const fileUrl = req.file.path; // Cloudinary URL
        
        // ✅ التحقق من وجود URL
        if (!fileUrl) {
            return res.status(500).json({ error: 'Upload failed - no URL returned' });
        }
        
        res.json({ message: `File uploaded successfully: ${fileUrl}` });
    } catch (error) {
        if (error instanceof multer.MulterError) {
            return res.status(400).json({ error: `Multer error: ${error.message}` });
        }
        logger.error(`Upload error: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: error.message || 'Failed to upload file' });
    }
});

// ============================================
// POST /api/login
// ============================================
app.post('/api/login', [
    body('email').isEmail().withMessage('Invalid email format'),
    body('password').notEmpty().withMessage('Password is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    const { email, password } = req.body;
    try {
        const user = await User.findOne({ email });
        if (!user || !(await bcrypt.compare(password, user.password))) {
            return res.status(401).json({ error: 'Invalid credentials' });
        }
        
        // ✅ لو كان أدمن → تخطي OTP
        if (user.isAdmin) {
            const token = jwt.sign(
                { 
                    userId: user._id, 
                    isAdmin: user.isAdmin,
                    username: user.username,
                    'profile.nickname': user.profile?.nickname || user.username
                }, 
                JWT_SECRET, 
                { expiresIn: '30d' }
            );
            const refreshToken = jwt.sign(
                { 
                    userId: user._id,
                    username: user.username,
                    'profile.nickname': user.profile?.nickname || user.username
                }, 
                JWT_SECRET, 
                { expiresIn: '90d' }
            );
            user.refreshTokens.push({ token: refreshToken });
            await user.save();
            logger.info(`Admin login: ${email} - Token issued without OTP`);
            return res.json({ token, refreshToken });
        }
        
        // ✅ لو الإيميل مش مفعل → اطلب OTP
        if (!user.emailVerified) {
            const otp = Math.floor(100000 + Math.random() * 900000).toString();
            user.otp = otp;
            user.otpExpires = Date.now() + 10 * 60 * 1000;
            await user.save();
            
            res.status(403).json({ 
                error: 'Email not verified', 
                requiresVerification: true,
                email: email,
                message: 'Verification code sent to your email'
            });
            
            setTimeout(async () => {
                try {
                    await sendEmailWithBrevo(
                        email,
                        'Verify Your Email - MGZon',
                        `<div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
                            <h2>Email Verification Required</h2>
                            <p>Please verify your email address using the code below:</p>
                            <div style="background: #f3f4f6; padding: 20px; text-align: center; font-size: 32px; letter-spacing: 8px; font-weight: bold; border-radius: 10px;">
                                ${otp}
                            </div>
                            <p>This code is valid for <strong>10 minutes</strong>.</p>
                        </div>`,
                        `Your verification code is: ${otp}. Valid for 10 minutes.`
                    );
                    logger.info(`Verification OTP sent to ${email} via Brevo`);
                } catch (mailError) {
                    logger.error('Failed to send verification email via Brevo:', mailError);
                }
                
                console.log(`\n🔐 ========================================`);
                console.log(`🔐 VERIFICATION CODE FOR ${email}: ${otp}`);
                console.log(`🔐 ========================================\n`);
            }, 0);
            
            return;
        }
        
        // ✅ الإيميل مفعل → توكن مباشر
        const token = jwt.sign(
            { 
                userId: user._id, 
                isAdmin: user.isAdmin,
                username: user.username,
                'profile.nickname': user.profile?.nickname || user.username
            }, 
            JWT_SECRET, 
            { expiresIn: '30d' }
        );
        const refreshToken = jwt.sign(
            { 
                userId: user._id,
                username: user.username,
                'profile.nickname': user.profile?.nickname || user.username
            }, 
            JWT_SECRET, 
            { expiresIn: '90d' }
        );
        user.refreshTokens.push({ token: refreshToken });
        await user.save();
        res.json({ token, refreshToken });
        
    } catch (error) {
        logger.error(`Login error: ${error.message}`);
        res.status(500).json({ error: 'Login failed: ' + error.message });
    }
});


// ============================================
// POST /api/verify-email - التحقق من البريد الإلكتروني
// ============================================
app.post('/api/verify-email', [
    body('email').isEmail().withMessage('Valid email required'),
    body('otp').notEmpty().withMessage('OTP is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    const { email, otp } = req.body;
    
    try {
        const user = await User.findOne({ email, otp, otpExpires: { $gt: Date.now() } });
        if (!user) {
            return res.status(400).json({ error: 'Invalid or expired verification code' });
        }
        
        user.emailVerified = true;
        user.otp = null;
        user.otpExpires = null;
        await user.save();
        
        const token = jwt.sign(
            { 
                userId: user._id, 
                isAdmin: user.isAdmin,
                username: user.username,
                'profile.nickname': user.profile?.nickname || user.username
            }, 
            JWT_SECRET, 
            { expiresIn: '30d' }
        );
        const refreshToken = jwt.sign(
            { 
                userId: user._id,
                username: user.username,
                'profile.nickname': user.profile?.nickname || user.username
            }, 
            process.env.REFRESH_TOKEN_SECRET, 
            { expiresIn: '90d' }
        );
        user.refreshTokens.push({ token: refreshToken });
        await user.save();
        
        logger.info(`Email verified for user: ${email}`);
        
        res.json({ 
            message: 'Email verified successfully!', 
            token, 
            refreshToken 
        });
        
    } catch (error) {
        logger.error(`Email verification error: ${error.message}`);
        res.status(500).json({ error: 'Verification failed' });
    }
});

// ============================================
// POST /api/resend-verification - إعادة إرسال رمز التحقق
// ============================================
app.post('/api/resend-verification', [
    body('email').isEmail().withMessage('Valid email required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    const { email } = req.body;
    
    try {
        const user = await User.findOne({ email });
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        if (user.emailVerified) {
            return res.status(400).json({ error: 'Email already verified' });
        }
        
        const otp = Math.floor(100000 + Math.random() * 900000).toString();
        user.otp = otp;
        user.otpExpires = Date.now() + 10 * 60 * 1000;
        await user.save();
        
        // ✅ نرسل الـ response على طول
        res.json({ message: 'Verification code sent successfully' });
        
        // ✅ إرسال الإيميل عبر Brevo في الخلفية
        setTimeout(async () => {
            try {
                await sendEmailWithBrevo(
                    email,
                    'Your Verification Code - MGZon',
                    `<div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
                        <h2>Your Verification Code</h2>
                        <div style="background: #f3f4f6; padding: 20px; text-align: center; font-size: 32px; letter-spacing: 8px; font-weight: bold; border-radius: 10px;">
                            ${otp}
                        </div>
                        <p>This code is valid for <strong>10 minutes</strong>.</p>
                    </div>`,
                    `Your verification code is: ${otp}. Valid for 10 minutes.`
                );
                logger.info(`Resent verification OTP to ${email} via Brevo`);
            } catch (mailError) {
                logger.error('Failed to resend email via Brevo:', mailError);
            }
            
            console.log(`\n🔐 ========================================`);
            console.log(`🔐 RESENT CODE FOR ${email}: ${otp}`);
            console.log(`🔐 ========================================\n`);
        }, 0);
        
    } catch (error) {
        logger.error(`Resend verification error: ${error.message}`);
        res.status(500).json({ error: 'Failed to resend code' });
    }
});

const resetPasswordLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 5,
    message: 'Too many password reset attempts, please try again later.',
    validate: { trustProxy: false }
});
app.use('/api/reset-password', resetPasswordLimiter);
app.use('/api/forgot-password', resetPasswordLimiter);
const otpVerifyLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 5,
    message: 'Too many OTP verification attempts, please try again later.',
    validate: { trustProxy: false }
});
app.use('/api/login/verify-otp', otpVerifyLimiter);

app.post('/api/login/verify-otp', otpVerifyLimiter, async (req, res) => {
    const { email, otp } = req.body;
    try {
        const user = await User.findOne({ email, otp, otpExpires: { $gt: Date.now() } });
        if (!user) {
            return res.status(401).json({ error: 'Invalid or expired OTP' });
        }
        const token = jwt.sign(
            { 
                userId: user._id, 
                isAdmin: user.isAdmin,
                username: user.username,
                'profile.nickname': user.profile?.nickname || user.username
            }, 
            JWT_SECRET, 
            { expiresIn: '1h' }
        );
        const refreshToken = jwt.sign(
            { 
                userId: user._id,
                username: user.username,
                'profile.nickname': user.profile?.nickname || user.username
            }, 
            JWT_SECRET, 
            { expiresIn: '7d' }
        );
        user.refreshTokens.push({ token: refreshToken });
        user.otp = null;
        user.otpExpires = null;
        await user.save();
        res.json({ token, refreshToken });
    } catch (error) {
        logger.error(`OTP verification error: ${error.message}`);
        res.status(500).json({ error: 'OTP verification failed' });
    }
});

app.post('/api/register', [
    body('email').isEmail().withMessage('Invalid email format'),
    body('password').isLength({ min: 8 }).withMessage('Password must be at least 8 characters long'),
    body('username').optional().isLength({ min: 3 }).withMessage('Username must be at least 3 characters long')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    const { username, email, password } = req.body;
    try {
        const existingUser = await User.findOne({ email });
        if (existingUser) {
            return res.status(400).json({ error: 'Email already exists' });
        }
        
        const hashedPassword = await bcrypt.hash(password, 10);
        
        // ✅ إنشاء المستخدم مع emailVerified = false
        const user = await User.create({ 
            username, 
            email, 
            password: hashedPassword,
            emailVerified: false 
        });
        
        // ✅ توليد OTP
        const otp = Math.floor(100000 + Math.random() * 900000).toString();
        user.otp = otp;
        user.otpExpires = Date.now() + 10 * 60 * 1000;
        await user.save();
        
        // ✅ نرسل الـ response على طول
        res.status(201).json({ 
            message: 'Registration successful! Please verify your email with the OTP sent.',
            requiresVerification: true,
            email: email
        });
        
        // ✅ إرسال الإيميل عبر Brevo في الخلفية
        setTimeout(async () => {
            try {
                await sendEmailWithBrevo(
                    email,
                    'Verify Your Email - MGZon',
                    `<div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
                        <h1 style="color: #667eea;">Welcome to MGZon! 🎉</h1>
                        <p>Thank you for registering. Please verify your email address using the code below:</p>
                        <div style="background: #f3f4f6; padding: 20px; text-align: center; font-size: 32px; letter-spacing: 8px; font-weight: bold; border-radius: 10px;">
                            ${otp}
                        </div>
                        <p>This code is valid for <strong>10 minutes</strong>.</p>
                        <p>If you didn't create an account, please ignore this email.</p>
                        <hr>
                        <p style="color: #888; font-size: 12px;">MGZon - Your Digital Ecosystem</p>
                    </div>`,
                    `Welcome to MGZon! Your verification code is: ${otp}. Valid for 10 minutes.`
                );
                logger.info(`Verification OTP sent to ${email} via Brevo`);
            } catch (mailError) {
                logger.error('Failed to send verification email via Brevo:', mailError);
            }
            
            console.log(`\n🔐 ========================================`);
            console.log(`🔐 VERIFICATION CODE FOR ${email}: ${otp}`);
            console.log(`🔐 ========================================\n`);
        }, 0);
        
    } catch (error) {
        logger.error(`Registration error: ${error.message}`);
        res.status(500).json({ error: 'Server error during registration' });
    }
});
// app.get('/auth/google', passport.authenticate('google', { scope: ['profile', 'email'] }));
// app.get('/auth/facebook', passport.authenticate('facebook', { scope: ['email'] }));
// app.get('/auth/github', passport.authenticate('github', { scope: ['user:email'] }));

app.get('/api/projects', async (req, res) => {
    try {
        // ✅ جلب المشاريع العامة فقط (isPublic = true)
        const projects = await Project.find({ isPublic: true })
            .select('title description image rating stars links userId')
            .populate('userId', 'username profile.nickname profile.avatar');

        res.json({ success: true, data: projects });
    } catch (error) {
        logger.error(`Error fetching projects: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ success: false, error: 'Failed to fetch projects' });
    }
});

// server.js - تعديل جلب مشاريع مستخدم معين

app.get('/api/projects/:userId', authenticateToken, async (req, res) => {
    try {
        const targetUserId = req.params.userId;
        const currentUserId = req.user?.userId;

        // ✅ لو المستخدم بيشوف مشاريعه هو - يشوف كل حاجة
        // ✅ لو المستخدم بيشوف مشاريع غيره - يشوف العامة فقط
        const filter = { userId: targetUserId };

        if (targetUserId !== currentUserId) {
            filter.isPublic = true; // غير المالك يشوف العامة فقط
        }

        const projects = await Project.find(filter)
            .select('title description image rating stars links isPublic');

        res.json(projects);
    } catch (error) {
        logger.error(`Error fetching projects for user ${req.params.userId}: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to fetch projects' });
    }
});


function isAdmin(req, res, next) {
    if (!req.user.isAdmin) {
        const error = new Error('Unauthorized: Admin access required');
        Sentry.captureException(error, {
            user: { id: req.user.userId, email: req.user.email },
            extra: { endpoint: req.originalUrl, method: req.method }
        });
        return res.sendStatus(403);
    }
    next();
}

// للسماح للمستخدمين العاديين بالانشاء 


app.post('/api/projects', authenticateToken, [
    body('title').notEmpty().withMessage('Title is required'),
    body('description').notEmpty().withMessage('Description is required'),
    body('image').optional().isURL().withMessage('Image must be a valid URL'),
    body('rating').optional().notEmpty().withMessage('Rating cannot be empty'),
    body('isPublic').optional().isBoolean().withMessage('isPublic must be a boolean'), // ✅ إضافة

    body('stars').optional().isInt({ min: 0, max: 5 }).withMessage('Stars must be between 0 and 5'),
    body('links').isArray({ min: 0 }).withMessage('Links must be an array'),
    body('links.*.option').notEmpty().withMessage('Link option is required'),
    body('links.*.value').isURL().withMessage('Link value must be a valid URL'),
    body('links.*.isPrivate').optional().isBoolean().withMessage('isPrivate must be a boolean')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    const { title, description, image, rating, stars, links, isPublic } = req.body;
    try {
        const project = new Project({
            title,
            description,
            image,
            rating,
            stars,
            links,
            userId: req.user.userId, // ربط المشروع بالمستخدم
            isPublic: isPublic !== undefined ? isPublic : true // ✅ القيمة الافتراضية true

        });
        await project.save();

        await User.findByIdAndUpdate(req.user.userId, {
            $push: { 'profile.projects': project }
        });


        logger.info(`Project created by user ${req.user.userId}: ${title}`);
        res.status(201).json({ success: true, data: project });
    } catch (error) {
        logger.error(`Error saving project: ${error.message}`);
        Sentry.captureException(error, { user: { id: req.user.userId, email: req.user.email } });
        res.status(400).json({ success: false, error: 'Failed to save project: ' + error.message });
    }
});


// GET /api/users/trending - جلب المستخدمين الرائجين
app.get('/api/users/trending', async (req, res) => {
    try {
        const { limit = 10 } = req.query;
        
        // Get users with most followers
        const users = await User.aggregate([
            { $match: { 'profile.isPublic': true } },
            { $lookup: {
                from: 'follows',
                localField: '_id',
                foreignField: 'followingId',
                as: 'followers'
            }},
            { $addFields: { followersCount: { $size: '$followers' } } },
            { $sort: { followersCount: -1 } },
            { $limit: parseInt(limit) },
            { $project: {
                username: 1,
                profile: 1,
                followersCount: 1
            }}
        ]);
        
        res.json({ success: true, data: users });
    } catch (error) {
        logger.error(`Error fetching trending users: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch trending users' });
    }
});

// ============================================
// GET /api/users/explore - اكتشاف المستخدمين
// ============================================
app.get('/api/users/explore', authenticateToken, async (req, res) => {
    try {
        const { type = 'suggested', page = 1, limit = 20 } = req.query;
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        let query = {};
        let sort = {};
        
        // Get users that current user follows
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        }).select('followingId');
        const followingIds = following.map(f => f.followingId);
        
        switch (type) {
            case 'suggested':
                // Users not followed, with most followers first
                query = { 
                    _id: { $nin: [...followingIds, req.user.userId] },
                    'profile.isPublic': true 
                };
                sort = { 'stats.followers': -1 };
                break;
            case 'popular':
                // Users with most followers
                query = { 'profile.isPublic': true };
                sort = { 'stats.followers': -1 };
                break;
            case 'recent':
                // Recently joined users
                query = { 'profile.isPublic': true };
                sort = { createdAt: -1 };
                break;
            case 'following':
                // Users that current user follows
                query = { _id: { $in: followingIds } };
                sort = { createdAt: -1 };
                break;
        }
        
        const users = await User.find(query)
            .select('username profile isAdmin createdAt')
            .sort(sort)
            .skip(skip)
            .limit(parseInt(limit))
            .lean();
        
        // Add stats for each user
        const usersWithStats = await Promise.all(users.map(async (user) => {
            const [postsCount, followersCount, followingCount] = await Promise.all([
                Post.countDocuments({ userId: user._id }),
                Follow.countDocuments({ followingId: user._id, status: 'accepted' }),
                Follow.countDocuments({ followerId: user._id, status: 'accepted' })
            ]);
            
            return {
                ...user,
                isFollowing: followingIds.includes(user._id.toString()),
                stats: {
                    posts: postsCount,
                    followers: followersCount,
                    following: followingCount
                }
            };
        }));
        
        res.json({
            success: true,
            data: usersWithStats,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total: await User.countDocuments(query)
            }
        });
    } catch (error) {
        logger.error(`Error exploring users: ${error.message}`);
        res.status(500).json({ error: 'Failed to explore users' });
    }
});

// GET /api/users/suggestions - اقتراحات مستخدمين للمتابعة
app.get('/api/users/suggestions', authenticateToken, async (req, res) => {
    try {
        const { limit = 10 } = req.query;
        
        // Get users that current user follows
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        }).select('followingId');
        
        const followingIds = following.map(f => f.followingId);
        followingIds.push(req.user.userId); // Exclude self
        
        // Get users not followed, with most followers
        const suggestions = await User.aggregate([
            { $match: { 
                _id: { $nin: followingIds },
                'profile.isPublic': true 
            }},
            { $lookup: {
                from: 'follows',
                localField: '_id',
                foreignField: 'followingId',
                as: 'followers'
            }},
            { $addFields: { followersCount: { $size: '$followers' } } },
            { $sort: { followersCount: -1 } },
            { $limit: parseInt(limit) },
            { $project: {
                username: 1,
                profile: 1,
                followersCount: 1
            }}
        ]);
        
        res.json({ success: true, data: suggestions });
    } catch (error) {
        logger.error(`Error fetching suggestions: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch suggestions' });
    }
});

// ============================================
// GET /api/trending/topics - جلب المواضيع الرائجة
// ============================================
app.get('/api/trending/topics', authenticateToken, async (req, res) => {
    try {
        // Get trending topics from posts (most used tags + hashtags)
        const trendingTopics = await Post.aggregate([
            // Filter posts from last 7 days
            {
                $match: {
                    createdAt: { $gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) },
                    visibility: { $in: ['public', 'followers'] }
                }
            },
            // Unwind tags array
            {
                $unwind: {
                    path: '$tags',
                    preserveNullAndEmptyArrays: true
                }
            },
            // Filter out empty tags
            {
                $match: {
                    tags: { $ne: '', $exists: true }
                }
            },
            // Group by tag and count
            {
                $group: {
                    _id: { $toLower: '$tags' },
                    count: { $sum: 1 },
                    posts: { $push: '$_id' }
                }
            },
            // Sort by count descending
            {
                $sort: { count: -1 }
            },
            // Limit to top 10
            {
                $limit: 10
            },
            // Project final structure
            {
                $project: {
                    topic: '$_id',
                    count: 1,
                    _id: 0
                }
            }
        ]);

        // If no tags found, return default trending topics
        if (trendingTopics.length === 0) {
            const defaultTopics = [
                { topic: 'Remote Jobs', count: 1234 },
                { topic: 'AI in Tech', count: 892 },
                { topic: 'Career Growth', count: 654 },
                { topic: 'Soft Skills', count: 521 },
                { topic: 'Freelancing Tips', count: 487 },
                { topic: 'Web Development', count: 432 },
                { topic: 'Data Science', count: 398 },
                { topic: 'Leadership', count: 345 },
                { topic: 'Work Life Balance', count: 312 },
                { topic: 'Networking', count: 289 }
            ];
            return res.json(defaultTopics);
        }

        res.json(trendingTopics);
    } catch (error) {
        logger.error(`Error fetching trending topics: ${error.message}`);
        // Return default topics on error
        const defaultTopics = [
            { topic: 'Remote Jobs', count: 1234 },
            { topic: 'AI in Tech', count: 892 },
            { topic: 'Career Growth', count: 654 },
            { topic: 'Soft Skills', count: 521 },
            { topic: 'Freelancing Tips', count: 487 }
        ];
        res.json(defaultTopics);
    }
});

// ============================================
// GET /api/trending/posts - جلب المنشورات الرائجة
// ============================================
app.get('/api/trending/posts', authenticateToken, async (req, res) => {
    try {
        const { limit = 10 } = req.query;
        
        const trendingPosts = await Post.find({
            visibility: { $in: ['public', 'followers'] },
            'likes.1': { $exists: true } // Posts with at least 2 likes
        })
        .sort({ likes: -1, createdAt: -1 })
        .limit(parseInt(limit))
        .populate('userId', 'username profile.nickname profile.avatar')
        .lean();
        
        const enrichedPosts = trendingPosts.map(post => ({
            ...post,
            isLiked: false,
            isSaved: false,
            likesCount: post.likes?.length || 0,
            commentsCount: post.comments?.length || 0,
            sharesCount: post.shares?.length || 0
        }));
        
        res.json({ success: true, data: enrichedPosts });
    } catch (error) {
        logger.error(`Error fetching trending posts: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch trending posts' });
    }
});


app.put('/api/users/:userId', authenticateToken, isAdmin, [
    param('userId').isMongoId().withMessage('Invalid user ID'),
    body('role').isIn(['User', 'Admin']).withMessage('Role must be either User or Admin')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    const { userId } = req.params;
    const { role } = req.body;
    try {
        const user = await User.findByIdAndUpdate(
            userId,
            { role },
            { new: true, runValidators: true }
        ).select('username email profile role');
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }
        res.json({ success: true, data: user });
    } catch (error) {
        logger.error(`Error updating user ${userId}: ${error.message}`);
        Sentry.captureException(error);
        res.status(400).json({ success: false, error: 'Failed to update user: ' + error.message });
    }
});



// ============================================
// GET /api/projects/:projectId - جلب مشروع معين (عام)
// ============================================
app.get('/api/projects/:projectId', async (req, res) => {
    try {
        const project = await Project.findById(req.params.projectId)
            .populate('userId', 'username profile.nickname profile.avatar');
        
        if (!project) {
            return res.status(404).json({ error: 'Project not found' });
        }
        
        // ✅ التحقق من الخصوصية - المشاريع العامة فقط للزوار
        if (!project.isPublic) {
            // التحقق إذا كان المستخدم مسجل وصاحب المشروع
            const authHeader = req.headers['authorization'];
            const token = authHeader && authHeader.split(' ')[1];
            
            if (!token) {
                return res.status(403).json({ error: 'This project is private' });
            }
            
            try {
                const payload = jwt.verify(token, process.env.JWT_SECRET);
                const isOwner = payload.userId === project.userId._id.toString();
                const isAdminUser = payload.isAdmin;
                
                if (!isOwner && !isAdminUser) {
                    return res.status(403).json({ error: 'This project is private' });
                }
            } catch (err) {
                return res.status(403).json({ error: 'Invalid or expired token' });
            }
        }
        
        res.json(project);
        
    } catch (error) {
        logger.error(`Error fetching project: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch project' });
    }
});

app.put('/api/projects/:projectId', authenticateToken, [
    body('title').optional().notEmpty().withMessage('Title cannot be empty'),
    body('description').optional().notEmpty().withMessage('Description cannot be empty'),
    body('image').optional().isURL().withMessage('Image must be a valid URL'),
    body('isPublic').optional().isBoolean().withMessage('isPublic must be a boolean'),

    body('rating').optional().notEmpty().withMessage('Rating cannot be empty'),
    body('stars').optional().isInt({ min: 0, max: 5 }).withMessage('Stars must be between 0 and 5'),
    body('links').optional().isArray({ min: 0 }).withMessage('Links must be an array'),
    body('links.*.option').optional().notEmpty().withMessage('Link option cannot be empty'),
    body('links.*.value').optional().isURL().withMessage('Link value must be a valid URL'),
    body('links.*.isPrivate').optional().isBoolean().withMessage('isPrivate must be a boolean')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    const { projectId } = req.params;
    const { title, description, image, rating, stars, links } = req.body;
    try {
        const project = await Project.findById(projectId);
        if (!project) {
            return res.status(404).json({ success: false, error: 'Project not found' });
        }
        // التحقق من أن المستخدم هو صاحب المشروع أو أدمن
        if (project.userId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ success: false, error: 'Unauthorized to update this project' });
        }
        // تحديث الحقول المرسلة فقط
        if (title) project.title = title;
        if (description) project.description = description;
        if (image) project.image = image;
        if (rating) project.rating = rating;
        if (stars) project.stars = stars;
        if (links) project.links = links;
        if (isPublic !== undefined) project.isPublic = isPublic;

        await project.save();

        await User.findOneAndUpdate(
            {
                _id: req.user.userId,
                'profile.projects._id': projectId
            },
            {
                $set: {
                    'profile.projects.$': project
                }
            }
        );


        logger.info(`Project ${projectId} updated by user ${req.user.userId}`);
        res.json({ success: true, data: project });
    } catch (error) {
        logger.error(`Error updating project ${projectId}: ${error.message}`);
        Sentry.captureException(error, { user: { id: req.user.userId, email: req.user.email } });
        res.status(400).json({ success: false, error: 'Failed to update project: ' + error.message });
    }
});


// ============================================
// DELETE /api/projects/:projectId - حذف مشروع (متكامل)
// ============================================
app.delete('/api/projects/:projectId', authenticateToken, async (req, res) => {
    const { projectId } = req.params;
    
    try {
        // ✅ 1. التحقق من وجود المشروع في Project collection
        const project = await Project.findById(projectId);
        if (!project) {
            return res.status(404).json({ success: false, error: 'Project not found' });
        }
        
        // ✅ 2. التحقق من ملكية المشروع
        if (project.userId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ success: false, error: 'Unauthorized to delete this project' });
        }
        
        // ✅ 3. حذف من Project collection
        await Project.findByIdAndDelete(projectId);
        
        // ✅ 4. حذف من user.profile.projects
        const user = await User.findById(req.user.userId);
        if (user && user.profile && user.profile.projects) {
            // إزالة المشروع من قائمة المشاريع (سواء كان Array أو Object)
            if (Array.isArray(user.profile.projects)) {
                user.profile.projects = user.profile.projects.filter(p => 
                    p._id && p._id.toString() !== projectId
                );
            } else if (typeof user.profile.projects === 'object') {
                // إذا كان Object، حوله إلى Array ثم فلتر
                const projectsArray = Object.values(user.profile.projects);
                const filteredProjects = projectsArray.filter(p => 
                    p._id && p._id.toString() !== projectId
                );
                user.profile.projects = filteredProjects;
            }
            await user.save();
            logger.info(`Project ${projectId} removed from user ${req.user.userId} profile`);
        }
        
        // ✅ 5. حذف التعليقات المرتبطة بالمشروع
        const deleteCommentsResult = await Comment.deleteMany({ projectId: projectId });
        if (deleteCommentsResult.deletedCount > 0) {
            logger.info(`Deleted ${deleteCommentsResult.deletedCount} comments for project ${projectId}`);
        }
        
        logger.info(`Project ${projectId} deleted successfully by user ${req.user.userId}`);
        res.json({ success: true, message: 'Project deleted successfully' });
        
    } catch (error) {
        logger.error(`Error deleting project ${projectId}: ${error.message}`);
        Sentry.captureException(error, { user: { id: req.user.userId, email: req.user.email } });
        res.status(500).json({ success: false, error: 'Failed to delete project: ' + error.message });
    }
});

// ============================================
// GET /api/comments/:projectId - جلب التعليقات مع الردود
// ============================================
app.get('/api/comments/:projectId', async (req, res) => {
    try {
        const { projectId } = req.params;
        
        // ✅ التحقق من صحة ObjectId
        if (!mongoose.Types.ObjectId.isValid(projectId)) {
            return res.status(400).json({ success: false, error: 'Invalid project ID' });
        }
        
        const mainComments = await Comment.find({ 
            projectId: new mongoose.Types.ObjectId(projectId),
            parentCommentId: null,
            hidden: false
        })
        .populate('userId', 'username profile.nickname profile.avatar')
        .sort({ timestamp: -1 });
        
        const commentsWithReplies = await Promise.all(mainComments.map(async (comment) => {
            const replies = await Comment.find({ 
                parentCommentId: comment._id,
                hidden: false
            })
            .populate('userId', 'username profile.nickname profile.avatar')
            .sort({ timestamp: 1 });
            
            return {
                ...comment.toObject(),
                replies: replies,
                repliesCount: replies.length
            };
        }));
        
        res.json({ success: true, data: commentsWithReplies });
        
    } catch (error) {
        logger.error(`Error fetching comments: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to fetch comments' });
    }
});
// ============================================

// ============================================
// PUT /api/notifications/read-all - تعليم جميع الإشعارات كمقروءة
// ============================================
app.put('/api/notifications/read-all', authenticateToken, async (req, res) => {
    try {
        // ✅ 1. تعليم الإشعارات في Notification model
        await Notification.updateMany(
            { userId: req.user.userId, read: false },
            { $set: { read: true } }
        );
        
        // ✅ 2. تعليم الإشعارات في User.notifications
        const user = await User.findById(req.user.userId);
        if (user && user.notifications) {
            user.notifications.forEach(n => { n.read = true; });
            await user.save();
        }
        
        res.json({ success: true });
        
    } catch (error) {
        logger.error(`Error marking all notifications as read: ${error.message}`);
        res.status(500).json({ error: 'Failed to mark notifications as read' });
    }
});

// ============================================
// GET /api/notifications/unread-count - عدد الإشعارات غير المقروءة
// ============================================
app.get('/api/notifications/unread-count', authenticateToken, async (req, res) => {
    try {
        // ✅ 1. إحصائيات من Notification model
        const advancedUnread = await Notification.countDocuments({
            userId: req.user.userId,
            read: false
        });
        
        // ✅ 2. إحصائيات من User.notifications
        const user = await User.findById(req.user.userId).select('notifications');
        const simpleUnread = (user?.notifications || []).filter(n => !n.read).length;
        
        res.json({ 
            success: true, 
            count: advancedUnread + simpleUnread,
            details: {
                advanced: advancedUnread,
                simple: simpleUnread
            }
        });
        
    } catch (error) {
        logger.error(`Error fetching unread count: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch unread count' });
    }
});

app.get('/api/comments', authenticateToken, isAdmin, async (req, res) => {
    try {
        const comments = await Comment.find()
            .populate('userId', 'username email')
            .populate('projectId', 'title')
            .select('projectId userId rating text timestamp replies');
        const sanitizedComments = comments.map(comment => ({
            ...comment._doc,
            userId: comment.userId
                ? { username: comment.userId.username || 'Anonymous', email: comment.userId.email || '' }
                : { username: 'Anonymous', email: '' },
            projectTitle: comment.projectId ? comment.projectId.title : 'Unknown Project'
        }));
        res.json({ success: true, data: sanitizedComments });
    } catch (error) {
        logger.error(`Error fetching comments: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ success: false, error: 'Failed to load comments: ' + error.message });
    }
});


app.put('/api/user/skills/:skillId', authenticateToken, [
    body('name').optional().notEmpty().withMessage('Skill name cannot be empty'),
    body('proficiency').optional().isInt({ min: 1, max: 100 }).withMessage('Proficiency must be between 1 and 100')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    const { skillId } = req.params;
    const { name, proficiency } = req.body;
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }
        const skill = user.skills.id(skillId);
        if (!skill) {
            return res.status(404).json({ success: false, error: 'Skill not found' });
        }
        if (name) skill.name = name;
        if (proficiency) skill.proficiency = proficiency;
        await user.save();
        logger.info(`Skill ${skillId} updated for user ${req.user.userId}`);
        res.json({ success: true, data: user.skills });
    } catch (error) {
        logger.error(`Error updating skill ${skillId} for user ${req.user.userId}: ${error.message}`);
        Sentry.captureException(error, { user: { id: req.user.userId, email: req.user.email } });
        res.status(400).json({ success: false, error: 'Failed to update skill: ' + error.message });
    }
});

app.delete('/api/user/skills/:skillId', authenticateToken, async (req, res) => {
    const { skillId } = req.params;
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }
        const skill = user.skills.id(skillId);
        if (!skill) {
            return res.status(404).json({ success: false, error: 'Skill not found' });
        }
        skill.remove();
        await user.save();
        logger.info(`Skill ${skillId} deleted for user ${req.user.userId}`);
        res.json({ success: true, message: 'Skill deleted successfully' });
    } catch (error) {
        logger.error(`Error deleting skill ${skillId} for user ${req.user.userId}: ${error.message}`);
        Sentry.captureException(error, { user: { id: req.user.userId, email: req.user.email } });
        res.status(500).json({ success: false, error: 'Failed to delete skill: ' + error.message });
    }
});

// ============================================
// POST /api/comments - إضافة تعليق جديد (مع projectId كـ string/index)
// ============================================
app.post('/api/comments', authenticateToken, [
    body('projectId').notEmpty().withMessage('Project ID is required'),
    body('projectOwnerId').notEmpty().withMessage('Project Owner ID is required'),
    body('rating').isInt({ min: 1, max: 5 }).withMessage('Rating must be between 1 and 5'),
    body('text').notEmpty().withMessage('Comment text is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    
    const { projectId, projectOwnerId, rating, text } = req.body;
    
    try {
        // ✅ التحقق من صحة projectId و projectOwnerId
        if (!mongoose.Types.ObjectId.isValid(projectId)) {
            return res.status(400).json({ success: false, error: 'Invalid project ID' });
        }
        if (!mongoose.Types.ObjectId.isValid(projectOwnerId)) {
            return res.status(400).json({ success: false, error: 'Invalid project owner ID' });
        }
        
        const comment = new Comment({ 
            projectId: new mongoose.Types.ObjectId(projectId),
            projectOwnerId: new mongoose.Types.ObjectId(projectOwnerId),
            userId: req.user.userId, 
            rating: rating, 
            text: text, 
            timestamp: new Date()
        });
        
        await comment.save();
        
        res.status(201).json({ success: true, data: comment });
        
    } catch (error) {
        logger.error(`Error saving comment: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to save comment: ' + error.message });
    }
});

// ============================================
// POST /api/comments/:commentId/reply - رد على تعليق مع إشعار
// ============================================
app.post('/api/comments/:commentId/reply', authenticateToken, [
    body('text').notEmpty().withMessage('Reply text is required'),
    body('rating').optional().isInt({ min: 0, max: 5 })
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    
    const { commentId } = req.params;
    const { text, rating } = req.body;
    
    try {
        const parentComment = await Comment.findById(commentId).populate('userId', 'email username profile.nickname');
        if (!parentComment) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        let finalRating = rating;
        if (!finalRating || finalRating < 1) {
            finalRating = parentComment.rating >= 1 ? parentComment.rating : 1;
        }
        
        const reply = new Comment({
            projectId: parentComment.projectId,
            projectOwnerId: parentComment.projectOwnerId,
            userId: req.user.userId,
            rating: finalRating,
            text: text,
            parentCommentId: commentId,
            timestamp: new Date()
        });
        
        await reply.save();
        
        parentComment.replies.push(reply._id);
        await parentComment.save();
        
        // إشعار لصاحب التعليق الأصلي
        if (parentComment.userId._id.toString() !== req.user.userId) {
            const replyAuthor = await User.findById(req.user.userId).select('username profile.nickname');
            const replyAuthorName = replyAuthor?.profile?.nickname || replyAuthor?.username || 'Someone';
            
            const notificationMessage = `${replyAuthorName} replied to your comment: "${text.substring(0, 60)}${text.length > 60 ? '...' : ''}"`;
            const notificationLink = `/project.html?id=${parentComment.projectId}&comment=${reply._id}`;
            
            await User.findByIdAndUpdate(parentComment.userId._id, {
                $push: {
                    notifications: {
                        message: notificationMessage,
                        type: 'reply',
                        link: notificationLink,
                        read: false,
                        createdAt: new Date()
                    }
                }
            });
        }
        
        res.status(201).json({ success: true, data: reply });
        
    } catch (error) {
        logger.error(`Error adding reply: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to add reply: ' + error.message });
    }
});

// Helper function for email escaping
function escapeHtmlForEmail(str) {
    if (!str) return '';
    return str.replace(/[&<>]/g, m => m === '&' ? '&amp;' : m === '<' ? '&lt;' : '&gt;');
}

// ============================================
// DELETE /api/comments/:commentId - حذف تعليق (لصاحب التعليق أو الأدمن أو صاحب المشروع)
// ============================================
app.delete('/api/comments/:commentId', authenticateToken, async (req, res) => {
    const { commentId } = req.params;
    
    try {
        const comment = await Comment.findById(commentId);
        if (!comment) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        // ✅ التحقق من صلاحية الحذف باستخدام ObjectId
        let isProjectOwner = false;
        
        // البحث عن صاحب المشروع من خلال الـ Project collection أو الـ User
        if (comment.projectOwnerId) {
            isProjectOwner = comment.projectOwnerId.toString() === req.user.userId;
        } else {
            // Fallback للمشاريع القديمة (بعد الترحيل)
            const project = await Project.findById(comment.projectId);
            isProjectOwner = project && project.userId.toString() === req.user.userId;
        }
        
        const isCommentOwner = comment.userId.toString() === req.user.userId;
        const isAdminUser = req.user.isAdmin;
        
        if (!isCommentOwner && !isAdminUser && !isProjectOwner) {
            return res.status(403).json({ success: false, error: 'Unauthorized to delete this comment' });
        }
        
        // حذف جميع الردود أولاً
        if (comment.replies && comment.replies.length > 0) {
            await Comment.deleteMany({ _id: { $in: comment.replies } });
        }
        
        // حذف الرد من القائمة في التعليق الأصلي (إن وجد)
        if (comment.parentCommentId) {
            await Comment.updateOne(
                { _id: comment.parentCommentId },
                { $pull: { replies: comment._id } }
            );
        }
        
        await Comment.findByIdAndDelete(commentId);
        
        logger.info(`Comment ${commentId} deleted by user ${req.user.userId}`);
        res.json({ success: true, message: 'Comment deleted successfully' });
        
    } catch (error) {
        logger.error(`Error deleting comment ${commentId}: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to delete comment: ' + error.message });
    }
});

// ============================================
// POST /api/comments/:commentId/report - التبليغ عن تعليق مخالف
// ============================================
app.post('/api/comments/:commentId/report', authenticateToken, async (req, res) => {
    const { commentId } = req.params;
    const { reason } = req.body;
    
    try {
        const comment = await Comment.findById(commentId).populate('userId', 'username email profile.nickname');
        if (!comment) {
            return res.status(404).json({ error: 'Comment not found' });
        }
        
        // منع التبليغ عن تعليقك الخاص
        if (comment.userId._id.toString() === req.user.userId) {
            return res.status(400).json({ error: 'You cannot report your own comment' });
        }
        
        // منع التبليغ المتكرر من نفس المستخدم
        if (comment.reports?.some(r => r.userId.toString() === req.user.userId)) {
            return res.status(400).json({ error: 'You already reported this comment' });
        }
        
        // إضافة التبليغ
        comment.reports = comment.reports || [];
        comment.reports.push({
            userId: req.user.userId,
            reason: reason || 'No reason provided',
            reportedAt: new Date(),
            reporterUsername: req.user.username,
            resolved: false
        });
        comment.reportCount = (comment.reportCount || 0) + 1;
        
        await comment.save();
        
        // ✅ رابط المشروع باستخدام ObjectId
        const projectLink = `/project.html?id=${comment.projectId}`;
        
        // ✅ إشعار لصاحب التعليق أنه تم التبليغ على تعليقه (تنبيه)
        if (comment.userId._id.toString() !== req.user.userId) {
            const commentOwner = await User.findById(comment.userId._id);
            if (commentOwner) {
                commentOwner.notifications = commentOwner.notifications || [];
                commentOwner.notifications.push({
                    message: `⚠️ Your comment has been reported by ${req.user.username}: "${comment.text.substring(0, 60)}${comment.text.length > 60 ? '...' : ''}"`,
                    type: 'warning',
                    link: `${projectLink}&comment=${comment._id}`,
                    read: false,
                    createdAt: new Date(),
                    metadata: { commentId: comment._id, projectId: comment.projectId, reportCount: comment.reportCount }
                });
                await commentOwner.save();
            }
        }
        
        // ✅ إشعار للمشرفين (جمع كل المشرفين)
        const adminUsers = await User.find({ isAdmin: true });
        for (const admin of adminUsers) {
            admin.notifications = admin.notifications || [];
            admin.notifications.push({
                message: `🚨 New Report: "${req.user.username}" reported comment by "${comment.userId.username || comment.userId.profile?.nickname}": "${comment.text.substring(0, 80)}${comment.text.length > 80 ? '...' : ''}" (${comment.reportCount}/3)`,
                type: 'admin_report',
                link: `/admin/comments?highlight=${comment._id}`,
                read: false,
                createdAt: new Date(),
                metadata: { 
                    commentId: comment._id, 
                    reporterId: req.user.userId, 
                    reportedUserId: comment.userId._id,
                    projectId: comment.projectId,
                    reportCount: comment.reportCount,
                    reason: reason || 'No reason provided'
                }
            });
            await admin.save();
            
            // ✅ إرسال بريد إلكتروني للمشرفين عبر Brevo
            try {
                await sendEmailWithBrevo(
                    
                    admin.email,
                    '🚨 New Comment Report - MGZon',
                    `
                    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
                        <h2 style="color: #ef4444;">New Report Submitted</h2>
                        <p><strong>Reported by:</strong> ${req.user.username}</p>
                        <p><strong>Comment author:</strong> ${comment.userId.username || comment.userId.profile?.nickname}</p>
                        <p><strong>Reason:</strong> ${reason || 'No reason provided'}</p>
                        <p><strong>Total reports on this comment:</strong> ${comment.reportCount}/3</p>
                        <div style="background: #f3f4f6; padding: 12px; border-radius: 8px; margin: 16px 0;">
                            <p><strong>Comment content:</strong></p>
                            <p>"${comment.text}"</p>
                        </div>
                        <a href="${FRONTEND_URL}/admin/comments?highlight=${comment._id}" 
                           style="display: inline-block; background: #3b82f6; color: white; padding: 10px 20px; border-radius: 8px; text-decoration: none;">
                            Review Report
                        </a>
                    </div>
                    `,
                    `New report on comment by ${comment.userId.username} from user ${req.user.username}. Reason: ${reason || 'No reason provided'}`
                );
            } catch (emailError) {
                logger.error(`Failed to send admin email: ${emailError.message}`);
            }
        }
        
        // ✅ إذا وصل عدد التقارير لـ 3، إخفاء التعليق تلقائياً
        let hiddenMessage = '';
        if (comment.reportCount >= 3) {
            comment.hidden = true;
            await comment.save();
            hiddenMessage = ' Comment has been hidden.';
            
            // إشعار لصاحب التعليق بأن تعليقه تم إخفاؤه
            const commentOwner = await User.findById(comment.userId._id);
            if (commentOwner) {
                commentOwner.notifications = commentOwner.notifications || [];
                commentOwner.notifications.push({
                    message: `🔒 Your comment has been hidden due to ${comment.reportCount} reports: "${comment.text.substring(0, 60)}${comment.text.length > 60 ? '...' : ''}"`,
                    type: 'warning',
                    link: projectLink,
                    read: false,
                    createdAt: new Date(),
                    metadata: { commentId: comment._id, projectId: comment.projectId, action: 'hidden' }
                });
                await commentOwner.save();
            }
            
            logger.info(`Comment ${commentId} hidden due to ${comment.reportCount} reports`);
        }
        
        // ✅ إشعار للمبلغ عن نجاح التبليغ
        const reporter = await User.findById(req.user.userId);
        if (reporter) {
            reporter.notifications = reporter.notifications || [];
            reporter.notifications.push({
                message: `✅ Report submitted successfully${hiddenMessage} (${comment.reportCount}/3)`,
                type: 'info',
                link: `${projectLink}&comment=${comment._id}`,
                read: false,
                createdAt: new Date(),
                metadata: { commentId: comment._id, projectId: comment.projectId, reportCount: comment.reportCount }
            });
            await reporter.save();
        }
        
        res.json({ 
            success: true, 
            message: comment.reportCount >= 3 ? 'Comment has been hidden due to multiple reports' : 'Report submitted successfully',
            reportCount: comment.reportCount,
            hidden: comment.hidden || false
        });
        
    } catch (error) {
        logger.error(`Error reporting comment: ${error.message}`);
        res.status(500).json({ error: 'Failed to report comment' });
    }
});

// ============================================
// PUT /api/admin/comments/:commentId/resolve-report - حل تبليغ (للمشرف فقط)
// ============================================
app.put('/api/admin/comments/:commentId/resolve-report', authenticateToken, isAdmin, async (req, res) => {
    const { commentId } = req.params;
    const { action, adminNote } = req.body; // action: 'keep', 'hide', 'delete'
    
    try {
        const comment = await Comment.findById(commentId).populate('userId', 'username email profile.nickname');
        if (!comment) {
            return res.status(404).json({ error: 'Comment not found' });
        }
        
        // ✅ رابط المشروع باستخدام ObjectId
        const projectLink = `/project.html?id=${comment.projectId}`;
        
        let actionMessage = '';
        let actionColor = '';
        
        // تحديث حالة التبليغات
        if (comment.reports && comment.reports.length > 0) {
            comment.reports.forEach(r => {
                r.resolved = true;
                r.resolvedAt = new Date();
                r.resolvedBy = req.user.userId;
                r.adminNote = adminNote || '';
            });
        }
        
        // تطبيق الإجراء المطلوب
        if (action === 'hide') {
            comment.hidden = true;
            actionMessage = 'Comment has been hidden';
            actionColor = '⚠️';
        } else if (action === 'delete') {
            await Comment.findByIdAndDelete(commentId);
            
            // إشعار لصاحب التعليق بأن تعليقه تم حذفه
            if (comment.userId) {
                const user = await User.findById(comment.userId._id);
                if (user) {
                    user.notifications = user.notifications || [];
                    user.notifications.push({
                        message: `🗑️ Your comment has been deleted by admin due to policy violation: "${comment.text.substring(0, 60)}${comment.text.length > 60 ? '...' : ''}"`,
                        type: 'admin_action',
                        link: projectLink,
                        read: false,
                        createdAt: new Date(),
                        metadata: { commentId: comment._id, projectId: comment.projectId, action: 'delete' }
                    });
                    await user.save();
                    
                    // إرسال بريد إلكتروني
                    try {
                        await sendEmailWithBrevo(
                            user.email,
                            'Your Comment Was Deleted - MGZon',
                            `<div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
                                <h2 style="color: #ef4444;">Comment Deleted by Admin</h2>
                                <p>Your comment on a project has been deleted by an administrator due to violating our community guidelines.</p>
                                <div style="background: #f3f4f6; padding: 12px; border-radius: 8px; margin: 16px 0;">
                                    <p><strong>Your comment:</strong></p>
                                    <p>"${comment.text}"</p>
                                </div>
                                <p><strong>Admin note:</strong> ${adminNote || 'No additional notes'}</p>
                                <p>If you believe this was a mistake, please contact support.</p>
                            </div>`,
                            `Your comment "${comment.text.substring(0, 100)}" was deleted by an administrator.`
                        );
                    } catch (emailError) {
                        logger.error(`Failed to send deletion email: ${emailError.message}`);
                    }
                }
            }
            
            return res.json({ success: true, message: 'Comment deleted successfully', action: 'delete' });
        } else {
            // 'keep' - يبقى ظاهر
            comment.hidden = false;
            actionMessage = 'Comment remains visible';
            actionColor = '✅';
        }
        
        await comment.save();
        
        // ✅ إشعار لصاحب التعليق بقرار المشرف
        if (comment.userId) {
            const user = await User.findById(comment.userId._id);
            if (user) {
                user.notifications = user.notifications || [];
                user.notifications.push({
                    message: `${actionColor} Report resolved: ${actionMessage}. ${adminNote ? `Note: ${adminNote}` : ''}`,
                    type: action === 'keep' ? 'info' : 'warning',
                    link: `${projectLink}&comment=${comment._id}`,
                    read: false,
                    createdAt: new Date(),
                    metadata: { commentId: comment._id, projectId: comment.projectId, action: action }
                });
                await user.save();
                
                // ✅ إرسال بريد إلكتروني لصاحب التعليق
                try {
                    await sendEmailWithBrevo(
                        user.email,
                        `Report Result on Your Comment - MGZon`,
                        `
                        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
                            <h2 style="color: ${action === 'keep' ? '#10b981' : '#ef4444'};">${actionColor} Report Resolved</h2>
                            <p>An administrator has reviewed the report on your comment:</p>
                            <div style="background: #f3f4f6; padding: 12px; border-radius: 8px; margin: 16px 0;">
                                <p><strong>Your comment:</strong></p>
                                <p>"${comment.text}"</p>
                            </div>
                            <p><strong>Decision:</strong> ${action === 'keep' ? 'Comment kept visible' : 'Comment hidden'}</p>
                            <p><strong>Admin note:</strong> ${adminNote || 'No additional notes'}</p>
                            <a href="${FRONTEND_URL}${projectLink}&comment=${comment._id}" 
                               style="display: inline-block; background: #3b82f6; color: white; padding: 10px 20px; border-radius: 8px; text-decoration: none;">
                                View Comment
                            </a>
                        </div>
                        `,
                        `Report resolved: ${actionMessage}`
                    );
                } catch (emailError) {
                    logger.error(`Failed to send resolution email: ${emailError.message}`);
                }
            }
        }
        
        // ✅ إشعار للمشرفين الآخرين أن التبليغ تم حله
        const otherAdmins = await User.find({ isAdmin: true, _id: { $ne: req.user.userId } });
        for (const admin of otherAdmins) {
            admin.notifications = admin.notifications || [];
            admin.notifications.push({
                message: `✅ Report resolved by ${req.user.username}: ${action === 'keep' ? 'Comment kept' : 'Comment hidden'} on comment by ${comment.userId?.username || 'Unknown'}`,
                type: 'admin_info',
                link: `/admin/comments?highlight=${comment._id}`,
                read: false,
                createdAt: new Date(),
                metadata: { commentId: comment._id, resolvedBy: req.user.userId, action: action }
            });
            await admin.save();
        }
        
        res.json({ 
            success: true, 
            message: 'Report resolved', 
            action: action,
            commentHidden: comment.hidden
        });
        
    } catch (error) {
        logger.error(`Error resolving report: ${error.message}`);
        res.status(500).json({ error: 'Failed to resolve report' });
    }
});


// ============================================
// GET /api/admin/comments/reported - جلب التعليقات المبلغ عنها (للمشرف)
// ============================================
app.get('/api/admin/comments/reported', authenticateToken, isAdmin, async (req, res) => {
    try {
        const reportedComments = await Comment.find({ 
            reportCount: { $gt: 0 },
            hidden: { $ne: true }
        })
        .sort({ reportCount: -1, timestamp: -1 })
        .populate('userId', 'username email profile.nickname');
        
        res.json(reportedComments);
    } catch (error) {
        logger.error(`Error fetching reported comments: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch reported comments' });
    }
});

// ============================================
// POST /api/comments/:commentId/like - إعجاب/إلغاء إعجاب
// ============================================
app.post('/api/comments/:commentId/like', authenticateToken, async (req, res) => {
    const { commentId } = req.params;
    
    try {
        const comment = await Comment.findById(commentId);
        if (!comment) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        const userId = req.user.userId;
        const hasLiked = comment.likes.includes(userId);
        
        if (hasLiked) {
            comment.likes = comment.likes.filter(id => id.toString() !== userId);
        } else {
            comment.likes.push(userId);
        }
        
        await comment.save();
        
        res.json({ 
            success: true, 
            likesCount: comment.likes.length, 
            hasLiked: !hasLiked 
        });
        
    } catch (error) {
        logger.error(`Error toggling like: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to toggle like' });
    }
});

// ============================================
// PUT /api/comments/:commentId - تعديل تعليق
// ============================================
app.put('/api/comments/:commentId', authenticateToken, [
    body('text').notEmpty().withMessage('Comment text is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    
    const { commentId } = req.params;
    const { text } = req.body;
    
    try {
        const comment = await Comment.findById(commentId);
        if (!comment) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        // فقط صاحب التعليق أو الأدمن يمكنه التعديل
        if (comment.userId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ success: false, error: 'Unauthorized to edit this comment' });
        }
        
        comment.text = text;
        comment.isEdited = true;
        comment.editedAt = new Date();
        await comment.save();
        
        res.json({ success: true, data: comment });
        
    } catch (error) {
        logger.error(`Error editing comment ${commentId}: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to edit comment: ' + error.message });
    }
});


// GET /api/profile/id/:userId
app.get('/api/profile/id/:userId', async (req, res) => {
    try {
        const { userId } = req.params;
        
        if (!mongoose.Types.ObjectId.isValid(userId)) {
            return res.status(400).json({ error: 'Invalid user ID' });
        }
        
        const user = await User.findById(userId).select('username profile');
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        // جلب عدد المتابعين
        const followersCount = await Follow.countDocuments({ followingId: userId, status: 'accepted' });
        
        res.json({
            _id: user._id,
            username: user.username,
            profile: user.profile || {},
            stats: { followers: followersCount }
        });
    } catch (error) {
        console.error('Error fetching user by ID:', error);
        res.status(500).json({ error: 'Failed to fetch user' });
    }
});


app.get('/api/skills', async (req, res) => {
    try {
        const skills = await Skill.find();
        res.json({ success: true, data: skills });
    } catch (error) {
        logger.error(`Error fetching skills: ${error.message}`);
        Sentry.captureException(error, { extra: { endpoint: '/api/skills', method: 'GET' } });
        res.status(500).json({ success: false, error: 'Failed to fetch skills: ' + error.message });
    }
});

app.post('/api/skills', authenticateToken, isAdmin, [
    body('name').notEmpty().withMessage('Skill name is required'),
    body('icon').optional().isString().withMessage('Icon must be a string'), // ✅ غيرنا isURL لـ isString
    body('percentage').isInt({ min: 0, max: 100 }).withMessage('Percentage must be between 0 and 100')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    const { name, icon, percentage } = req.body;
    try {
        const skill = new Skill({ name, icon, percentage });
        await skill.save();
        res.status(201).json({ success: true, data: skill });
    } catch (error) {
        logger.error(`Error saving skill: ${error.message}`);
        Sentry.captureException(error);
        res.status(400).json({ success: false, error: 'Failed to save skill: ' + error.message });
    }
});

app.put('/api/skills/:skillId', authenticateToken, isAdmin, [
    param('skillId').isMongoId().withMessage('Invalid skill ID'),
    body('name').notEmpty().withMessage('Skill name is required'),
    body('icon').optional().isString().withMessage('Icon must be a string'), // ✅ غيرنا isURL لـ isString
    body('percentage').isInt({ min: 0, max: 100 }).withMessage('Percentage must be between 0 and 100')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    const { skillId } = req.params;
    const { name, icon, percentage } = req.body;
    try {
        const skill = await Skill.findByIdAndUpdate(
            skillId,
            { name, icon, percentage },
            { new: true, runValidators: true }
        );
        if (!skill) {
            return res.status(404).json({ success: false, error: 'Skill not found' });
        }
        res.json({ success: true, data: skill });
    } catch (error) {
        logger.error(`Error updating skill ${skillId}: ${error.message}`);
        Sentry.captureException(error);
        res.status(400).json({ success: false, error: 'Failed to update skill: ' + error.message });
    }
});

app.delete('/api/skills/:skillId', authenticateToken, isAdmin, async (req, res) => {
    const { skillId } = req.params;
    try {
        const skill = await Skill.findByIdAndDelete(skillId);
        if (!skill) {
            return res.status(404).json({ success: false, error: 'Skill not found' });
        }
        res.json({ success: true });
    } catch (error) {
        logger.error(`Error deleting skill ${skillId}: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ success: false, error: 'Failed to delete skill: ' + error.message });
    }
});





// ============================================
// GET /api/profile/me - جلب ملفي الشخصي (للتعديل)
// ============================================
app.get('/api/profile/me', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId)
            .select('username profile')
            .lean();
        
        if (!user) {
            return res.status(404).json({ error: 'المستخدم غير موجود' });
        }

        // ✅ القيم الافتراضية للـ profile
        const defaultProfile = {
            portfolioName: 'Portfolio',
            nickname: '',
            jobTitle: '',
            bio: '',
            phone: '',
            isPublic: true,
            status: 'Available',
            socialLinks: { linkedin: '', behance: '', github: '', whatsapp: '' },
            avatar: '',
            avatarDisplayType: 'normal',
            svgColor: '#000000',
            pdfFormat: 'jspdf',
            education: [],
            experience: [],
            certificates: [],
            skills: [],
            projects: [],
            interests: [],
            sectionOrder: [],
            customSections: [],
            sectionStyleSettings: {},
            designSettings: {
                primaryColor: '#3b82f6',
                secondaryColor: '#8b5cf6',
                fontFamily: 'Inter, sans-serif',
                borderRadius: 16,
                zoomLevel: 100,
                shadowType: 'md',
                animationType: 'none',
                glassEffect: false,
                backgroundType: 'default',
                backgroundValue: '',
                customCss: ''
            },

            sectionNames: {
                about: 'About / Bio',
                experience: 'Experience',
                education: 'Education',
                certificates: 'Licenses & certificates',
                skills: 'Skills & expertise',
                projects: 'Projects',
                interests: 'Interests',
                contactInfo: 'Contact info',
                activity: 'Activity',
                contributionGraph: 'Contribution Graph',
                alsoViewed: 'Who viewed also viewed',
                suggestions: 'People you may know',
                pages: 'You might like',
                analytics: 'Analytics',
                jobApplications: 'Job Applications'
            },
            sectionVisibility: {
                about: true,
                experience: true,
                education: true,
                certificates: true,
                skills: true,
                projects: true,
                interests: true,
                contactInfo: true,
                socialLinks: true,
                stats: true,
                activity: true,
                contributionGraph: true,
                alsoViewed: true,
                suggestions: true,
                pages: true,
                jobApplications: true,
                analytics: true
            },
            gender: 'male',
            storeEnabled: false,
            showGender: false,
             aiBot: {
                enabled: false,
                provider: 'mgzon',
                customApiKey: '',
                customModel: 'Qwen/Qwen2.5-7B-Instruct',
                temperature: 0.7,
                maxTokens: 400,
                systemPrompt: '',
                totalQueries: 0,
                lastQueryAt: null
            },
            theme: {
                id: 'default',
                primaryColor: '#3b82f6',
                secondaryColor: '#8b5cf6',
                fontFamily: 'Inter',
                borderRadius: '0.5rem',
            },
            layout: {
                type: 'grid',
                columns: 3,
                showProjectImages: true,
                showProjectDescriptions: true,
                showProjectRatings: true,
                showProjectLinks: true,
            },
            header: {
                showAvatar: true,
                showJobTitle: true,
                showBio: true,
                showContactInfo: true,
                showSocialLinks: true,
                layout: 'centered',
            },
            footer: {
                showCopyright: true,
                customText: '',
            },
            seo: {
                title: '',
                description: '',
                keywords: '',
                ogImage: '',
                ogTitle: '',
                ogDescription: '',
                twitterCard: 'summary_large_image',
                twitterSite: '',
                canonicalUrl: '',
                noindex: false,
                nofollow: false,
            },
            schema: {
                type: 'Person',
                name: '',
                description: '',
                image: '',
                sameAs: [],
                jobTitle: '',
                worksFor: '',
                alumniOf: [],
                knowsAbout: [],
            },
            pushNotifications: false,
            audio: {
                url: '',
                title: '',
                delay: 0,
                loop: true,
                volume: 50
            }
        };

        // ✅ دمج default مع اللي موجود
        let profile = { ...defaultProfile, ...(user.profile || {}) };
        
        if (!profile.sectionStyleSettings) {
            profile.sectionStyleSettings = {};
        }
        
        // ✅ تحويل المشاريع إلى Array مع ضمان وجود _id
        if (profile.projects) {
            let projectsArray = [];
            if (Array.isArray(profile.projects)) {
                projectsArray = profile.projects;
            } else if (typeof profile.projects === 'object') {
                projectsArray = Object.values(profile.projects);
            }
            
            // ✅ ضمان وجود _id لكل مشروع
            profile.projects = projectsArray.map(project => ({
                _id: project._id || new mongoose.Types.ObjectId(),
                ...project
            }));
        }

        res.json({
            username: user.username,
            profile: profile
        });
        
    } catch (error) {
        logger.error(`Error fetching profile/me: ${error.message}`);
        res.status(500).json({ error: 'Profile retrieval error' });
    }
});



// ============================================
// DESIGN SETTINGS API
// ============================================

// GET /api/profile/design-settings
app.get('/api/profile/design-settings', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        const defaultSettings = {
            primaryColor: '#3b82f6',
            secondaryColor: '#8b5cf6',
            fontFamily: 'Inter, sans-serif',
            borderRadius: 16,
            zoomLevel: 100,
            shadowType: 'md',
            animationType: 'none',
            glassEffect: false,
            backgroundType: 'default',
            backgroundValue: '',
            customCss: ''
        };
        
        // ✅ دمج مع الحقول الموجودة
        const designSettings = user.profile?.designSettings || {};
        const settings = { ...defaultSettings, ...designSettings };
        
        console.log('📤 Returning design settings from DB:', {
            backgroundType: settings.backgroundType,
            hasBackgroundValue: !!settings.backgroundValue,
            zoomLevel: settings.zoomLevel
        });
        
        res.json({ success: true, settings });
        
    } catch (error) {
        console.error('Error fetching design settings:', error);
        res.status(500).json({ error: 'Failed to fetch design settings' });
    }
});

// PUT /api/profile/design-settings
app.put('/api/profile/design-settings', authenticateToken, async (req, res) => {
    try {
        const {
            primaryColor, secondaryColor, fontFamily, borderRadius, zoomLevel,
            shadowType, animationType, glassEffect, backgroundType, backgroundValue, customCss
        } = req.body;
        
        const user = await User.findById(req.user.userId);
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        // ✅ التأكد من وجود profile
        if (!user.profile) {
            user.profile = {};
        }
        
        // ✅ التأكد من وجود designSettings
        if (!user.profile.designSettings) {
            user.profile.designSettings = {};
        }
        
        // ✅ الإعدادات الافتراضية
        const defaultSettings = {
            primaryColor: '#3b82f6',
            secondaryColor: '#8b5cf6',
            fontFamily: 'Inter, sans-serif',
            borderRadius: 16,
            zoomLevel: 100,
            shadowType: 'md',
            animationType: 'none',
            glassEffect: false,
            backgroundType: 'default',
            backgroundValue: '',
            customCss: ''
        };
        
        // ✅ دمج مع الإعدادات الحالية
        const currentSettings = { ...defaultSettings, ...(user.profile.designSettings || {}) };
        
        // ✅ تحديث الحقول المرسلة
        if (primaryColor !== undefined) currentSettings.primaryColor = primaryColor;
        if (secondaryColor !== undefined) currentSettings.secondaryColor = secondaryColor;
        if (fontFamily !== undefined) currentSettings.fontFamily = fontFamily;
        if (borderRadius !== undefined) currentSettings.borderRadius = borderRadius;
        if (zoomLevel !== undefined) currentSettings.zoomLevel = zoomLevel;
        if (shadowType !== undefined) currentSettings.shadowType = shadowType;
        if (animationType !== undefined) currentSettings.animationType = animationType;
        if (glassEffect !== undefined) currentSettings.glassEffect = glassEffect;
        if (backgroundType !== undefined) currentSettings.backgroundType = backgroundType;
        if (backgroundValue !== undefined) currentSettings.backgroundValue = backgroundValue;
        if (customCss !== undefined) currentSettings.customCss = customCss;
        
        // ✅ حفظ الكامل
        user.profile.designSettings = currentSettings;
        
        // ✅✅✅ IMPORTANT: markModified ضروري لـ Mixed type ✅✅✅
        user.markModified('profile.designSettings');
        user.markModified('profile');
        
        await user.save();
        
        console.log('✅ Design settings saved in DB:', {
            backgroundType: currentSettings.backgroundType,
            hasBackgroundValue: !!currentSettings.backgroundValue,
            zoomLevel: currentSettings.zoomLevel
        });
        
        res.json({
            success: true,
            message: 'Design settings saved successfully',
            settings: user.profile.designSettings
        });
        
    } catch (error) {
        console.error('Error saving design settings:', error);
        res.status(500).json({ error: 'Failed to save design settings: ' + error.message });
    }
});

// POST /api/profile/design-settings/reset
app.post('/api/profile/design-settings/reset', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        // إعادة الإعدادات الافتراضية
        user.profile.designSettings = {
            primaryColor: '#3b82f6',
            secondaryColor: '#8b5cf6',
            fontFamily: 'Inter, sans-serif',
            borderRadius: 16,
            zoomLevel: 100,
            shadowType: 'md',
            animationType: 'none',
            glassEffect: false,
            backgroundType: 'default',
            backgroundValue: '',
            customCss: ''
        };
        
        await user.save();
        
        res.json({
            success: true,
            message: 'Design settings reset to default',
            settings: user.profile.designSettings
        });
        
    } catch (error) {
        console.error('Error resetting design settings:', error);
        res.status(500).json({ error: 'Failed to reset design settings' });
    }
});

// ============================================
// CUSTOM SECTIONS API - إدارة الأقسام المخصصة
// ============================================

// GET /api/profile/custom-sections - جلب جميع الأقسام المخصصة
app.get('/api/profile/custom-sections', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        let customSections = user.profile?.customSections || [];
        
        // ✅ أضف هذا الشرط ✅
        if (!Array.isArray(customSections)) {
            const newArray = [];
            if (typeof customSections === 'object') {
                for (const key in customSections) {
                    if (customSections[key]) {
                        newArray.push(customSections[key]);
                    }
                }
            }
            customSections = newArray;
            user.profile.customSections = customSections;
            user.markModified('profile.customSections');
            await user.save();
        }
        
        res.json(customSections);
        
    } catch (error) {
        console.error('Error fetching custom sections:', error);
        res.status(500).json({ error: 'Failed to fetch custom sections' });
    }
});

// POST /api/profile/custom-sections - إضافة قسم مخصص جديد
app.post('/api/profile/custom-sections', authenticateToken, [
    body('name').notEmpty().withMessage('Section name is required'),
    body('type').optional().isIn(['text', 'skills', 'links', 'gallery', 'stats', 'timeline', 'testimonials', 'cta']).withMessage('Invalid section type'),
    body('content').optional().isObject(),
    body('settings').optional().isObject()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const { name, type, content, settings } = req.body;
        
        let user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        if (!user.profile.customSections) {
            user.profile.customSections = [];
        }
        
        if (!Array.isArray(user.profile.customSections)) {
            console.log('Converting customSections from object to array');
            const oldSections = user.profile.customSections;
            user.profile.customSections = [];
            if (typeof oldSections === 'object') {
                for (const key in oldSections) {
                    if (oldSections[key]) {
                        user.profile.customSections.push(oldSections[key]);
                    }
                }
            }
        }
        
        // ✅ إعدادات افتراضية
        const defaultSettings = {
            fontSize: 'base',
            textColor: '',
            backgroundColor: '',
            textAlign: 'left',
            padding: 'md',
            borderRadius: 'md',
            shadow: 'none',
            animation: 'none',
            icon: '',
            columns: 1,
            showDivider: true,
            dividerColor: '',
            customClass: '',
            customCss: ''
        };
        
        const mergedSettings = { ...defaultSettings, ...(settings || {}) };
        
        const newSection = {
            _id: new mongoose.Types.ObjectId(),
            name: name.trim(),
            type: type || 'text',
            content: content || {},
            settings: mergedSettings,
            isVisible: true,
            createdAt: new Date(),
            updatedAt: new Date()
        };
        
        user.profile.customSections.push(newSection);
        
        if (!user.profile.sectionOrder) {
            user.profile.sectionOrder = [];
        }
        
        user.profile.sectionOrder.push({
            id: `custom_${newSection._id}`,
            column: 'main'
        });
        
        user.markModified('profile.customSections');
        user.markModified('profile');
        
        await user.save();
        
        res.status(201).json({ 
            success: true, 
            section: newSection,
            message: 'Custom section created successfully'
        });
        
    } catch (error) {
        console.error('Error creating custom section:', error);
        res.status(500).json({ error: 'Failed to create custom section: ' + error.message });
    }
});

// GET /api/profile/custom-sections/:sectionId - جلب قسم مخصص محدد
app.get('/api/profile/custom-sections/:sectionId', authenticateToken, async (req, res) => {
    try {
        const { sectionId } = req.params;
        
        // التحقق من صحة الـ ObjectId
        if (!mongoose.Types.ObjectId.isValid(sectionId)) {
            return res.status(400).json({ error: 'Invalid section ID format' });
        }
        
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        const customSections = user.profile?.customSections || [];
        const section = customSections.find(s => s._id.toString() === sectionId);
        
        if (!section) {
            return res.status(404).json({ error: 'Custom section not found' });
        }
        
        res.json(section);
        
    } catch (error) {
        logger.error(`Error fetching custom section: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch custom section' });
    }
});

// PUT /api/profile/custom-sections/:sectionId - تحديث قسم مخصص
app.put('/api/profile/custom-sections/:sectionId', authenticateToken, [
    body('name').optional().isString().notEmpty(),
    body('content').optional().isObject(),
    body('isVisible').optional().isBoolean(),
    body('settings').optional().isObject()  
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const { sectionId } = req.params;
        const { name, content, isVisible, settings } = req.body;
        
        if (!mongoose.Types.ObjectId.isValid(sectionId)) {
            return res.status(400).json({ error: 'Invalid section ID format' });
        }
        
        // ✅ بناء كائن التحديث مع دعم settings
        const updateFields = {};
        if (name !== undefined) updateFields['profile.customSections.$[elem].name'] = name.trim();
        if (content !== undefined) updateFields['profile.customSections.$[elem].content'] = content;
        if (isVisible !== undefined) updateFields['profile.customSections.$[elem].isVisible'] = isVisible;
        if (settings !== undefined) {
            // دمج الإعدادات الجديدة مع القديمة
            updateFields['profile.customSections.$[elem].settings'] = settings;
        }
        updateFields['profile.customSections.$[elem].updatedAt'] = new Date();
        
        const user = await User.findByIdAndUpdate(
            req.user.userId,
            updateFields,
            {
                arrayFilters: [{ 'elem._id': new mongoose.Types.ObjectId(sectionId) }],
                new: true
            }
        );
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        const updatedSection = user.profile?.customSections?.find(s => s._id.toString() === sectionId);
        if (!updatedSection) {
            return res.status(404).json({ error: 'Custom section not found' });
        }
        
        logger.info(`Custom section updated: ${updatedSection.name} for user ${req.user.userId}`);
        
        res.json({ 
            success: true, 
            section: updatedSection,
            message: 'Custom section updated successfully' 
        });
        
    } catch (error) {
        logger.error(`Error updating custom section: ${error.message}`);
        res.status(500).json({ error: 'Failed to update custom section' });
    }
});

// DELETE /api/profile/custom-sections/:sectionId - حذف قسم مخصص
app.delete('/api/profile/custom-sections/:sectionId', authenticateToken, async (req, res) => {
    try {
        const { sectionId } = req.params;
        
        // التحقق من صحة الـ ObjectId
        if (!mongoose.Types.ObjectId.isValid(sectionId)) {
            return res.status(400).json({ error: 'Invalid section ID format' });
        }
        
        // 1. حذف القسم من customSections
        const user = await User.findByIdAndUpdate(
            req.user.userId,
            {
                $pull: { 'profile.customSections': { _id: new mongoose.Types.ObjectId(sectionId) } }
            },
            { new: true }
        );
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        // 2. حذف القسم من sectionOrder
        await User.findByIdAndUpdate(
            req.user.userId,
            {
                $pull: { 'profile.sectionOrder': { id: `custom_${sectionId}` } }
            }
        );
        
        logger.info(`Custom section deleted: ${sectionId} for user ${req.user.userId}`);
        
        res.json({ 
            success: true, 
            message: 'Custom section deleted successfully' 
        });
        
    } catch (error) {
        logger.error(`Error deleting custom section: ${error.message}`);
        res.status(500).json({ error: 'Failed to delete custom section' });
    }
});



// ============================================
// SECTION NAMES API - تعديل أسماء الأقسام الافتراضية
// ============================================

// GET /api/profile/section-names - جلب أسماء الأقسام
app.get('/api/profile/section-names', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        const sectionNames = user.profile?.sectionNames || {};
        res.json({ sectionNames });
    } catch (error) {
        logger.error(`Error fetching section names: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch section names' });
    }
});

// PUT /api/profile/section-names - حفظ أسماء الأقسام
app.put('/api/profile/section-names', authenticateToken, async (req, res) => {
    try {
        const { sectionNames } = req.body;
        
        if (!sectionNames || typeof sectionNames !== 'object') {
            return res.status(400).json({ error: 'Invalid section names format' });
        }
        
        await User.findByIdAndUpdate(req.user.userId, {
            'profile.sectionNames': sectionNames
        });
        
        logger.info(`Section names updated for user ${req.user.userId}`);
        res.json({ success: true, message: 'Section names updated successfully' });
    } catch (error) {
        logger.error(`Error saving section names: ${error.message}`);
        res.status(500).json({ error: 'Failed to save section names' });
    }
});

// ============================================
// LAYOUT PRESETS - حفظ وتحميل تصاميم البروفايل
// ============================================


// GET /api/profile/layout-presets - جلب كل التصاميم المحفوظة
app.get('/api/profile/layout-presets', authenticateToken, async (req, res) => {
    try {
        const presets = await LayoutPreset.find({ userId: req.user.userId }).sort({ createdAt: -1 });
        res.json(presets);
    } catch (error) {
        res.status(500).json({ error: 'Failed to fetch presets' });
    }
});

// GET /api/profile/layout-presets/:id - جلب تصميم محدد
app.get('/api/profile/layout-presets/:id', authenticateToken, async (req, res) => {
    try {
        const preset = await LayoutPreset.findOne({ _id: req.params.id, userId: req.user.userId });
        if (!preset) return res.status(404).json({ error: 'Preset not found' });
        res.json(preset);
    } catch (error) {
        res.status(500).json({ error: 'Failed to fetch preset' });
    }
});

// POST /api/profile/layout-presets - حفظ تصميم جديد
app.post('/api/profile/layout-presets', authenticateToken, async (req, res) => {
    try {
        const { name, sectionOrder, theme } = req.body;
        
        const preset = new LayoutPreset({
            userId: req.user.userId,
            name: name,
            sectionOrder: sectionOrder,
            theme: theme || {}
        });
        
        await preset.save();
        res.json({ success: true, preset });
    } catch (error) {
        res.status(500).json({ error: 'Failed to save preset' });
    }
});

// DELETE /api/profile/layout-presets/:id - حذف تصميم
app.delete('/api/profile/layout-presets/:id', authenticateToken, async (req, res) => {
    try {
        await LayoutPreset.findOneAndDelete({ _id: req.params.id, userId: req.user.userId });
        res.json({ success: true });
    } catch (error) {
        res.status(500).json({ error: 'Failed to delete preset' });
    }
});

// GET /api/profile/section-order - جلب ترتيب الأقسام الحالي
app.get('/api/profile/section-order', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        res.json({ order: user.profile?.sectionOrder || [] });
    } catch (error) {
        res.status(500).json({ error: 'Failed to fetch section order' });
    }
});

// PUT /api/profile/section-order - حفظ ترتيب الأقسام
app.put('/api/profile/section-order', authenticateToken, async (req, res) => {
    try {
        const { sectionOrder } = req.body;
        await User.findByIdAndUpdate(req.user.userId, {
            'profile.sectionOrder': sectionOrder
        });
        res.json({ success: true });
    } catch (error) {
        res.status(500).json({ error: 'Failed to save section order' });
    }
});


app.post('/api/user/education', authenticateToken, [
    body('institution').notEmpty().withMessage('Institution is required'),
    body('degree').notEmpty().withMessage('Degree is required'),
    body('year').isInt({ min: 1900, max: new Date().getFullYear() }).withMessage('Invalid year')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    const { institution, degree, year } = req.body;
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }
        user.education = user.education || [];
        user.education.push({ institution, degree, year });
        await user.save();
        logger.info(`Education added for user ${req.user.userId}: ${institution}`);
        res.status(201).json({ success: true, data: user.education });
    } catch (error) {
        logger.error(`Error adding education for user ${req.user.userId}: ${error.message}`);
        Sentry.captureException(error, { user: { id: req.user.userId, email: req.user.email } });
        res.status(400).json({ success: false, error: 'Failed to add education: ' + error.message });
    }
});

// ============================================
// GET /api/profile/:nickname - جلب الملف الشخصي
// ============================================
app.get('/api/profile/:nickname', async (req, res) => {
    try {
        const decodedNickname = decodeURIComponent(req.params.nickname);

        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${decodedNickname}$`, $options: 'i' } },
                { username: { $regex: `^${decodedNickname}$`, $options: 'i' } },
            ],
        })
        .select('username email profile notifications')
        .lean();
        

        if (!user) {
            return res.status(404).json({ error: `Profile not found for ${decodedNickname}` });
        }

        // ============================
        // 📊 ANALYTICS (NEW)
        // ============================
        const analytics = await ProfileAnalytics.findOne({ userId: user._id });

        let profileViews = 0;
        let uniqueProfileViews = 0;
        let weeklyViews = 0;

        if (analytics) {
            profileViews = analytics.profileViews?.length || 0;

            uniqueProfileViews = analytics.profileViews
                ? new Set(analytics.profileViews.map(v => v.viewerId?.toString())).size
                : 0;

            const last7Days = new Date();
            last7Days.setDate(last7Days.getDate() - 7);

            weeklyViews = analytics.profileViews?.filter(v =>
                new Date(v.viewedAt) >= last7Days
            ).length || 0;
        }

        const isOwner = req.user && req.user.userId === user._id;
        const showEmail = isOwner || (user.profile.showEmail === true);

        
        if (!user.profile) user.profile = {};

        if (!user.profile.isPublic && !isOwner) {
            return res.status(403).json({ error: 'Profile is private' });
        }

        // ✅ استخراج المشاريع مع الحفاظ على _id
        let projects = [];
        if (user.profile.projects) {
            if (Array.isArray(user.profile.projects)) {
                projects = user.profile.projects.map(p => ({
                    ...p,
                    _id: p._id || new mongoose.Types.ObjectId()
                }));
            } else if (typeof user.profile.projects === 'object') {
                projects = Object.values(user.profile.projects).map(p => ({
                    ...p,
                    _id: p._id || new mongoose.Types.ObjectId()
                }));
            }
        }

        if (!isOwner) {
            projects = projects.filter(p => p.isPublic !== false);
        }

        projects.sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0));

        // ✅ بناء كائن aiBot حسب صلاحية المشاهد
        let aiBotResponse = {
            enabled: user.profile.aiBot?.enabled || false,
            provider: user.profile.aiBot?.provider || 'mgzon'
        };
        
        // ✅ لو المالك، أضف المعلومات الإضافية
        if (isOwner) {
            aiBotResponse = {
                ...aiBotResponse,
                customModel: user.profile.aiBot?.customModel || 'Qwen/Qwen2.5-7B-Instruct',
                temperature: user.profile.aiBot?.temperature || 0.7,
                maxTokens: user.profile.aiBot?.maxTokens || 400,
                totalQueries: user.profile.aiBot?.totalQueries || 0,
                lastQueryAt: user.profile.aiBot?.lastQueryAt || null
            };
        } else {
            // ✅ للزوار، أضف customModel فقط (بدون باقي التفاصيل)
            aiBotResponse.customModel = user.profile.aiBot?.customModel || 'Qwen/Qwen2.5-7B-Instruct';
        }

        // ============================
        // 🎨 Design Settings
        // ============================
        const defaultDesignSettings = {
            primaryColor: '#3b82f6',
            secondaryColor: '#8b5cf6',
            fontFamily: 'Inter, sans-serif',
            borderRadius: 16,
            zoomLevel: 100,
            shadowType: 'md',
            animationType: 'none',
            glassEffect: false,
            backgroundType: 'default',
            backgroundValue: '',
            customCss: ''
        };

        const designSettings = {
            ...defaultDesignSettings,
            ...(user.profile?.designSettings || {})
        };

        const hasCustomDesign =
            JSON.stringify(designSettings) !== JSON.stringify(defaultDesignSettings);

        const response = {
            username: user.username,
            email: showEmail ? user.email : null,
            profile: {
                _id: user._id,
                nickname: user.profile.nickname || user.username,
                portfolioName: user.profile.portfolioName || 'Portfolio',
                coverImage: user.profile.coverImage || '/assets/img/default-cover.png',
                avatar: user.profile.avatar || '/assets/img/default-avatar.png',
                avatarDisplayType: user.profile.avatarDisplayType || 'normal',
                industry: user.profile.industry || '',
                location: user.profile.location || '',
                svgColor: user.profile.svgColor || '#000000',
                jobTitle: user.profile.jobTitle || '',
                bio: user.profile.bio || '',
                showEmail: user.profile.showEmail || true,
                sectionNames: user.profile?.sectionNames || {},
                phone: user.profile.phone || '',
                status: user.profile.status || 'Available',
                isPublic: user.profile.isPublic ?? true,
                pdfFormat: user.profile.pdfFormat || 'jspdf',
                projects: projects,
                socialLinks: user.profile.socialLinks || {},
                audio: user.profile.audio || {},
                sectionStyleSettings: user.profile?.sectionStyleSettings || {},
                education: user.profile.education || [],
                experience: user.profile.experience || [],
                certificates: user.profile.certificates || [],
                skills: user.profile.skills || [],
                interests: user.profile.interests || [],
                designSettings,
                hasCustomDesign,
                // ✅ للجميع (زوار ومالك)
                sectionVisibility: user.profile?.sectionVisibility || {},
                sectionOrder: user.profile?.sectionOrder || [],
                customSections: user.profile?.customSections || [],

                gender: (isOwner || user.profile.showGender) ? (user.profile?.gender || 'male') : null,
                showGender: user.profile?.showGender || false, 

                // ✅ AI Bot - حسب صلاحية المشاهد
                aiBot: aiBotResponse,

                theme: user.profile.theme || {},
                layout: user.profile.layout || {},
                header: user.profile.header || {},
                footer: user.profile.footer || {},
                seo: user.profile.seo || {},
                schema: user.profile.schema || {},

                analytics: {
                    views: profileViews,
                    uniqueViews: uniqueProfileViews,
                    weeklyViews: weeklyViews
                },
            },
        };

        res.json(response);

    } catch (error) {
        logger.error(`Error fetching profile: ${error.message}`);
        res.status(500).json({ error: `Failed to fetch profile: ${error.message}` });
    }
});


// ============================================
// POST /api/profile/:userId/view - تتبع مشاهدة البروفايل
// ============================================
app.post('/api/profile/:userId/view', async (req, res) => {
    try {
        const { userId: targetUserId } = req.params;
        
        if (!targetUserId) {
            return res.status(400).json({
                success: false,
                error: 'targetUserId is required'
            });
        }

        // ✅ الحصول على viewerId من التوكن (لو موجود)
        const viewerId = req.user?.userId || null;
        const viewerIp = req.ip || req.connection?.remoteAddress || 'unknown';

        // ✅ لا تسجل مشاهدة لنفس المستخدم
        if (viewerId === targetUserId) {
            return res.json({
                success: true,
                message: 'Self view not tracked',
                data: { selfView: true }
            });
        }

        // ============================
        // 📊 1. تسجيل في ProfileAnalytics
        // ============================
        let analytics = await ProfileAnalytics.findOne({ userId: targetUserId });
        
        if (!analytics) {
            analytics = new ProfileAnalytics({ userId: targetUserId });
        }
        
        analytics.profileViews = analytics.profileViews || [];
        analytics.profileViews.push({
            viewerId: viewerId,
            viewerIp: viewerIp,
            viewedAt: new Date()
        });
        
        // ✅ الاحتفاظ بآخر 100 مشاهدة فقط
        if (analytics.profileViews.length > 100) {
            analytics.profileViews = analytics.profileViews.slice(-100);
        }
        
        analytics.lastUpdated = new Date();
        await analytics.save();

        // ============================
        // 👥 2. تسجيل في AlsoViewed
        // ============================
        if (viewerId) {
            // ✅ مستخدم مسجل
            await AlsoViewed.findOneAndUpdate(
                { targetUserId, viewerId: viewerId },
                { 
                    viewedAt: new Date(),
                    viewerIp: viewerIp 
                },
                { upsert: true }
            );
        } else {
            // ✅ زائر (غير مسجل) - نستخدم IP
            const existingView = await AlsoViewed.findOne({
                targetUserId,
                viewerIp: viewerIp,
                viewedAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) }
            });
            
            if (!existingView) {
                await AlsoViewed.create({
                    targetUserId,
                    viewerId: null,
                    viewerIp: viewerIp,
                    viewedAt: new Date()
                });
            }
        }

        // ============================
        // 🏆 3. تحديث البرونزيات
        // ============================
        const badgeResult = await updateUserBadges(targetUserId);

        // ============================
        // 📢 4. بث للمستخدم المستهدف (لو فتح برونزية) - عبر Socket
        // ============================
        if (badgeResult?.newBadgeUnlocked && badgeResult?.unlockedBadges?.length > 0) {
            // ✅ استخدم io.to (نفس الكود القديم)
            io.to(`user_${targetUserId}`).emit('badge_unlocked', {
                userId: targetUserId,
                badges: badgeResult.unlockedBadges,
                badgeIcons: badgeResult.unlockedBadgeIcons || [],
                viewCount: badgeResult.viewCount,
                likeCount: badgeResult.likeCount,
                replyCount: badgeResult.replyCount,
                ratingCount: badgeResult.ratingCount,
                totalBadges: badgeResult.totalBadgeCount
            });
        }

        res.json({
            success: true,
            message: 'View tracked successfully',
            data: {
                viewCount: badgeResult?.viewCount || 0,
                likeCount: badgeResult?.likeCount || 0,
                replyCount: badgeResult?.replyCount || 0,
                ratingCount: badgeResult?.ratingCount || 0,
                totalBadges: badgeResult?.totalBadgeCount || 0,
                newBadgeUnlocked: badgeResult?.newBadgeUnlocked || false,
                unlockedBadges: badgeResult?.unlockedBadges || []
            }
        });

    } catch (error) {
        console.error('❌ Track profile view error:', error);
        // ✅ لا نرسل خطأ للمستخدم حتى لا يسبب مشاكل
        res.json({
            success: true,
            message: 'View tracked',
            data: { error: error.message }
        });
    }
});

// ============================================
// GET /api/users/:userId/badges - جلب البرونزيات المفتوحة فقط
// ============================================
app.get('/api/users/:userId/badges', async (req, res) => {
    try {
        const { userId } = req.params;
        
        // ✅ جلب جميع البيانات بشكل متوازي (نفس الـ Socket)
        const [badges, viewCount, likeCount, replyCount, ratingCount] = await Promise.all([
            getUserBadges(userId),
            getUniqueViewsCount(userId),
            getTotalPostLikes(userId),
            getTotalUserReplies(userId),
            getTotalUserRatings(userId)  // ✅ أضف ratingCount
        ]);
        
        // ✅ حساب التالي - نفس منطق الـ Socket بالضبط
        let nextBadge = null;
        let nextThreshold = null;
        let progress = 100;
        let nextBadgeType = null;
        
        // ✅ Views Badges
        const viewsBadges = badges.views || { unlocked: [], count: 0 };
        const hasSilver = viewsBadges.unlocked.some(b => b.key === 'silver');
        const hasGold = viewsBadges.unlocked.some(b => b.key === 'gold');
        const hasRed = viewsBadges.unlocked.some(b => b.key === 'red');
        
        if (!hasSilver && viewCount < VIEW_BADGE_THRESHOLDS.SILVER) {
            nextBadge = 'Views Silver';
            nextThreshold = VIEW_BADGE_THRESHOLDS.SILVER;
            progress = (viewCount / VIEW_BADGE_THRESHOLDS.SILVER) * 100;
            nextBadgeType = 'views';
        } else if (!hasGold && viewCount < VIEW_BADGE_THRESHOLDS.GOLD) {
            nextBadge = 'Views Gold';
            nextThreshold = VIEW_BADGE_THRESHOLDS.GOLD;
            progress = (viewCount / VIEW_BADGE_THRESHOLDS.GOLD) * 100;
            nextBadgeType = 'views';
        } else if (!hasRed && viewCount < VIEW_BADGE_THRESHOLDS.RED) {
            nextBadge = 'Views Red';
            nextThreshold = VIEW_BADGE_THRESHOLDS.RED;
            progress = (viewCount / VIEW_BADGE_THRESHOLDS.RED) * 100;
            nextBadgeType = 'views';
        }
        
        // ✅ Likes Badges
        const likesBadges = badges.likes || { unlocked: [], count: 0 };
        const hasLikesBronze = likesBadges.unlocked.some(b => b.key === 'bronze');
        const hasLikesRed = likesBadges.unlocked.some(b => b.key === 'red');
        const hasLikesSilver = likesBadges.unlocked.some(b => b.key === 'silver');
        const hasLikesGold = likesBadges.unlocked.some(b => b.key === 'gold');
        
        if (!nextBadge) {
            if (!hasLikesBronze && likeCount < LIKE_BADGE_THRESHOLDS.BRONZE) {
                nextBadge = 'Likes Bronze';
                nextThreshold = LIKE_BADGE_THRESHOLDS.BRONZE;
                progress = (likeCount / LIKE_BADGE_THRESHOLDS.BRONZE) * 100;
                nextBadgeType = 'likes';
            } else if (!hasLikesRed && likeCount < LIKE_BADGE_THRESHOLDS.RED) {
                nextBadge = 'Likes Red';
                nextThreshold = LIKE_BADGE_THRESHOLDS.RED;
                progress = (likeCount / LIKE_BADGE_THRESHOLDS.RED) * 100;
                nextBadgeType = 'likes';
            } else if (!hasLikesSilver && likeCount < LIKE_BADGE_THRESHOLDS.SILVER) {
                nextBadge = 'Likes Silver';
                nextThreshold = LIKE_BADGE_THRESHOLDS.SILVER;
                progress = (likeCount / LIKE_BADGE_THRESHOLDS.SILVER) * 100;
                nextBadgeType = 'likes';
            } else if (!hasLikesGold && likeCount < LIKE_BADGE_THRESHOLDS.GOLD) {
                nextBadge = 'Likes Gold';
                nextThreshold = LIKE_BADGE_THRESHOLDS.GOLD;
                progress = (likeCount / LIKE_BADGE_THRESHOLDS.GOLD) * 100;
                nextBadgeType = 'likes';
            }
        }
        
        // ✅ Interaction Badges
        const interactionBadges = badges.interaction || { unlocked: [], count: 0 };
        const hasInteractionBronze = interactionBadges.unlocked.some(b => b.key === 'bronze');
        
        if (!nextBadge) {
            if (!hasInteractionBronze && replyCount < INTERACTION_BADGE_THRESHOLDS.BRONZE) {
                nextBadge = 'Interaction Bronze';
                nextThreshold = INTERACTION_BADGE_THRESHOLDS.BRONZE;
                progress = (replyCount / INTERACTION_BADGE_THRESHOLDS.BRONZE) * 100;
                nextBadgeType = 'interaction';
            }
        }
        
        // ✅ Ratings Badges
        const ratingsBadges = badges.ratings || { unlocked: [], count: 0 };
        const hasRatingsBronze = ratingsBadges.unlocked.some(b => b.key === 'bronze');
        const hasRatingsSilver = ratingsBadges.unlocked.some(b => b.key === 'silver');
        const hasRatingsGold = ratingsBadges.unlocked.some(b => b.key === 'gold');
        const hasRatingsPlatinum = ratingsBadges.unlocked.some(b => b.key === 'platinum');
        
        if (!nextBadge) {
            if (!hasRatingsBronze && ratingCount < RATING_BADGE_THRESHOLDS.BRONZE) {
                nextBadge = 'Ratings Bronze';
                nextThreshold = RATING_BADGE_THRESHOLDS.BRONZE;
                progress = (ratingCount / RATING_BADGE_THRESHOLDS.BRONZE) * 100;
                nextBadgeType = 'ratings';
            } else if (!hasRatingsSilver && ratingCount < RATING_BADGE_THRESHOLDS.SILVER) {
                nextBadge = 'Ratings Silver';
                nextThreshold = RATING_BADGE_THRESHOLDS.SILVER;
                progress = (ratingCount / RATING_BADGE_THRESHOLDS.SILVER) * 100;
                nextBadgeType = 'ratings';
            } else if (!hasRatingsGold && ratingCount < RATING_BADGE_THRESHOLDS.GOLD) {
                nextBadge = 'Ratings Gold';
                nextThreshold = RATING_BADGE_THRESHOLDS.GOLD;
                progress = (ratingCount / RATING_BADGE_THRESHOLDS.GOLD) * 100;
                nextBadgeType = 'ratings';
            } else if (!hasRatingsPlatinum && ratingCount < RATING_BADGE_THRESHOLDS.PLATINUM) {
                nextBadge = 'Ratings Platinum';
                nextThreshold = RATING_BADGE_THRESHOLDS.PLATINUM;
                progress = (ratingCount / RATING_BADGE_THRESHOLDS.PLATINUM) * 100;
                nextBadgeType = 'ratings';
            }
        }
        
        if (!nextBadge) {
            nextBadge = 'All badges collected! 🎉';
            nextThreshold = null;
            progress = 100;
            nextBadgeType = 'complete';
        }
        
        const totalBadges = badges.totalCount || 0;
        const totalPossible = 3 + 4 + 1 + 4; // views(3) + likes(4) + interaction(1) + ratings(4)
        const overallProgress = Math.min((totalBadges / totalPossible) * 100, 100);
        
        // ✅ نفس بنية البيانات تماماً زي الـ Socket
        res.json({
            success: true,
            data: {
                userId,
                viewCount,
                likeCount,
                replyCount,
                ratingCount,
                badges: {
                    views: {
                        unlocked: badges.views?.unlocked || [],
                        count: badges.views?.count || 0
                    },
                    likes: {
                        unlocked: badges.likes?.unlocked || [],
                        count: badges.likes?.count || 0
                    },
                    interaction: {
                        unlocked: badges.interaction?.unlocked || [],
                        count: badges.interaction?.count || 0
                    },
                    ratings: {
                        unlocked: badges.ratings?.unlocked || [],
                        count: badges.ratings?.count || 0
                    },
                    unlocked: badges.unlocked || [],
                    totalCount: totalBadges
                },
                thresholds: {
                    views: VIEW_BADGE_THRESHOLDS,
                    likes: LIKE_BADGE_THRESHOLDS,
                    interaction: INTERACTION_BADGE_THRESHOLDS,
                    ratings: RATING_BADGE_THRESHOLDS
                },
                nextBadge,
                nextThreshold,
                nextBadgeType,
                progress: Math.min(Math.round(progress), 100),
                overallProgress: Math.min(Math.round(overallProgress), 100),
                totalBadges,
                totalPossible
            }
        });
        
    } catch (error) {
        console.error('Error getting badges:', error);
        res.status(500).json({ 
            success: false, 
            error: 'Failed to get badges' 
        });
    }
});


// ============================================
// GET /api/achievements/:slug - جلب تفاصيل برونزية معينة
// ============================================
app.get('/api/achievements/:slug', async (req, res) => {
    try {
        const { slug } = req.params;
        const { userId } = req.query; // ✅ userId من query string
        
        // ✅ تعريف كل البرونزيات مع بياناتها الكاملة
        const achievements = {
            'views-silver': {
                name: 'Views Silver',
                slug: 'views-silver',
                icon: '/assets/img/fire.svg',
                type: 'views',
                description: 'Achieved 20 unique profile views. Your profile is getting noticed!',
                rarity: 'uncommon',
                rarityScore: 15,
                threshold: 20,
                requirements: [
                    { text: 'Get 20 unique profile views', max: 20 }
                ]
            },
            'views-gold': {
                name: 'Views Gold',
                slug: 'views-gold',
                icon: '/assets/img/firegolden.svg',
                type: 'views',
                description: 'Achieved 100 unique profile views. You\'re building a strong presence!',
                rarity: 'rare',
                rarityScore: 30,
                threshold: 100,
                requirements: [
                    { text: 'Get 100 unique profile views', max: 100 }
                ]
            },
            'views-red': {
                name: 'Views Red',
                slug: 'views-red',
                icon: '/assets/img/firered.svg',
                type: 'views',
                description: 'Achieved 200 unique profile views. You\'re a rising star!',
                rarity: 'epic',
                rarityScore: 50,
                threshold: 200,
                requirements: [
                    { text: 'Get 200 unique profile views', max: 200 }
                ]
            },
            'likes-bronze': {
                name: 'Likes Bronze',
                slug: 'likes-bronze',
                icon: '/assets/img/StarStruck_SkinTone1.png',
                type: 'likes',
                description: 'Received 10 likes across your posts. People appreciate your content!',
                rarity: 'common',
                rarityScore: 5,
                threshold: 10,
                requirements: [
                    { text: 'Receive 10 likes on your posts', max: 10 }
                ]
            },
            'likes-red': {
                name: 'Likes Red',
                slug: 'likes-red',
                icon: '/assets/img/StarStruck_Bronze.png',
                type: 'likes',
                description: 'Received 128 likes across your posts. Your content is gaining traction!',
                rarity: 'uncommon',
                rarityScore: 20,
                threshold: 128,
                requirements: [
                    { text: 'Receive 128 likes on your posts', max: 128 }
                ]
            },
            'likes-silver': {
                name: 'Likes Silver',
                slug: 'likes-silver',
                icon: '/assets/img/StarStruck_Silver.png',
                type: 'likes',
                description: 'Received 512 likes across your posts. You\'re building a strong community!',
                rarity: 'rare',
                rarityScore: 35,
                threshold: 512,
                requirements: [
                    { text: 'Receive 512 likes on your posts', max: 512 }
                ]
            },
            'likes-gold': {
                name: 'Likes Gold',
                slug: 'likes-gold',
                icon: '/assets/img/StarStruck_Gold.png',
                type: 'likes',
                description: 'Received 4096 likes across your posts. Your content is going viral!',
                rarity: 'epic',
                rarityScore: 60,
                threshold: 4096,
                requirements: [
                    { text: 'Receive 4096 likes on your posts', max: 4096 }
                ]
            },
            'interaction-bronze': {
                name: 'Interaction Bronze',
                slug: 'interaction-bronze',
                icon: '/assets/img/QuickDraw_SkinTone1.png',
                type: 'interaction',
                description: 'Replied to 10 comments. You\'re an active community member!',
                rarity: 'common',
                rarityScore: 5,
                threshold: 10,
                requirements: [
                    { text: 'Reply to 10 comments on other posts', max: 10 }
                ]
            },
            'ratings-bronze': {
                name: 'Ratings Bronze',
                slug: 'ratings-bronze',
                icon: '/assets/img/GalaxyBrain.png',
                type: 'ratings',
                description: 'Received 2 ratings. Your work is being recognized!',
                rarity: 'common',
                rarityScore: 5,
                threshold: 2,
                requirements: [
                    { text: 'Receive 2 ratings on your profile', max: 2 }
                ]
            },
            'ratings-silver': {
                name: 'Ratings Silver',
                slug: 'ratings-silver',
                icon: '/assets/img/GalaxyBrain_Bronze.png',
                type: 'ratings',
                description: 'Received 6 ratings. Your reputation is growing!',
                rarity: 'uncommon',
                rarityScore: 15,
                threshold: 6,
                requirements: [
                    { text: 'Receive 6 ratings on your profile', max: 6 }
                ]
            },
            'ratings-gold': {
                name: 'Ratings Gold',
                slug: 'ratings-gold',
                icon: '/assets/img/GalaxyBrain_Silver.png',
                type: 'ratings',
                description: 'Received 16 ratings. You\'re highly regarded by the community!',
                rarity: 'rare',
                rarityScore: 30,
                threshold: 16,
                requirements: [
                    { text: 'Receive 16 ratings on your profile', max: 16 }
                ]
            },
            'ratings-platinum': {
                name: 'Ratings Platinum',
                slug: 'ratings-platinum',
                icon: '/assets/img/GalaxyBrain_Gold.png',
                type: 'ratings',
                description: 'Received 32 ratings. You\'re a top-rated professional!',
                rarity: 'epic',
                rarityScore: 55,
                threshold: 32,
                requirements: [
                    { text: 'Receive 32 ratings on your profile', max: 32 }
                ]
            }
        };
        
        const achievement = achievements[slug];
        
        if (!achievement) {
            return res.status(404).json({
                success: false,
                error: 'Achievement not found'
            });
        }
        
        // ✅ جلب إحصائيات فعلية من قاعدة البيانات
        let userUnlocked = false;
        let userUnlockedAt = null;
        let progress = 0;
        let currentValue = 0;
        let requirements = [];
        let stats = [];
        let usersEarnedList = [];
        
        // ✅ استخدام userId من الـ query
        const targetUserId = userId || req.user?.userId || null;
        
        console.log(`🔍 Achievement details requested: ${slug}, userId: ${targetUserId}`);
        
        if (targetUserId) {
            // ✅ جلب بيانات المستخدم
            const user = await User.findById(targetUserId).select('profile.badges');
            
            if (user && user.profile?.badges) {
                const badges = user.profile.badges;
                
                // ✅ التحقق من فتح البرونزية وحساب التقدم
                const badgeType = achievement.type;
                const threshold = achievement.threshold || 0;
                
                // ✅ جلب القيمة الفعلية حسب النوع
                if (badgeType === 'views') {
                    currentValue = await getUniqueViewsCount(targetUserId);
                } else if (badgeType === 'likes') {
                    currentValue = await getTotalPostLikes(targetUserId);
                } else if (badgeType === 'interaction') {
                    currentValue = await getTotalUserReplies(targetUserId);
                } else if (badgeType === 'ratings') {
                    currentValue = await getTotalUserRatings(targetUserId);
                }
                
                progress = Math.min((currentValue / threshold) * 100, 100);
                
                // ✅ التحقق من الفتح
                const badgeKey = slug.split('-').pop(); // silver, gold, red, bronze, platinum
                
                let isUnlocked = false;
                if (badgeType === 'views' && badges.views) {
                    isUnlocked = badges.views[badgeKey] === true;
                } else if (badgeType === 'likes' && badges.likes) {
                    isUnlocked = badges.likes[badgeKey] === true;
                } else if (badgeType === 'interaction' && badges.interaction) {
                    isUnlocked = badges.interaction[badgeKey] === true;
                } else if (badgeType === 'ratings' && badges.ratings) {
                    isUnlocked = badges.ratings[badgeKey] === true;
                }
                
                console.log(`📊 Achievement check:`, {
                    slug,
                    badgeType,
                    badgeKey,
                    isUnlocked,
                    currentValue,
                    threshold,
                    userBadges: badges[badgeType]
                });
                
                if (isUnlocked) {
                    userUnlocked = true;
                    userUnlockedAt = badges.unlockedAt || new Date();
                }
            }
            
            // ✅ جلب المستخدمين الذين حصلوا على هذه البرونزية
            const allUsers = await User.find({
                [`profile.badges.${achievement.type}.${slug.split('-').pop()}`]: true
            })
            .select('username profile.nickname profile.avatar profile.badges.unlockedAt')
            .limit(10)
            .lean();
            
            usersEarnedList = allUsers.map(u => ({
                name: u.profile?.nickname || u.username,
                nickname: u.profile?.nickname || u.username,
                username: u.username,
                avatar: u.profile?.avatar || '/assets/img/default-avatar.png',
                unlockedAt: u.profile?.badges?.unlockedAt || null
            }));
        }
        
        // ✅ بناء الـ Requirements مع التقدم الفعلي
        requirements = achievement.requirements.map(req => ({
            ...req,
            progress: Math.min(currentValue, req.max),
            completed: currentValue >= req.max
        }));
        
        // ✅ بناء الإحصائيات
        stats = [
            { label: 'Progress', value: `${Math.round(progress)}%`, icon: 'bx-chart' },
            { label: 'Current', value: currentValue, icon: 'bx-current-location' },
            { label: 'Target', value: achievement.threshold || '—', icon: 'bx-bullseye' },
            { label: 'Status', value: userUnlocked ? '✅ Unlocked' : '🔒 In Progress', icon: 'bx-info-circle' }
        ];
        
        // ✅ بناء البيانات النهائية (نفس هيكل الـ Socket)
        const responseData = {
            ...achievement,
            isUnlocked: userUnlocked,
            unlockedAt: userUnlockedAt,
            progress: Math.min(currentValue, achievement.threshold || 0),
            maxProgress: achievement.threshold || 0,
            currentValue: currentValue,
            requirements: requirements,
            stats: stats,
            usersEarnedList: usersEarnedList,
            totalEarned: usersEarnedList.length,
            globalRank: usersEarnedList.length > 0 ? `#${Math.floor(Math.random() * 100) + 1}` : '#N/A'
        };
        
        console.log(`✅ Achievement response:`, {
            name: responseData.name,
            isUnlocked: responseData.isUnlocked,
            currentValue: responseData.currentValue,
            maxProgress: responseData.maxProgress
        });
        
        res.json({
            success: true,
            data: responseData
        });
        
    } catch (error) {
        console.error('❌ Achievement details error:', error);
        res.status(500).json({
            success: false,
            error: error.message
        });
    }
});

// ============================================
// GET /api/users/:userId - جلب بيانات مستخدم معين للوسام
// ============================================
app.get('/api/users/:userId', async (req, res) => {
    try {
        const userId = req.params.userId;
        
        if (!mongoose.Types.ObjectId.isValid(userId)) {
            return res.status(400).json({ error: 'Invalid user ID' });
        }
        
        const user = await User.findById(userId)
            .select('username isAdmin profile.nickname profile.avatar profile.jobTitle')
            .lean();
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        res.json({
            _id: user._id,
            username: user.username,
            isAdmin: user.isAdmin || false,
            profile: {
                nickname: user.profile?.nickname || user.username,
                avatar: user.profile?.avatar || '/assets/img/default-avatar.png',
                jobTitle: user.profile?.jobTitle || 'Professional'
            }
        });
        
    } catch (error) {
        console.error('Error fetching user:', error);
        res.status(500).json({ error: 'Failed to fetch user' });
    }
});

const googleLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 10,
    message: 'Too many Google API requests, please try again later.',
    validate: { trustProxy: false }
});
app.use('/api/google', googleLimiter);




// app.get('/api/profile/:nickname/seo-preview')

// ============================================
// GET /api/profile/:nickname/seo-preview - معاينة SEO
// ============================================
app.get('/api/profile/:nickname/seo-preview', async (req, res) => {
    try {
        const decodedNickname = decodeURIComponent(req.params.nickname);

        const user = await User.findOne({
            $or: [
                { 'profile.nickname': decodedNickname },
                { username: decodedNickname },
            ],
        }).select('profile');

        if (!user) {
            return res.status(404).json({ error: 'Profile not found' });
        }


        const profileUrl = `${FRONTEND_URL}/portfolio/${user.profile.nickname || user.username}`;

        // إنشاء meta tags preview
        const metaTags = {
            title: user.profile.seo?.title || user.profile.portfolioName || 'My Portfolio',
            description: user.profile.seo?.description || user.profile.bio || '',
            ogImage: user.profile.seo?.ogImage || user.profile.avatar || '',
            canonicalUrl: user.profile.seo?.canonicalUrl || profileUrl,
            noindex: user.profile.seo?.noindex || false,
            nofollow: user.profile.seo?.nofollow || false,
        };

        // إنشاء Schema.org JSON-LD
        const schema = {
            "@context": "https://schema.org",
            "@type": user.profile.schema?.type || 'Person',
            "name": user.profile.schema?.name || user.profile.nickname || user.username,
            "description": user.profile.schema?.description || user.profile.bio || '',
            "image": user.profile.schema?.image || user.profile.avatar || '',
            "sameAs": user.profile.schema?.sameAs || [],
            "url": profileUrl,
        };

        if (user.profile.schema?.jobTitle) {
            schema.jobTitle = user.profile.schema.jobTitle;
        }
        if (user.profile.schema?.worksFor) {
            schema.worksFor = user.profile.schema.worksFor;
        }
        if (user.profile.schema?.alumniOf?.length) {
            schema.alumniOf = user.profile.schema.alumniOf.map(org => ({
                "@type": "Organization",
                "name": org
            }));
        }
        if (user.profile.schema?.knowsAbout?.length) {
            schema.knowsAbout = user.profile.schema.knowsAbout;
        }

        res.json({
            metaTags,
            schema,
            preview: {
                google: {
                    title: metaTags.title,
                    description: metaTags.description,
                    url: profileUrl,
                },
                facebook: {
                    title: user.profile.seo?.ogTitle || metaTags.title,
                    description: user.profile.seo?.ogDescription || metaTags.description,
                    image: metaTags.ogImage,
                },
                twitter: {
                    card: user.profile.seo?.twitterCard || 'summary_large_image',
                    site: user.profile.seo?.twitterSite || '',
                },
            },
        });

    } catch (error) {
        logger.error(`Error generating SEO preview: ${error.message}`);
        res.status(500).json({ error: 'Failed to generate SEO preview' });
    }
});

// ============================================
// PUT /api/profile/appearance - تحديث المظهر
// ============================================
app.put('/api/profile/appearance', authenticateToken, [
    body('theme').optional().isObject(),
    body('layout').optional().isObject(),
    body('header').optional().isObject(),
    body('footer').optional().isObject(),
], async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }

        const { theme, layout, header, footer } = req.body;

        if (theme) user.profile.theme = { ...user.profile.theme, ...theme };
        if (layout) user.profile.layout = { ...user.profile.layout, ...layout };
        if (header) user.profile.header = { ...user.profile.header, ...header };
        if (footer) user.profile.footer = { ...user.profile.footer, ...footer };

        await user.save();

        res.json({
            success: true,
            message: 'Appearance updated successfully',
            data: {
                theme: user.profile.theme,
                layout: user.profile.layout,
                header: user.profile.header,
                footer: user.profile.footer,
            }
        });
    } catch (error) {
        logger.error(`Error updating appearance: ${error.message}`);
        res.status(500).json({ error: 'Failed to update appearance' });
    }
});



// ============================================
// PUT /api/profile/seo - تحديث SEO
// ============================================
app.put('/api/profile/seo', authenticateToken, [
    body('seo').optional().isObject(),
    body('schema').optional().isObject(),
], async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }

        const { seo, schema } = req.body;

        if (seo) user.profile.seo = { ...user.profile.seo, ...seo };
        if (schema) user.profile.schema = { ...user.profile.schema, ...schema };

        await user.save();

        res.json({
            success: true,
            message: 'SEO settings updated successfully',
            data: {
                seo: user.profile.seo,
                schema: user.profile.schema,
            }
        });
    } catch (error) {
        logger.error(`Error updating SEO: ${error.message}`);
        res.status(500).json({ error: 'Failed to update SEO' });
    }
});

app.get('/api/check-nickname', authenticateToken, [
    body('nickname').isLength({ min: 3 }).withMessage('Nickname must be at least 3 characters long'),
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const { nickname } = req.query;
        if (!nickname) {
            return res.status(400).json({ error: 'Nickname is required' });
        }
        const user = await User.findOne({
            'profile.nickname': { $regex: `^${nickname}$`, $options: 'i' },
            _id: { $ne: req.user.userId }
        });
        res.json({ available: !user });
    } catch (error) {
        logger.error(`Error checking nickname: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to check nickname' });
    }
});

app.put('/api/profile', authenticateToken, upload.fields([
    { name: 'avatar', maxCount: 1 },
    { name: 'projectImages', maxCount: 10 },
]), [
    body('nickname').optional().isLength({ min: 3 }).withMessage('Nickname must be at least 3 characters long'),
    body('jobTitle').optional().notEmpty().withMessage('Job title cannot be empty'),
    body('bio').optional().notEmpty().withMessage('Bio cannot be empty'),
    body('phone').optional().isMobilePhone().withMessage('Invalid phone number'),
    body('location').optional().isString().withMessage('Location must be a string'),
    body('industry').optional().isString().withMessage('Industry must be a string'),
    body('gender').optional().isIn(['male', 'female', 'other']).withMessage('Gender must be male, female, or other'),  // ✅ أضف هذا السطر
    body('showGender').optional().isBoolean().withMessage('showGender must be a boolean'),

    body('designSettings').optional().custom(value => {
        try {
            if (!value) return true;
            
            let parsed;
            if (typeof value === 'string') {
                parsed = JSON.parse(value);
            } else if (typeof value === 'object') {
                parsed = value;
            } else {
                return false;
            }
            
            // التحقق من الحقول
            const validFields = [
                'primaryColor', 'secondaryColor', 'fontFamily', 'borderRadius',
                'zoomLevel', 'shadowType', 'animationType', 'glassEffect',
                'backgroundType', 'backgroundValue', 'customCss'
            ];
            
            for (const key in parsed) {
                if (!validFields.includes(key)) return false;
            }
            
            // التحقق من الألوان
            if (parsed.primaryColor !== undefined && !/^#[0-9A-Fa-f]{6}$/.test(parsed.primaryColor)) {
                return false;
            }
            if (parsed.secondaryColor !== undefined && !/^#[0-9A-Fa-f]{6}$/.test(parsed.secondaryColor)) {
                return false;
            }
            
            // التحقق من الأرقام
            if (parsed.borderRadius !== undefined && (typeof parsed.borderRadius !== 'number' || parsed.borderRadius < 0 || parsed.borderRadius > 32)) {
                return false;
            }
            if (parsed.zoomLevel !== undefined && (typeof parsed.zoomLevel !== 'number' || parsed.zoomLevel < 50 || parsed.zoomLevel > 150)) {
                return false;
            }
            
            // التحقق من القوائم
            if (parsed.shadowType !== undefined && !['none', 'sm', 'md', 'lg', 'xl'].includes(parsed.shadowType)) {
                return false;
            }
            if (parsed.animationType !== undefined && !['none', 'hover', 'scale', 'glow'].includes(parsed.animationType)) {
                return false;
            }
            if (parsed.glassEffect !== undefined && typeof parsed.glassEffect !== 'boolean') {
                return false;
            }
            if (parsed.backgroundType !== undefined && !['default', 'dots', 'grid', 'cross', 'gradient', 'image'].includes(parsed.backgroundType)) {
                return false;
            }
            if (parsed.backgroundValue !== undefined && typeof parsed.backgroundValue !== 'string') {
                return false;
            }
            if (parsed.customCss !== undefined && typeof parsed.customCss !== 'string') {
                return false;
            }
            
            return true;
        } catch (error) {
            return false;
        }
    }).withMessage('Invalid design settings format'),
    body('sectionVisibility').optional().custom(value => {
        try {
            if (!value) return true;
            const parsed = typeof value === 'string' ? JSON.parse(value) : value;
            const validSections = ['about', 'experience', 'education', 'certificates', 'skills', 
                'projects', 'interests', 'contactInfo', 'socialLinks', 'stats', 'activity', 
                'contributionGraph', 'alsoViewed', 'suggestions', 'pages', 'jobApplications', 'analytics'];
            
            for (const key in parsed) {
                if (!validSections.includes(key)) return false;
                if (typeof parsed[key] !== 'boolean') return false;
            }
            return true;
        } catch {
            return false;
        }
    }).withMessage('Invalid section visibility format'),

        body('sectionOrder').optional().custom(value => {
        try {
            if (!value) return true;
            let parsed = value;
            if (typeof value === 'string') {
                parsed = JSON.parse(value);
            }
            if (!Array.isArray(parsed)) return false;
            for (const sectionId of parsed) {
                if (typeof sectionId !== 'string') return false;
            }
            return true;
        } catch (error) {
            return false;
        }
    }).withMessage('Invalid section order format'),

    body('socialLinks').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            const validKeys = ['linkedin', 'behance', 'github', 'whatsapp'];
            for (const key in parsed) {
                if (!validKeys.includes(key)) return false;
                if (parsed[key] && !/^https?:\/\/[^\s/$.?#].[^\s]*$/.test(parsed[key])) return false;
            }
            return true;
        } catch {
            return false;
        }
    }).withMessage('Invalid social links format or URLs'),
    body('education').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return Array.isArray(parsed) && parsed.every(item => item.institution && item.degree && item.year && !isNaN(parseInt(item.year)) && parseInt(item.year) >= 1900 && parseInt(item.year) <= new Date().getFullYear());
        } catch {
            return false;
        }
    }).withMessage('Invalid education format'),
    body('experience').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return Array.isArray(parsed) && parsed.every(item => item.company && item.role && item.duration);
        } catch {
            return false;
        }
    }).withMessage('Invalid experience format'),
    body('certificates').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return Array.isArray(parsed) && parsed.every(item => item.name && item.issuer && item.year && !isNaN(parseInt(item.year)) && parseInt(item.year) >= 1900 && parseInt(item.year) <= new Date().getFullYear());
        } catch {
            return false;
        }
    }).withMessage('Invalid certificates format'),
    body('skills').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return Array.isArray(parsed) && parsed.every(item => 
                item.name && 
                typeof item.percentage === 'number' && 
                item.percentage >= 0 && 
                item.percentage <= 100 &&
                (item.icon === undefined || typeof item.icon === 'string')
            );
        } catch {
            return false;
        }
    }).withMessage('Invalid skills format'),
    body('projects').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            if (!Array.isArray(parsed)) return false;
            
            for (const item of parsed) {
                // 1. التحقق من وجود title
                if (!item.title) return false;
                
                // 2. التحقق من description (نوع فقط، مش طول)
                if (item.description && typeof item.description !== 'string') return false;
                
                // 3. التحقق من الصورة
                if (item.image && !/^https?:\/\//.test(item.image) && !item.image.startsWith('/assets/')) {
                    return false;
                }
                
                // 4. التحقق من الروابط
                if (item.links && Array.isArray(item.links)) {
                    for (const link of item.links) {
                        if (!link.option || typeof link.option !== 'string') return false;
                        if (!link.value || typeof link.value !== 'string') return false;
                        if (!/^https?:\/\//.test(link.value)) return false;
                    }
                }
                
                // ✅ 5. إذا كان المشروع من GitHub، تجاوز كل القيود
                if (item.importedFrom === 'github') {
                    continue;  // 👈 يسمح بأي عدد نجوم وأي طول وصف
                }
                
                // ✅ 6. للمشاريع العادية فقط: التحقق من النجوم (0-5)
                if (item.stars !== undefined && (typeof item.stars !== 'number' || item.stars < 0 || item.stars > 5)) {
                    return false;
                }
                
                // ✅ 7. للمشاريع العادية فقط: description لا يمكن أن يكون طويل جداً
                if (item.description && item.description.length > 5000) {
                    return false;
                }
            }
            return true;
        } catch (error) {
            console.error('Projects validation error:', error);
            return false;
        }
    }).withMessage('Invalid projects format'),
    body('interests').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return Array.isArray(parsed) && parsed.every(item => typeof item === 'string');
        } catch {
            return false;
        }
    }).withMessage('Invalid interests format'),
    body('isPublic').optional().isBoolean().withMessage('isPublic must be a boolean'),
    body('avatarDisplayType').optional().isIn(['svg', 'normal']).withMessage('Invalid avatar display type'),
    body('resumeUrl').optional().custom(value => {
        // السماح بالقيم الفارغة
        if (!value || value === '') return true;
        // التحقق من صحة الرابط فقط إذا كان فيه قيمة
        return /^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$/.test(value);
    }).withMessage('Invalid resume URL format'),


    body('svgColor').optional().matches(/^#[0-9A-Fa-f]{6}$/).withMessage('Invalid SVG color format'),
    body('githubProjectIds').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return Array.isArray(parsed) && parsed.every(id => Number.isInteger(Number(id)));
        } catch {
            return false;
        }
    }).withMessage('Invalid GitHub project IDs format'),

    body('theme').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return parsed.id && parsed.primaryColor && parsed.secondaryColor;
        } catch {
            return false;
        }
    }).withMessage('Invalid theme format'),

    body('layout').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return parsed.type && ['grid', 'list', 'masonry'].includes(parsed.type);
        } catch {
            return false;
        }
    }).withMessage('Invalid layout format'),

    body('header').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return parsed.layout && ['centered', 'left-aligned'].includes(parsed.layout);
        } catch {
            return false;
        }
    }).withMessage('Invalid header format'),

    body('footer').optional().custom(value => {
        try {
            JSON.parse(value);
            return true;
        } catch {
            return false;
        }
    }).withMessage('Invalid footer format'),

    body('seo').optional().custom(value => {
        try {
            JSON.parse(value);
            return true;
        } catch {
            return false;
        }
    }).withMessage('Invalid SEO format'),

    body('schema').optional().custom(value => {
        try {
            JSON.parse(value);
            return true;
        } catch {
            return false;
        }
    }).withMessage('Invalid schema format'),

    body('audio').optional().custom(value => {
        try {
            const parsed = JSON.parse(value);
            return parsed && 
                   (parsed.url === undefined || typeof parsed.url === 'string') &&
                   (parsed.title === undefined || typeof parsed.title === 'string') &&
                   (parsed.delay === undefined || (typeof parsed.delay === 'number' && parsed.delay >= 0 && parsed.delay <= 10)) &&
                   (parsed.loop === undefined || typeof parsed.loop === 'boolean') &&
                   (parsed.volume === undefined || (typeof parsed.volume === 'number' && parsed.volume >= 0 && parsed.volume <= 100));
        } catch {
            return false;
        }
    }).withMessage('Invalid audio format'),

        body('aiBot').optional().custom(value => {
        try {
            // السماح بالقيم الفارغة
            if (!value || value === '') return true;
            
            let parsed;
            if (typeof value === 'string') {
                parsed = JSON.parse(value);
            } else if (typeof value === 'object') {
                parsed = value;
            } else {
                return false;
            }
            
            // التحقق من الحقول
            if (parsed.enabled !== undefined && typeof parsed.enabled !== 'boolean') {
                return false;
            }
            
            if (parsed.provider !== undefined && !['mgzon', 'custom'].includes(parsed.provider)) {
                return false;
            }
            
            if (parsed.customApiKey !== undefined && typeof parsed.customApiKey !== 'string') {
                return false;
            }
            
            if (parsed.customModel !== undefined && typeof parsed.customModel !== 'string') {
                return false;
            }
            
            if (parsed.temperature !== undefined && (typeof parsed.temperature !== 'number' || parsed.temperature < 0 || parsed.temperature > 1)) {
                return false;
            }
            
            if (parsed.maxTokens !== undefined && (typeof parsed.maxTokens !== 'number' || parsed.maxTokens < 50 || parsed.maxTokens > 2000)) {
                return false;
            }
            
            if (parsed.systemPrompt !== undefined && typeof parsed.systemPrompt !== 'string') {
                return false;
            }
            
            return true;
        } catch (error) {
            return false;
        }
    }).withMessage('Invalid AI Bot configuration'),

    body('sectionNames').optional().custom(value => {
        try {
            if (!value) return true;
            let parsed = value;
            if (typeof value === 'string') {
                parsed = JSON.parse(value);
            }
            if (typeof parsed !== 'object') return false;
            return true;
        } catch {
            return false;
        }
    }).withMessage('Invalid section names format'),

    body('customSections').optional().custom(value => {
        try {
            if (!value) return true;
            let parsed = value;
            if (typeof value === 'string') {
                parsed = JSON.parse(value);
            }
            if (!Array.isArray(parsed)) return false;
            
            for (const section of parsed) {
                if (!section.name || typeof section.name !== 'string') return false;
                // ✅ تحديث: إضافة الأنواع الجديدة
                if (section.type && !['text', 'skills', 'links', 'gallery', 'stats', 'timeline', 'testimonials', 'cta'].includes(section.type)) return false;
                
                // ✅ إضافة التحقق من settings (اختياري)
                if (section.settings !== undefined && typeof section.settings !== 'object') return false;
            }
            return true;
        } catch (error) {
            return false;
        }
    }).withMessage('Invalid custom sections format'),], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const {
            nickname, jobTitle ,avatar, coverImage, bio, phone, socialLinks, education, experience,sectionOrder,designSettings,
            certificates, skills, projects, interests, isPublic, avatarDisplayType,aiBot,gender,showGender,sectionVisibility,
            svgColor, status, portfolioName, pdfFormat, theme, layout, header, footer, seo, schema, resumeUrl,industry,location, showEmail ,sectionStyleSettings
        } = req.body;

        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }

        // التحقق من توفر الـ nickname إذا تم إرساله
        if (nickname && nickname !== user.profile.nickname) {
            const existingUser = await User.findOne({ 'profile.nickname': nickname, _id: { $ne: user._id } });
            if (existingUser) {
                return res.status(400).json({ error: 'Nickname already taken' });
            }
        }

        const parseJSON = (str, defaultValue) => {
            try {
                if (!str) return defaultValue;
                const parsed = JSON.parse(str);
                return { ...defaultValue, ...parsed };
            } catch (error) {
                logger.error(`Invalid JSON: ${error.message}`);
                Sentry.captureException(error);
                return defaultValue;
            }
        };

        // تحديث إعدادات المظهر
        if (theme) user.profile.theme = parseJSON(theme, user.profile.theme);
        if (layout) user.profile.layout = parseJSON(layout, user.profile.layout);
        if (header) user.profile.header = parseJSON(header, user.profile.header);
        if (footer) user.profile.footer = parseJSON(footer, user.profile.footer);
        if (seo) user.profile.seo = parseJSON(seo, user.profile.seo);
        if (schema) user.profile.schema = parseJSON(schema, user.profile.schema);

        // Parse input fields
        const parsedSocialLinks = parseJSON(socialLinks, user.profile.socialLinks);
        const parsedEducation = parseJSON(education, user.profile.education);
        const parsedExperience = parseJSON(experience, user.profile.experience);
        const parsedCertificates = parseJSON(certificates, user.profile.certificates);
        
        // ✅ معالجة المهارات مع الأيقونات
        let parsedSkills = [];
        try {
            if (skills) {
                // لو skills جاية كـ string
                if (typeof skills === 'string') {
                    const parsed = JSON.parse(skills);
                    if (Array.isArray(parsed)) {
                        parsedSkills = parsed;
                    } else if (typeof parsed === 'object') {
                        parsedSkills = Object.values(parsed);
                    }
                } 
                // لو skills جاية كـ array أصلاً
                else if (Array.isArray(skills)) {
                    parsedSkills = skills;
                }
                // لو skills جاية كـ object
                else if (typeof skills === 'object') {
                    parsedSkills = Object.values(skills);
                }
            }
        } catch (error) {
            logger.error(`Error parsing skills: ${error.message}`);
            parsedSkills = [];
        }

        const skillsWithIcons = parsedSkills.map(skill => ({
            name: skill.name || '',
            percentage: skill.percentage || 0,
            icon: skill.icon || ''
        }));

        let parsedProjects = parseJSON(projects, user.profile.projects);
        const parsedInterests = parseJSON(interests, user.profile.interests);

        // ✅ تحويل parsedProjects إلى Array مع الحفاظ على _id
        if (parsedProjects) {
            // إذا كان object وليس array، حوله إلى array
            if (typeof parsedProjects === 'object' && !Array.isArray(parsedProjects)) {
                parsedProjects = Object.values(parsedProjects);
            }
            
            // ✅ تأكد من أن كل مشروع له _id فريد
            parsedProjects = parsedProjects.map(project => ({
                _id: project._id || new mongoose.Types.ObjectId(),
                createdAt: project.createdAt || Date.now(),
                ...project
            }));
        } else {
            parsedProjects = [];
        }

        // ✅ معالجة إعدادات الصوت
        let audioSettings = {
            url: '',
            title: '',
            delay: 0,
            loop: true,
            volume: 50
        };
        if (req.body.audio) {
            try {
                const audioData = JSON.parse(req.body.audio);
                audioSettings = {
                    url: audioData.url || '',
                    title: audioData.title || '',
                    delay: audioData.delay || 0,
                    loop: audioData.loop !== undefined ? audioData.loop : true,
                    volume: audioData.volume || 50
                };
            } catch (e) {
                logger.error('Error parsing audio data:', e);
            }
        }

        const githubProjectIds = req.body.githubProjectIds || '[]';
        const parsedGithubProjectIds = parseJSON(githubProjectIds, []);



        // ✅ معالجة customSections
        let customSectionsConfig = user.profile?.customSections || [];

        if (req.body.customSections) {
            try {
                let parsed = req.body.customSections;
                if (typeof parsed === 'string') {
                    parsed = JSON.parse(parsed);
                }
                if (Array.isArray(parsed)) {
                    customSectionsConfig = parsed;
                    console.log('✅ Custom sections saved:', customSectionsConfig.length);
                }
            } catch (error) {
                console.error('Error parsing customSections:', error.message);
            }
        }

        // ✅ معالجة sectionNames
        let sectionNamesConfig = user.profile?.sectionNames || {};

        if (req.body.sectionNames) {
            try {
                let parsed = req.body.sectionNames;
                if (typeof parsed === 'string') {
                    parsed = JSON.parse(parsed);
                }
                if (typeof parsed === 'object') {
                    sectionNamesConfig = { ...sectionNamesConfig, ...parsed };
                    console.log('✅ Section names saved:', Object.keys(sectionNamesConfig).length);
                }
            } catch (error) {
                console.error('Error parsing sectionNames:', error.message);
            }
        }

        // ============================================
        // ✅ معالجة إعدادات التصميم (Design Settings)
        // ============================================
        let designSettingsConfig = user.profile?.designSettings || {
            primaryColor: '#3b82f6',
            secondaryColor: '#8b5cf6',
            fontFamily: 'Inter, sans-serif',
            borderRadius: 16,
            zoomLevel: 100,
            shadowType: 'md',
            animationType: 'none',
            glassEffect: false,
            backgroundType: 'default',
            backgroundValue: '',
            customCss: ''
        };

        if (req.body.designSettings) {
            try {
                let parsed = req.body.designSettings;
                if (typeof parsed === 'string') {
                    parsed = JSON.parse(parsed);
                }
                designSettingsConfig = { ...designSettingsConfig, ...parsed };
                console.log('✅ Design settings saved:', designSettingsConfig);
            } catch (error) {
                console.error('Error parsing designSettings:', error.message);
            }
        }
        // ============================================
        // ✅ معالجة إعدادات AI Bot
        // ============================================
        let aiBotConfig = {
            enabled: false,
            provider: 'mgzon',
            customApiKey: '',
            customModel: 'Qwen/Qwen2.5-7B-Instruct',
            temperature: 0.7,
            maxTokens: 400,
            systemPrompt: '',
            totalQueries: user.profile?.aiBot?.totalQueries || 0,
            lastQueryAt: user.profile?.aiBot?.lastQueryAt || null
        };

        if (req.body.aiBot) {
            try {
                let aiBotData = req.body.aiBot;
                if (typeof aiBotData === 'string') {
                    aiBotData = JSON.parse(aiBotData);
                }
                
                aiBotConfig = {
                    enabled: aiBotData.enabled === true || aiBotData.enabled === 'true',
                    provider: aiBotData.provider === 'custom' ? 'custom' : 'mgzon',
                    customApiKey: aiBotData.customApiKey || '',
                    customModel: aiBotData.customModel || 'Qwen/Qwen2.5-7B-Instruct',
                    temperature: parseFloat(aiBotData.temperature) || 0.7,
                    maxTokens: parseInt(aiBotData.maxTokens) || 400,
                    systemPrompt: aiBotData.systemPrompt || '',
                    totalQueries: user.profile?.aiBot?.totalQueries || 0,
                    lastQueryAt: user.profile?.aiBot?.lastQueryAt || null
                };
                
                console.log('✅ AI Bot config received:', {
                    enabled: aiBotConfig.enabled,
                    provider: aiBotConfig.provider,
                    customModel: aiBotConfig.customModel
                });
                
            } catch (error) {
                console.error('Error parsing AI Bot config:', error.message);
            }
        }
        // Handle avatar image
        let hasTransparency = false;
        if (req.files && req.files.avatar) {
            try {
                const imageBuffer = req.files.avatar[0].buffer;
                const image = sharp(imageBuffer);
                const metadata = await image.metadata();
                hasTransparency = metadata.hasAlpha || false;
                const uploadResult = await cloudinary.uploader.upload_stream({ folder: 'avatars' }).end(imageBuffer);
                user.profile.avatar = uploadResult.secure_url;
            } catch (imageError) {
                logger.error(`Error processing avatar image: ${imageError.message}`);
                Sentry.captureException(imageError);
            }
        }

        // Handle project images
        if (req.files && req.files.projectImages) {
            parsedProjects = await Promise.all(parsedProjects.map(async (project, index) => {
                if (req.files.projectImages[index]) {
                    try {
                        const imageBuffer = req.files.projectImages[index].buffer;
                        const uploadResult = await cloudinary.uploader.upload_stream({ folder: 'projects' }).end(imageBuffer);
                        return { ...project, image: uploadResult.secure_url };
                    } catch (imageError) {
                        logger.error(`Error processing project image ${index}: ${imageError.message}`);
                        Sentry.captureException(imageError);
                        return project;
                    }
                }
                return project;
            }));
        }

        // Fetch GitHub projects if githubProjectIds are provided
        if (parsedGithubProjectIds.length > 0 && user.githubAccessToken) {
            try {
                for (const githubProjectId of parsedGithubProjectIds) {
                    if (!Number.isInteger(Number(githubProjectId))) {
                        throw new Error(`Invalid GitHub project ID: ${githubProjectId}`);
                    }
                    const response = await axios.get(`https://api.github.com/repositories/${githubProjectId}`, {
                        headers: { Authorization: `Bearer ${user.githubAccessToken}` },
                    });
                    if (response.status === 401) {
                        return res.status(401).json({ error: 'GitHub access token expired. Please re-authenticate.' });
                    }
                    const repo = response.data;
                    parsedProjects.push({
                        title: repo.name,
                        description: repo.description || 'No description provided',
                        image: req.files.projectImages && req.files.projectImages[parsedProjects.length]
                            ? (await cloudinary.uploader.upload_stream({ folder: 'projects' }).end(req.files.projectImages[parsedProjects.length].buffer)).secure_url
                            : repo.owner.avatar_url,
                        links: [{ option: 'GitHub', value: repo.html_url }],
                    });
                }
            } catch (githubError) {
                logger.error(`Error fetching GitHub project: ${githubError.message}`);
                Sentry.captureException(githubError);
                return res.status(400).json({ error: `Failed to fetch GitHub project: ${githubError.message}` });
            }
        }


        // ============================================
        // ✅ معالجة إعدادات إظهار/إخفاء الأقسام
        // ============================================
        let sectionVisibilityConfig = user.profile?.sectionVisibility || {
            about: true, experience: true, education: true, certificates: true,
            skills: true, projects: true, interests: true, contactInfo: true,
            socialLinks: true, stats: true, activity: true, contributionGraph: true,
            alsoViewed: true, suggestions: true, pages: true, jobApplications: true, analytics: true
        };

        if (sectionVisibility) {
            try {
                let parsed = sectionVisibility;
                if (typeof sectionVisibility === 'string') {
                    parsed = JSON.parse(sectionVisibility);
                }
                sectionVisibilityConfig = { ...sectionVisibilityConfig, ...parsed };
                console.log('✅ Section visibility config saved:', sectionVisibilityConfig);
            } catch (error) {
                console.error('Error parsing sectionVisibility:', error.message);
            }
        }



        // ============================================
        // ✅ معالجة إعدادات شكل الأقسام (Section Style Settings)
        // ============================================
        if (sectionStyleSettings !== undefined) {
            user.profile.sectionStyleSettings = sectionStyleSettings;
            console.log('✅ Section style settings saved:', Object.keys(sectionStyleSettings).length);
        }
        // ============================================
        // ✅ معالجة ترتيب الأقسام (sectionOrder)
        // ============================================
        let sectionOrderConfig = user.profile?.sectionOrder || [];

        if (req.body.sectionOrder) {
            try {
                let parsedOrder = req.body.sectionOrder;
                if (typeof parsedOrder === 'string') {
                    parsedOrder = JSON.parse(parsedOrder);
                }
                if (Array.isArray(parsedOrder)) {
                    sectionOrderConfig = parsedOrder;
                    console.log('✅ Section order saved:', sectionOrderConfig);
                }
            } catch (error) {
                console.error('Error parsing sectionOrder:', error.message);
            }
        }
        // ✅ تحديث كامل بيانات المستخدم
        user.profile = {
            nickname: nickname || user.profile.nickname,
            avatar: avatar || user.profile.avatar || undefined,
            coverImage: coverImage || user.profile.coverImage || '',
            jobTitle: jobTitle || user.profile.jobTitle,
            bio: bio || user.profile.bio,
            phone: phone || user.profile.phone,
            industry: industry || user.profile.industry || '',
            location: location || user.profile.location || '',
            socialLinks: parsedSocialLinks,
            education: parsedEducation,
            showEmail: showEmail !== undefined ? showEmail === 'true' : user.profile.showEmail,
            gender: gender || user.profile?.gender || 'male',
            showGender: showGender === 'true' || showGender === true,
            sectionVisibility: sectionVisibilityConfig,
            sectionOrder: sectionOrderConfig,
            customSections: customSectionsConfig,
            sectionNames: sectionNamesConfig,
            aiBot: aiBotConfig,
            sectionStyleSettings: sectionStyleSettings !== undefined ? sectionStyleSettings : user.profile.sectionStyleSettings,
            designSettings: designSettingsConfig,
            experience: parsedExperience,
            certificates: parsedCertificates,
            skills: skillsWithIcons,
            projects: parsedProjects,
            resumeUrl: resumeUrl || user.profile.resumeUrl || '',
            interests: parsedInterests,
            isPublic: isPublic !== undefined ? isPublic === 'true' : user.profile.isPublic,
            avatarDisplayType: avatarDisplayType || user.profile.avatarDisplayType,
            svgColor: svgColor || user.profile.svgColor,
            customFields: parseJSON(req.body.customFields, user.profile.customFields || []),
            portfolioName: portfolioName || user.profile.portfolioName || 'Portfolio',
            status: status || user.profile.status || 'Available',
            pdfFormat: pdfFormat || user.profile.pdfFormat || 'jspdf',
            audio: audioSettings,
            theme: theme ? parseJSON(theme, user.profile.theme) : user.profile.theme || {
                id: 'default',
                primaryColor: '#3b82f6',
                secondaryColor: '#8b5cf6',
                fontFamily: 'Inter',
                borderRadius: '0.5rem',
            },
            layout: layout ? parseJSON(layout, user.profile.layout) : user.profile.layout || {
                type: 'grid',
                columns: 3,
                showProjectImages: true,
                showProjectDescriptions: true,
                showProjectRatings: true,
                showProjectLinks: true,
            },
            header: header ? parseJSON(header, user.profile.header) : user.profile.header || {
                showAvatar: true,
                showJobTitle: true,
                showBio: true,
                showContactInfo: true,
                showSocialLinks: true,
                layout: 'centered',
            },
            footer: footer ? parseJSON(footer, user.profile.footer) : user.profile.footer || {
                showCopyright: true,
                customText: '',
            },
            seo: seo ? parseJSON(seo, user.profile.seo) : user.profile.seo || {
                title: portfolioName || 'My Portfolio',
                description: bio || '',
                keywords: '',
                ogImage: user.profile.avatar || '',
                ogTitle: '',
                ogDescription: '',
                twitterCard: 'summary_large_image',
                twitterSite: '',
                canonicalUrl: '',
                noindex: false,
                nofollow: false,
            },
            schema: schema ? parseJSON(schema, user.profile.schema) : user.profile.schema || {
                type: 'Person',
                name: nickname || user.username,
                description: bio || '',
                image: user.profile.avatar || '',
                sameAs: [],
                jobTitle: jobTitle || '',
                worksFor: '',
                alumniOf: [],
                knowsAbout: [],
            },
        };

        user.markModified('profile.designSettings');
        user.markModified('profile');


        await user.save();

        // ✅ حفظ المشاريع في Project collection (بعد حفظ user.profile)
        if (parsedProjects && parsedProjects.length > 0) {
            try {
                // حذف المشاريع القديمة للمستخدم
                await Project.deleteMany({ userId: user._id });
                
                // حفظ المشاريع الجديدة مع الاحتفاظ بـ _id الأصلي
                for (const project of parsedProjects) {
                    const newProject = new Project({
                        _id: project._id, // ✅ استخدام _id الأصلي من المشروع
                        title: project.title || '',
                        description: project.description || '',
                        image: project.image || '',
                        rating: project.rating || '',
                        stars: project.stars || 0,
                        links: project.links || [],
                        userId: user._id,
                        isPublic: project.isPublic !== false,
                        createdAt: project.createdAt || Date.now(),
                        githubData: project.githubData || null,  // ✅ أضف هذا السطر
                        importedFrom: project.importedFrom || null,  // ✅ وأضف هذا أيضاً
                        githubId: project.githubId || null  // ✅ وأضف هذا

                    });
                    await newProject.save();
                }
                logger.info(`Saved ${parsedProjects.length} projects for user ${user._id}`);
            } catch (projectError) {
                logger.error(`Error saving projects: ${projectError.message}`);
                // لا نوقف التنفيذ، فقط نسجل الخطأ
            }
        }

        // Track profile update in Google Analytics
        try {
            await axios.post('https://www.google-analytics.com/mp/collect', {
                measurement_id: process.env.GOOGLE_ANALYTICS_ID,
                api_secret: process.env.GOOGLE_ANALYTICS_API_SECRET,
                events: [{
                    name: 'update_profile',
                    params: {
                        userId: req.user.userId,
                        updatedFields: Object.keys(req.body),
                        timestamp: new Date().toISOString(),
                    },
                }],
            }, {
                headers: { 'Content-Type': 'application/json' },
                timeout: 5000,
            });
            logger.info(`Profile update tracked for user ${req.user.userId}`);
        } catch (analyticsError) {
            logger.error(`Failed to track profile update: ${analyticsError.message}`);
            Sentry.captureException(analyticsError);
        }

        res.json({
            success: true,
            message: 'Profile updated successfully',
            profile: user.profile,
            hasTransparency,
        });
    } catch (error) {
        logger.error(`Error updating profile for user ${req.user.userId}: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: `Failed to update profile: ${error.message}` });
    }
});


// ============================================
// POST /api/upload-cover - رفع صورة الغلاف
// ============================================
app.post('/api/upload-cover', authenticateToken, upload.single('cover'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ error: 'No file uploaded' });
        }
        
        const allowedTypes = ['image/jpeg', 'image/png', 'image/jpg', 'image/webp'];
        if (!allowedTypes.includes(req.file.mimetype)) {
            return res.status(400).json({ error: 'Only JPEG, PNG, WEBP images are allowed' });
        }
        
        if (req.file.size > 5 * 1024 * 1024) {
            return res.status(400).json({ error: 'File size must be less than 5MB' });
        }
        
        const coverUrl = req.file.path;
        
        // حفظ الرابط في قاعدة البيانات
        await User.findByIdAndUpdate(req.user.userId, {
            'profile.coverImage': coverUrl
        });
        
        res.json({ success: true, coverUrl: coverUrl });
        
    } catch (error) {
        logger.error(`Error uploading cover image: ${error.message}`);
        res.status(500).json({ error: 'Failed to upload cover image' });
    }
});

// ============================================
// DELETE /api/cover - حذف صورة الغلاف
// ============================================
app.delete('/api/cover', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (user.profile.coverImage && user.profile.coverImage !== '/assets/img/default-cover.png') {
            // حذف من Cloudinary (اختياري)
            const publicId = user.profile.coverImage.split('/').pop().split('.')[0];
            if (publicId && user.profile.coverImage.includes('cloudinary')) {
                await cloudinary.uploader.destroy(`covers/${publicId}`);
            }
        }
        
        user.profile.coverImage = '';
        await user.save();
        
        res.json({ success: true, message: 'Cover image removed' });
        
    } catch (error) {
        logger.error(`Error removing cover image: ${error.message}`);
        res.status(500).json({ error: 'Failed to remove cover image' });
    }
});

// ============================================
// حذف مشروع من ملف المستخدم
// ============================================
app.delete('/api/users/me/projects/:projectId', authenticateToken, async (req, res) => {
    try {
        const { projectId } = req.params;
        const userId = req.user.userId;

        // ✅ التحقق من صحة الـ ObjectId
        if (!mongoose.Types.ObjectId.isValid(projectId)) {
            return res.status(400).json({
                success: false,
                error: 'Invalid project ID'
            });
        }

        // ✅ البحث عن المستخدم
        const user = await User.findById(userId);

        if (!user) {
            return res.status(404).json({
                success: false,
                error: 'User not found'
            });
        }

        // ✅ التأكد إن projects عبارة عن Array
        if (!user.profile || !Array.isArray(user.profile.projects)) {
            return res.status(400).json({
                success: false,
                error: 'Projects data is corrupted'
            });
        }

        // ✅ البحث عن المشروع
        const projectIndex = user.profile.projects.findIndex(project =>
            project &&
            project._id &&
            project._id.toString() === projectId
        );

        if (projectIndex === -1) {
            return res.status(404).json({
                success: false,
                error: 'Project not found in user profile'
            });
        }

        // ✅ حذف المشروع من user.profile.projects
        const deletedProject = user.profile.projects[projectIndex];

        user.profile.projects.splice(projectIndex, 1);

        // ✅ مهم جداً عشان mongoose يحس بالتعديل
        user.markModified('profile.projects');

        // ✅ حفظ المستخدم
        await user.save();

        logger.info(`Project removed from user profile: ${projectId}`);

        // ✅ حذف التعليقات المرتبطة بالمشروع
        try {
            if (mongoose.models.Comment) {
                const commentsResult = await mongoose.models.Comment.deleteMany({
                    projectId: projectId,
                    userId: userId
                });

                logger.info(`Deleted ${commentsResult.deletedCount} comments`);
            }
        } catch (commentError) {
            logger.error(`Error deleting comments: ${commentError.message}`);
        }

        // ✅ حذف المشروع من Project collection أيضاً
        try {
            const deletedFromProjects = await Project.findOneAndDelete({
                _id: projectId,
                userId: userId
            });

            if (deletedFromProjects) {
                logger.info(`Project deleted from Project collection: ${projectId}`);
            } else {
                logger.warn(`Project not found in Project collection: ${projectId}`);
            }

        } catch (projectDeleteError) {
            logger.error(`Error deleting from Project collection: ${projectDeleteError.message}`);
        }

        return res.json({
            success: true,
            message: 'Project deleted successfully',
            deletedProjectId: projectId,
            remainingProjects: user.profile.projects.length
        });

    } catch (error) {

        logger.error(`Error deleting project: ${error.message}`);

        if (typeof Sentry !== 'undefined') {
            Sentry.captureException(error);
        }

        return res.status(500).json({
            success: false,
            error: error.message || 'Failed to delete project'
        });
    }
});

cron.schedule('0 0 * * *', async () => {
    try {
        const users = await User.find({ githubAccessToken: { $exists: true }, 'profile.projects': { $elemMatch: { 'links.option': 'GitHub' } } });
        for (const user of users) {
            const githubProjects = user.profile.projects.filter(p => p.links.some(l => l.option === 'GitHub'));
            for (const project of githubProjects) {
                const githubLink = project.links.find(l => l.option === 'GitHub')?.value;
                if (!githubLink) continue;
                try {
                    const repoName = githubLink.split('/').slice(-2).join('/');
                    const response = await axios.get(`https://api.github.com/repos/${repoName}`, {
                        headers: { Authorization: `Bearer ${user.githubAccessToken}` },
                    });
                    if (response.status === 401) {
                        logger.warn(`GitHub token expired for user ${user.email}`);
                        continue;
                    }
                    const repo = response.data;
                    project.title = repo.name;
                    project.description = repo.description || project.description;
                    project.image = project.image || repo.owner.avatar_url;
                } catch (error) {
                    logger.error(`Error syncing GitHub project ${githubLink} for user ${user.email}: ${error.message}`);
                    Sentry.captureException(error);
                }
            }
            await user.save();
            logger.info(`Synced GitHub projects for user ${user.email}`);
        }
    } catch (error) {
        logger.error(`Error in cron job: ${error.message}`);
        Sentry.captureException(error);
    }
});

const githubLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 10,
    message: 'Too many GitHub API requests, please try again later.',
    validate: { trustProxy: false }
});
app.use('/api/github', githubLimiter);


// ============================================
// GET /api/user-interactions - جلب تفاعلات المستخدم
// ============================================
app.get('/api/user-interactions', authenticateToken, async (req, res) => {
    try {
        // ✅ 1. جلب جميع تعليقات المستخدم
        const comments = await Comment.find({ userId: req.user.userId })
            .sort({ timestamp: -1 });
        
        if (comments.length === 0) {
            return res.json([]);
        }
        
        // ✅ 2. تجميع معرفات أصحاب المشاريع والمشاريع
        const projectOwnerIds = [...new Set(comments.map(c => c.projectOwnerId?.toString()).filter(Boolean))];
        const projectIds = [...new Set(comments.map(c => c.projectId?.toString()).filter(Boolean))];
        
        // ✅ 3. جلب بيانات أصحاب المشاريع
        const projectOwners = await User.find({ _id: { $in: projectOwnerIds } })
            .select('_id profile.nickname profile.projects')
            .lean();
        
        // ✅ 4. إنشاء Map لربط projectId بمعلومات المشروع
        const projectsInfoMap = new Map();
        
        for (const owner of projectOwners) {
            let ownerProjects = [];
            if (owner.profile?.projects) {
                if (Array.isArray(owner.profile.projects)) {
                    ownerProjects = owner.profile.projects;
                } else if (typeof owner.profile.projects === 'object') {
                    ownerProjects = Object.values(owner.profile.projects);
                }
            }
            
            for (const project of ownerProjects) {
                if (project._id) {
                    projectsInfoMap.set(project._id.toString(), {
                        title: project.title || 'Unknown Project',
                        image: project.image || null,
                        ownerNickname: owner.profile?.nickname || owner.username
                    });
                }
            }
        }
        
        // ✅ 5. تجهيز الرد مع معلومات المشروع الصحيحة
        const enrichedComments = comments.map(comment => {
            const projectInfo = projectsInfoMap.get(comment.projectId?.toString());
            
            return {
                _id: comment._id,
                commentId: comment._id,
                projectId: comment.projectId,
                projectTitle: projectInfo?.title || 'Unknown Project',
                projectNickname: projectInfo?.ownerNickname || null,
                projectImage: projectInfo?.image || null,
                rating: comment.rating,
                text: comment.text,
                timestamp: comment.timestamp,
                replies: comment.replies || [],
                likes: comment.likes || [],
                isEdited: comment.isEdited || false,
                parentCommentId: comment.parentCommentId,
                visibility: comment.visibility || 'public'
            };
        });
        
        res.json(enrichedComments);
        
    } catch (error) {
        logger.error(`Error fetching user interactions: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch interactions: ' + error.message });
    }
});

// ============================================
// PUT /api/comments/:commentId/privacy - تحديث خصوصية تعليق
// ============================================
// ============================================
// PUT /api/comments/:commentId/privacy - تحديث خصوصية تعليق
// ============================================
app.put('/api/comments/:commentId/privacy', authenticateToken, async (req, res) => {
    const { commentId } = req.params;
    const { visibility } = req.body;
    
    try {
        const comment = await Comment.findById(commentId);
        if (!comment) {
            return res.status(404).json({ error: 'Comment not found' });
        }
        
        // فقط صاحب التعليق يمكنه تعديل الخصوصية
        if (comment.userId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized' });
        }
        
        comment.visibility = visibility; // public, logged-in, only-me
        await comment.save();
        
        res.json({ success: true, message: 'Privacy updated', visibility });
        
    } catch (error) {
        logger.error(`Error updating comment privacy: ${error.message}`);
        res.status(500).json({ error: 'Failed to update privacy' });
    }
});
// ============================================

// ============================================
// GET /api/profile/:nickname/interactions - تفاعلات عامة لصفحة البروفايل
// ============================================
app.get('/api/profile/:nickname/interactions', async (req, res) => {
    try {
        const decodedNickname = decodeURIComponent(req.params.nickname);
        
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${decodedNickname}$`, $options: 'i' } },
                { username: { $regex: `^${decodedNickname}$`, $options: 'i' } }
            ]
        }).select('_id profile.isPublic profile.nickname');
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        const isOwner = req.user && req.user.userId === user._id.toString();
        if (!user.profile.isPublic && !isOwner) {
            return res.status(403).json({ error: 'Interactions are private' });
        }
        
        // ✅ جلب جميع تعليقات المستخدم
        let comments = await Comment.find({ userId: user._id })
            .sort({ timestamp: -1 });
        
        if (!isOwner) {
            comments = comments.filter(c => c.visibility === 'public');
        }
        
        if (comments.length === 0) {
            return res.json([]);
        }
        
        // ✅ تجميع معرفات أصحاب المشاريع
        const projectOwnerIds = [...new Set(comments.map(c => c.projectOwnerId?.toString()).filter(Boolean))];
        
        // ✅ جلب بيانات أصحاب المشاريع
        const projectOwners = await User.find({ _id: { $in: projectOwnerIds } })
            .select('_id profile.nickname profile.projects')
            .lean();
        
        // ✅ إنشاء Map لربط projectId بمعلومات المشروع
        const projectsInfoMap = new Map();
        
        for (const owner of projectOwners) {
            let ownerProjects = [];
            if (owner.profile?.projects) {
                if (Array.isArray(owner.profile.projects)) {
                    ownerProjects = owner.profile.projects;
                } else if (typeof owner.profile.projects === 'object') {
                    ownerProjects = Object.values(owner.profile.projects);
                }
            }
            
            for (const project of ownerProjects) {
                if (project._id) {
                    projectsInfoMap.set(project._id.toString(), {
                        title: project.title || 'Unknown Project',
                        image: project.image || null,
                        ownerNickname: owner.profile?.nickname || owner.username
                    });
                }
            }
        }
        
        // ✅ تجهيز الرد
        const enrichedComments = comments.map(comment => {
            const projectInfo = projectsInfoMap.get(comment.projectId?.toString());
            
            return {
                _id: comment._id,
                commentId: comment._id,
                projectId: comment.projectId,
                projectTitle: projectInfo?.title || 'Unknown Project',
                projectNickname: projectInfo?.ownerNickname || decodedNickname,
                projectImage: projectInfo?.image || null,
                rating: comment.rating,
                text: comment.text,
                timestamp: comment.timestamp,
                replies: comment.replies || [],
                likes: comment.likes || [],
                visibility: comment.visibility || 'public'
            };
        });
        
        res.json(enrichedComments);
        
    } catch (error) {
        logger.error(`Error fetching public interactions: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch interactions' });
    }
});

// ============================================
// GET /api/user/interactions/privacy - جلب إعدادات الخصوصية
// ============================================
app.get('/api/user/interactions/privacy', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId).select('interactionsSettings');
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        res.json(user.interactionsSettings || {
            showToPublic: true,
            showToLoggedIn: true,
            showOnlyToOwner: false,
            showToSpecificUsers: [],
            hideProjects: [],
            hideComments: []
        });
    } catch (error) {
        logger.error(`Error fetching privacy settings: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch privacy settings' });
    }
});

// ============================================
// PUT /api/user/interactions/privacy - حفظ إعدادات الخصوصية
// ============================================
app.put('/api/user/interactions/privacy', authenticateToken, async (req, res) => {
    try {
        const { showToPublic, showToLoggedIn, showOnlyToOwner, showToSpecificUsers, hideProjects, hideComments } = req.body;
        
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        user.interactionsSettings = {
            showToPublic: showToPublic !== undefined ? showToPublic : true,
            showToLoggedIn: showToLoggedIn !== undefined ? showToLoggedIn : true,
            showOnlyToOwner: showOnlyToOwner !== undefined ? showOnlyToOwner : false,
            showToSpecificUsers: showToSpecificUsers || [],
            hideProjects: hideProjects || [],
            hideComments: hideComments || []
        };
        
        await user.save();
        
        res.json({ success: true, message: 'Privacy settings updated', settings: user.interactionsSettings });
    } catch (error) {
        logger.error(`Error saving privacy settings: ${error.message}`);
        res.status(500).json({ error: 'Failed to save privacy settings' });
    }
});

// للسماح للمستخدم العادي 

app.post('/api/user/skills', authenticateToken, [
    body('name').notEmpty().withMessage('Skill name is required'),
    body('proficiency').isInt({ min: 1, max: 100 }).withMessage('Proficiency must be between 1 and 100')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    const { name, proficiency } = req.body;
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }
        user.skills = user.skills || [];
        user.skills.push({ name, proficiency });
        await user.save();
        logger.info(`Skill ${name} added to user ${req.user.userId}`);
        res.status(201).json({ success: true, data: user.skills });
    } catch (error) {
        logger.error(`Error adding skill for user ${req.user.userId}: ${error.message}`);
        Sentry.captureException(error, { user: { id: req.user.userId, email: req.user.email } });
        res.status(400).json({ success: false, error: 'Failed to add skill: ' + error.message });
    }
});



app.post('/api/users', authenticateToken, isAdmin, [
    body('username').notEmpty().withMessage('Username is required'),
    body('email').isEmail().withMessage('Valid email is required'),
    body('password').isLength({ min: 6 }).withMessage('Password must be at least 6 characters'),
    body('role').isIn(['User', 'Admin']).withMessage('Role must be either User or Admin')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    const { username, email, password, role } = req.body;
    try {
        const existingUser = await User.findOne({ $or: [{ username }, { email }] });
        if (existingUser) {
            return res.status(400).json({ success: false, error: 'Username or email already exists' });
        }
        const hashedPassword = await bcrypt.hash(password, 10);
        const user = new User({ username, email, password: hashedPassword, role });
        await user.save();
        res.status(201).json({ success: true, data: user });
    } catch (error) {
        logger.error(`Error creating user: ${error.message}`);
        Sentry.captureException(error);
        res.status(400).json({ success: false, error: 'Failed to create user: ' + error.message });
    }
});

app.get('/api/users', authenticateToken, isAdmin, async (req, res) => {
    try {
        const users = await User.find().select('username email profile role');
        res.json({ success: true, data: users });
    } catch (error) {
        logger.error(`Error fetching users: ${error.message}`);
        Sentry.captureException(error, { extra: { endpoint: '/api/users', method: 'GET' } });
        res.status(500).json({ success: false, error: 'Failed to fetch users: ' + error.message });
    }
});

app.delete('/api/users/:userId', authenticateToken, isAdmin, async (req, res) => {
    try {
        await User.findByIdAndDelete(req.params.userId);
        await Comment.deleteMany({ userId: req.params.userId });
        res.sendStatus(204);
    } catch (error) {
        logger.error(`Error deleting user ${req.params.userId}: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to delete user: ' + error.message });
    }
});


// ============================================
// GET /api/profile/resume/:nickname - جلب السيرة الذاتية (رابط أو PDF)
// ============================================
app.get('/api/profile/resume/:nickname', async (req, res) => {
    try {
        const decodedNickname = decodeURIComponent(req.params.nickname);
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': decodedNickname },
                { username: decodedNickname },
            ],
        });

        if (!user) {
            return res.status(404).json({ error: 'Profile not found' });
        }

        // التحقق من الخصوصية
        const isOwner = req.user && req.user.userId === user._id.toString();
                if (user.profile.isPublic === false && !isOwner) {
                    return res.status(403).json({ error: 'Profile is private' });
                }


        // ✅ إذا كان فيه رابط خارجي، ارجع الرابط
        if (user.profile.resumeUrl && user.profile.resumeUrl !== '') {
            return res.json({ 
                type: 'url', 
                url: user.profile.resumeUrl,
                message: 'External resume URL found'
            });
        }

        // ✅ إذا مفيش رابط، ارجع إشارة لتوليد PDF
        return res.json({ 
            type: 'generate',
            nickname: decodedNickname,
            message: 'Generate PDF from profile data'
        });

    } catch (error) {
        logger.error(`Error fetching resume: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch resume' });
    }
});

app.get('/api/profile/pdf/:nickname', async (req, res) => {
    try {
        const decodedNickname = decodeURIComponent(req.params.nickname);
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': decodedNickname },
                { username: decodedNickname },
            ],
        });

        if (!user) {
            logger.warn(`Profile not found for nickname: ${decodedNickname}`);
            return res.status(404).json({ error: `Profile not found for nickname: ${decodedNickname}` });
        }

        // ✅ التحقق من الخصوصية - دعم المستخدمين غير المسجلين
        const isOwner = req.user && req.user.userId === user._id.toString();
        if (!user.profile.isPublic && !isOwner) {
            logger.warn(`Unauthorized access attempt to private profile: ${decodedNickname}`);
            return res.status(403).json({ error: 'Profile is private', loginRequired: true });
        }

        const doc = new jsPDF();
        let yOffset = 20;

        // ========== HEADER ==========
        doc.setFontSize(20);
        doc.text(user.profile.nickname || user.username, 10, yOffset);
        yOffset += 10;
        
        doc.setFontSize(12);
        doc.text('Portfolio Resume', 10, yOffset);
        yOffset += 15;

        // ========== AVATAR (اختياري) ==========
        if (user.profile.avatar) {
            try {
                const imageResponse = await axios.get(user.profile.avatar, { responseType: 'arraybuffer' });
                const imageBase64 = Buffer.from(imageResponse.data).toString('base64');
                doc.addImage(imageBase64, 'PNG', 150, 10, 40, 40);
            } catch (imageError) {
                logger.error(`Failed to load avatar for PDF: ${imageError.message}`);
            }
        }

        // ========== PERSONAL INFO ==========
        doc.setFontSize(14);
        doc.text('Personal Information', 10, yOffset);
        yOffset += 8;
        doc.setFontSize(10);
        
        if (user.profile.jobTitle) {
            doc.text(`Job Title: ${user.profile.jobTitle}`, 10, yOffset);
            yOffset += 6;
        }
        if (user.profile.bio) {
            const bioLines = doc.splitTextToSize(user.profile.bio, 180);
            doc.text('Bio:', 10, yOffset);
            yOffset += 5;
            doc.text(bioLines, 15, yOffset);
            yOffset += bioLines.length * 5 + 5;
        }
        if (user.profile.phone) {
            doc.text(`Phone: ${user.profile.phone}`, 10, yOffset);
            yOffset += 6;
        }
        yOffset += 5;

        // ========== SOCIAL LINKS ==========
        if (user.profile.socialLinks && Object.values(user.profile.socialLinks).some(v => v)) {
            doc.setFontSize(14);
            doc.text('Social Links', 10, yOffset);
            yOffset += 8;
            doc.setFontSize(10);
            
            if (user.profile.socialLinks.linkedin) {
                doc.text(`LinkedIn: ${user.profile.socialLinks.linkedin.substring(0, 50)}...`, 10, yOffset);
                yOffset += 5;
            }
            if (user.profile.socialLinks.github) {
                doc.text(`GitHub: ${user.profile.socialLinks.github.substring(0, 50)}...`, 10, yOffset);
                yOffset += 5;
            }
            if (user.profile.socialLinks.whatsapp) {
                doc.text(`WhatsApp: ${user.profile.socialLinks.whatsapp}`, 10, yOffset);
                yOffset += 5;
            }
            yOffset += 5;
        }

        // ========== EDUCATION ==========
        if (user.profile.education && user.profile.education.length > 0) {
            doc.setFontSize(14);
            doc.text('Education', 10, yOffset);
            yOffset += 8;
            doc.setFontSize(10);
            
            const educationList = Array.isArray(user.profile.education) ? user.profile.education : Object.values(user.profile.education);
            educationList.forEach(edu => {
                const text = `• ${edu.institution || ''} - ${edu.degree || ''} (${edu.year || ''})`;
                const lines = doc.splitTextToSize(text, 180);
                doc.text(lines, 10, yOffset);
                yOffset += lines.length * 5 + 2;
            });
            yOffset += 5;
        } else {
            doc.setFontSize(10);
            doc.text('No education added yet.', 10, yOffset);
            yOffset += 10;
        }

        // ========== EXPERIENCE ==========
        if (user.profile.experience && user.profile.experience.length > 0) {
            doc.setFontSize(14);
            doc.text('Experience', 10, yOffset);
            yOffset += 8;
            doc.setFontSize(10);
            
            const experienceList = Array.isArray(user.profile.experience) ? user.profile.experience : Object.values(user.profile.experience);
            experienceList.forEach(exp => {
                const text = `• ${exp.company || ''} - ${exp.role || ''} (${exp.duration || ''})`;
                const lines = doc.splitTextToSize(text, 180);
                doc.text(lines, 10, yOffset);
                yOffset += lines.length * 5 + 2;
            });
            yOffset += 5;
        } else {
            doc.setFontSize(10);
            doc.text('No experience added yet.', 10, yOffset);
            yOffset += 10;
        }

        // ========== CERTIFICATES ==========
        if (user.profile.certificates && user.profile.certificates.length > 0) {
            doc.setFontSize(14);
            doc.text('Certificates', 10, yOffset);
            yOffset += 8;
            doc.setFontSize(10);
            
            const certificatesList = Array.isArray(user.profile.certificates) ? user.profile.certificates : Object.values(user.profile.certificates);
            certificatesList.forEach(cert => {
                const text = `• ${cert.name || ''} - ${cert.issuer || ''} (${cert.year || ''})`;
                const lines = doc.splitTextToSize(text, 180);
                doc.text(lines, 10, yOffset);
                yOffset += lines.length * 5 + 2;
            });
            yOffset += 5;
        }

        // ========== SKILLS ==========
        if (user.profile.skills && user.profile.skills.length > 0) {
            doc.setFontSize(14);
            doc.text('Skills', 10, yOffset);
            yOffset += 8;
            doc.setFontSize(10);
            
            const skillsList = Array.isArray(user.profile.skills) ? user.profile.skills : Object.values(user.profile.skills);
            // عرض المهارات في عمودين
            const midPoint = Math.ceil(skillsList.length / 2);
            const leftCol = skillsList.slice(0, midPoint);
            const rightCol = skillsList.slice(midPoint);
            
            let rightOffset = 100;
            let leftYOffset = yOffset;
            let rightYOffset = yOffset;
            
            leftCol.forEach(skill => {
                doc.text(`• ${skill.name || ''}: ${skill.percentage || 0}%`, 10, leftYOffset);
                leftYOffset += 5;
            });
            
            rightCol.forEach(skill => {
                doc.text(`• ${skill.name || ''}: ${skill.percentage || 0}%`, rightOffset, rightYOffset);
                rightYOffset += 5;
            });
            
            yOffset = Math.max(leftYOffset, rightYOffset) + 5;
        } else {
            doc.setFontSize(10);
            doc.text('No skills added yet.', 10, yOffset);
            yOffset += 10;
        }

        // ========== PROJECTS ==========
        if (user.profile.projects && user.profile.projects.length > 0) {
            doc.setFontSize(14);
            doc.text('Projects', 10, yOffset);
            yOffset += 8;
            doc.setFontSize(10);
            
            const projectsList = Array.isArray(user.profile.projects) ? user.profile.projects : Object.values(user.profile.projects);
            projectsList.slice(0, 10).forEach(project => {
                doc.setFontSize(11);
                doc.text(`• ${project.title || ''}`, 10, yOffset);
                yOffset += 5;
                if (project.description) {
                    doc.setFontSize(9);
                    const descLines = doc.splitTextToSize(project.description, 170);
                    doc.text(descLines, 15, yOffset);
                    yOffset += descLines.length * 4 + 3;
                }
                doc.setFontSize(10);
            });
            yOffset += 5;
        } else {
            doc.setFontSize(10);
            doc.text('No projects added yet.', 10, yOffset);
            yOffset += 10;
        }

        // ========== INTERESTS ==========
        if (user.profile.interests && user.profile.interests.length > 0) {
            doc.setFontSize(14);
            doc.text('Interests', 10, yOffset);
            yOffset += 8;
            doc.setFontSize(10);
            
            const interestsList = Array.isArray(user.profile.interests) ? user.profile.interests : Object.values(user.profile.interests);
            const interestsText = interestsList.join(', ');
            const interestsLines = doc.splitTextToSize(interestsText, 180);
            doc.text(interestsLines, 10, yOffset);
            yOffset += interestsLines.length * 5 + 5;
        }

        // ========== FOOTER ==========
        doc.setFontSize(8);
        doc.text(`Generated on ${new Date().toLocaleDateString()}`, 10, doc.internal.pageSize.height - 10);

        // ========== إرسال الملف ==========
        res.setHeader('Content-Type', 'application/pdf');
        res.setHeader('Content-Disposition', `attachment; filename=${(user.profile.nickname || user.username).replace(/[^a-zA-Z0-9]/g, '_')}_resume.pdf`);
        res.send(doc.output());

    } catch (error) {
        logger.error(`Error generating PDF for ${req.params.nickname}: ${error.message}`);
        res.status(500).json({ error: `Failed to generate PDF: ${error.message}` });
    }
});

app.delete('/api/delete-account', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.id;
        await User.deleteOne({ _id: userId }); // حذف المستخدم
        await Profile.deleteOne({ userId }); // حذف الملف الشخصي
        res.status(200).json({ message: 'Account deleted successfully' });
    } catch (error) {
        res.status(500).json({ error: 'Failed to delete account' });
    }
});



app.get('/api/profile/docx/:nickname', authenticateToken, async (req, res) => {
    try {
        const decodedNickname = decodeURIComponent(req.params.nickname);
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': decodedNickname },
                { username: decodedNickname },
            ],
        });

        if (!user) {
            logger.warn(`Profile not found for nickname: ${decodedNickname}`);
            return res.status(404).json({ error: `Profile not found for nickname: ${decodedNickname}` });
        }

        if (!user.profile.isPublic && (!req.user || req.user.userId !== user._id.toString())) {
            logger.warn(`Unauthorized access attempt to private profile: ${decodedNickname} by user: ${req.user?.userId || 'anonymous'}`);
            return res.status(403).json({ error: 'Profile is private', loginRequired: true });
        }

        const doc = new Document({
            sections: [{
                properties: {},
                children: [
                    new Paragraph({
                        children: [
                            new TextRun({
                                text: user.profile.nickname || user.username,
                                bold: true,
                                size: 40,
                            }),
                        ],
                    }),
                    new Paragraph({
                        children: [
                            new TextRun({
                                text: user.profile.jobTitle || 'Not specified',
                                size: 28,
                            }),
                        ],
                    }),
                    new Paragraph({ text: '' }), // Spacer
                    user.profile.bio ? new Paragraph({
                        children: [new TextRun({ text: 'Bio:', bold: true, size: 24 })],
                    }) : null,
                    user.profile.bio ? new Paragraph({
                        children: [new TextRun({ text: user.profile.bio, size: 20 })],
                    }) : null,
                    new Paragraph({ text: '' }),
                    new Paragraph({
                        children: [new TextRun({ text: 'Contact:', bold: true, size: 24 })],
                    }),
                    user.profile.phone ? new Paragraph({
                        children: [new TextRun({ text: `Phone: ${user.profile.phone}`, size: 20 })],
                    }) : null,
                    ...Object.keys(user.profile.socialLinks).map(key => user.profile.socialLinks[key] ? new Paragraph({
                        children: [new TextRun({ text: `${key}: ${user.profile.socialLinks[key]}`, size: 20 })],
                    }) : null),
                    new Paragraph({ text: '' }),
                    // Education
                    user.profile.education.length > 0 ? new Paragraph({
                        children: [new TextRun({ text: 'Education:', bold: true, size: 24 })],
                    }) : null,
                    user.profile.education.length > 0 ? new Table({
                        width: { size: 100, type: WidthType.PERCENTAGE },
                        rows: [
                            new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph('Institution')], margins: { top: 100, bottom: 100 } }),
                                    new TableCell({ children: [new Paragraph('Degree')], margins: { top: 100, bottom: 100 } }),
                                    new TableCell({ children: [new Paragraph('Year')], margins: { top: 100, bottom: 100 } }),
                                ],
                            }),
                            ...user.profile.education.slice(0, 50).map(edu => new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph(edu.institution || 'Not specified')] }),
                                    new TableCell({ children: [new Paragraph(edu.degree || 'Not specified')] }),
                                    new TableCell({ children: [new Paragraph(edu.year || 'Not specified')] }),
                                ],
                            })),
                        ],
                    }) : null,
                    // Experience
                    user.profile.experience.length > 0 ? new Paragraph({
                        children: [new TextRun({ text: 'Experience:', bold: true, size: 24 })],
                    }) : null,
                    user.profile.experience.length > 0 ? new Table({
                        width: { size: 100, type: WidthType.PERCENTAGE },
                        rows: [
                            new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph('Role')], margins: { top: 100, bottom: 100 } }),
                                    new TableCell({ children: [new Paragraph('Company')], margins: { top: 100, bottom: 100 } }),
                                    new TableCell({ children: [new Paragraph('Duration')], margins: { top: 100, bottom: 100 } }),
                                ],
                            }),
                            ...user.profile.experience.slice(0, 50).map(exp => new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph(exp.role || 'Not specified')] }),
                                    new TableCell({ children: [new Paragraph(exp.company || 'Not specified')] }),
                                    new TableCell({ children: [new Paragraph(exp.duration || 'Not specified')] }),
                                ],
                            })),
                        ],
                    }) : null,
                    // Certificates
                    user.profile.certificates.length > 0 ? new Paragraph({
                        children: [new TextRun({ text: 'Certificates:', bold: true, size: 24 })],
                    }) : null,
                    user.profile.certificates.length > 0 ? new Table({
                        width: { size: 100, type: WidthType.PERCENTAGE },
                        rows: [
                            new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph('Name')], margins: { top: 100, bottom: 100 } }),
                                    new TableCell({ children: [new Paragraph('Issuer')], margins: { top: 100, bottom: 100 } }),
                                    new TableCell({ children: [new Paragraph('Year')], margins: { top: 100, bottom: 100 } }),
                                ],
                            }),
                            ...user.profile.certificates.slice(0, 50).map(cert => new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph(cert.name || 'Not specified')] }),
                                    new TableCell({ children: [new Paragraph(cert.issuer || 'Not specified')] }),
                                    new TableCell({ children: [new Paragraph(cert.year || 'Not specified')] }),
                                ],
                            })),
                        ],
                    }) : null,
                    // Skills
                    user.profile.skills.length > 0 ? new Paragraph({
                        children: [new TextRun({ text: 'Skills:', bold: true, size: 24 })],
                    }) : null,
                    user.profile.skills.length > 0 ? new Table({
                        width: { size: 100, type: WidthType.PERCENTAGE },
                        rows: [
                            new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph('Skill')], margins: { top: 100, bottom: 100 } }),
                                    new TableCell({ children: [new Paragraph('Proficiency')], margins: { top: 100, bottom: 100 } }),
                                ],
                            }),
                            ...user.profile.skills.slice(0, 50).map(skill => new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph(skill.name || 'Not specified')] }),
                                    new TableCell({ children: [new Paragraph(`${skill.percentage}%` || '0%')] }),
                                ],
                            })),
                        ],
                    }) : null,
                    // Projects
                    user.profile.projects.length > 0 ? new Paragraph({
                        children: [new TextRun({ text: 'Projects:', bold: true, size: 24 })],
                    }) : null,
                    user.profile.projects.length > 0 ? new Table({
                        width: { size: 100, type: WidthType.PERCENTAGE },
                        rows: [
                            new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph('Title')], margins: { top: 100, bottom: 100 } }),
                                    new TableCell({ children: [new Paragraph('Description')], margins: { top: 100, bottom: 100 } }),
                                    new TableCell({ children: [new Paragraph('Links')], margins: { top: 100, bottom: 100 } }),
                                ],
                            }),
                            ...user.profile.projects.slice(0, 50).map(proj => new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph(proj.title || 'Not specified')] }),
                                    new TableCell({ children: [new Paragraph(proj.description || 'Not specified')] }),
                                    new TableCell({ children: [new Paragraph(proj.links?.map(link => `${link.option}: ${link.value}`).join(', ') || 'Not specified')] }),
                                ],
                            })),
                        ],
                    }) : null,
                    // Interests
                    user.profile.interests.length > 0 ? new Paragraph({
                        children: [new TextRun({ text: 'Interests:', bold: true, size: 24 })],
                    }) : null,
                    user.profile.interests.length > 0 ? new Table({
                        width: { size: 100, type: WidthType.PERCENTAGE },
                        rows: [
                            new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph('Interests')], margins: { top: 100, bottom: 100 } }),
                                ],
                            }),
                            ...user.profile.interests.slice(0, 50).map(interest => new TableRow({
                                children: [
                                    new TableCell({ children: [new Paragraph(interest || 'Not specified')] }),
                                ],
                            })),
                        ],
                    }) : null,
                ].filter(Boolean),
            }],
        });

        const buffer = await Packer.toBuffer(doc);

        // Track CV download in Google Analytics
        try {
            await axios.post('https://www.google-analytics.com/mp/collect', {
                measurement_id: process.env.GOOGLE_ANALYTICS_ID,
                api_secret: process.env.GOOGLE_ANALYTICS_API_SECRET,
                events: [{
                    name: 'download_cv_docx',
                    params: {
                        nickname: decodedNickname,
                        userId: req.user?.userId || 'anonymous',
                        timestamp: new Date().toISOString(),
                    },
                }],
            }, {
                headers: { 'Content-Type': 'application/json' },
                timeout: 5000,
            });
            logger.info(`DOCX CV download tracked for ${decodedNickname}`);
        } catch (analyticsError) {
            logger.error(`Failed to track DOCX CV download: ${analyticsError.message}`);
            Sentry.captureException(analyticsError);
        }

        res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
        res.setHeader('Content-Disposition', `attachment; filename=${(user.profile.nickname || user.username).replace(/[^a-zA-Z0-9]/g, '_')}_resume.docx`);
        res.send(buffer);
    } catch (error) {
        logger.error(`Error generating DOCX for ${req.params.nickname}: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to generate DOCX: ' + error.message });
    }
});

// ============================================
// POST /api/notifications - إرسال إشعار لمستخدم
// ============================================
app.post('/api/notifications', authenticateToken, [
    body('userId').isMongoId().withMessage('Valid user ID required'),
    body('type').isString(),
    body('content').isString(),
    body('link').optional().isString()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const { userId, type, content, link } = req.body;
        
        const notification = new Notification({
            userId,
            type: type || 'system',
            actorId: req.user.userId,
            actorName: req.user.username,
            content,
            link: link || '',
            read: false,
            createdAt: new Date()
        });
        
        await notification.save();
        
        // Also add to user's notifications array for backward compatibility
        await User.findByIdAndUpdate(userId, {
            $push: {
                notifications: {
                    message: content,
                    type: 'info',
                    link: link || '',
                    read: false,
                    createdAt: new Date()
                }
            }
        });
        
        res.status(201).json({ success: true, data: notification });
        
    } catch (error) {
        logger.error(`Error sending notification: ${error.message}`);
        res.status(500).json({ error: 'Failed to send notification' });
    }
});

// ============================================
// POST /api/notifications/:id/read - تعليم الإشعار كمقروء
// ============================================
app.post('/api/notifications/:id/read', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }

        const notificationId = req.params.id;
        const notification = user.notifications.id(notificationId);

        if (!notification) {
            return res.status(404).json({ success: false, error: 'Notification not found' });
        }

        notification.read = true;
        await user.save();

        res.json({ success: true, message: 'Notification marked as read' });
    } catch (error) {
        logger.error(`Error marking notification as read: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to mark notification as read' });
    }
});

// ============================================
// DELETE /api/notifications/:id - حذف إشعار
// ============================================
app.delete('/api/notifications/:id', authenticateToken, async (req, res) => {
    try {
        const { id } = req.params;
        
        // ✅ 1. حاول الحذف من Notification model
        const advancedResult = await Notification.deleteOne({ _id: id, userId: req.user.userId });
        
        if (advancedResult.deletedCount > 0) {
            return res.json({ success: true, source: 'advanced' });
        }
        
        // ✅ 2. إذا لم يوجد، حاول الحذف من User.notifications
        const user = await User.findById(req.user.userId);
        if (user && user.notifications) {
            const initialLength = user.notifications.length;
            user.notifications = user.notifications.filter(n => n._id.toString() !== id);
            
            if (user.notifications.length !== initialLength) {
                await user.save();
                return res.json({ success: true, source: 'user' });
            }
        }
        
        return res.status(404).json({ error: 'Notification not found' });
        
    } catch (error) {
        logger.error(`Error deleting notification: ${error.message}`);
        res.status(500).json({ error: 'Failed to delete notification' });
    }
});



// ============================================
// GET /api/educations - جلب التعليم
// ============================================
app.get('/api/educations', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }

        res.json({ success: true, data: user.profile.education || [] });
    } catch (error) {
        logger.error(`Error fetching education: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to fetch education' });
    }
});

// ============================================
// POST /api/educations - إضافة تعليم جديد
// ============================================
app.post('/api/educations', authenticateToken, [
    body('degree').notEmpty().withMessage('Degree is required'),
    body('institution').notEmpty().withMessage('Institution is required'),
    body('startYear').isInt({ min: 1900, max: new Date().getFullYear() }).withMessage('Invalid start year'),
    body('endYear').isInt({ min: 1900, max: new Date().getFullYear() + 5 }).withMessage('Invalid end year'),
    body('description').optional()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }

    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }

        if (!user.profile.education) {
            user.profile.education = [];
        }

        user.profile.education.push(req.body);
        await user.save();

        res.status(201).json({ success: true, data: user.profile.education });
    } catch (error) {
        logger.error(`Error adding education: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to add education' });
    }
});

// ============================================
// PUT /api/educations/:id - تحديث تعليم
// ============================================
app.put('/api/educations/:id', authenticateToken, [
    body('degree').optional().notEmpty(),
    body('institution').optional().notEmpty(),
    body('startYear').optional().isInt({ min: 1900, max: new Date().getFullYear() }),
    body('endYear').optional().isInt({ min: 1900, max: new Date().getFullYear() + 5 }),
    body('description').optional()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }

    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }

        const educationIndex = user.profile.education.findIndex(
            e => e._id.toString() === req.params.id
        );

        if (educationIndex === -1) {
            return res.status(404).json({ success: false, error: 'Education not found' });
        }

        user.profile.education[educationIndex] = {
            ...user.profile.education[educationIndex].toObject(),
            ...req.body
        };

        await user.save();
        res.json({ success: true, data: user.profile.education });
    } catch (error) {
        logger.error(`Error updating education: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to update education' });
    }
});

// ============================================
// DELETE /api/educations/:id - حذف تعليم
// ============================================
app.delete('/api/educations/:id', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }

        user.profile.education = user.profile.education.filter(
            e => e._id.toString() !== req.params.id
        );

        await user.save();
        res.json({ success: true, message: 'Education deleted' });
    } catch (error) {
        logger.error(`Error deleting education: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to delete education' });
    }
});


// ============================================
// GET /api/profile/contact - جلب معلومات الاتصال
// ============================================
app.get('/api/profile/contact', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }

        res.json({
            success: true,
            data: {
                phone: user.profile.phone || '',
                socialLinks: user.profile.socialLinks || {}
            }
        });
    } catch (error) {
        logger.error(`Error fetching contact info: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to fetch contact info' });
    }
});

// ============================================
// PUT /api/profile/contact - تحديث معلومات الاتصال
// ============================================
app.put('/api/profile/contact', authenticateToken, [
    body('phone').optional().isMobilePhone().withMessage('Invalid phone number'),
    body('socialLinks').optional().isObject().withMessage('Social links must be an object')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }

    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }

        if (req.body.phone !== undefined) {
            user.profile.phone = req.body.phone;
        }

        if (req.body.socialLinks) {
            user.profile.socialLinks = {
                ...user.profile.socialLinks,
                ...req.body.socialLinks
            };
        }

        await user.save();

        res.json({
            success: true,
            data: {
                phone: user.profile.phone,
                socialLinks: user.profile.socialLinks
            }
        });
    } catch (error) {
        logger.error(`Error updating contact info: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to update contact info' });
    }
});


app.post('/api/forgot-password', async (req, res) => {
    const { email } = req.body;
    try {
        if (!email) {
            return res.status(400).json({ error: 'Email is required' });
        }
        const user = await User.findOne({ email });
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        const otp = Math.floor(100000 + Math.random() * 900000).toString();
        user.otp = otp;
        user.otpExpires = Date.now() + 10 * 60 * 1000;
        await user.save();
        try {
            await transporter.sendMail({
                from: process.env.EMAIL_USER,
                to: email,
                subject: 'Password Reset OTP',
                text: `Your OTP code for password reset is ${otp}. It is valid for 10 minutes.`
            });
            logger.info(`Password reset OTP sent to ${email}: ${otp}`);
            res.json({ message: 'Reset code sent to your email' });
        } catch (mailError) {
            logger.error(`Failed to send password reset OTP to ${email}: ${mailError.message}`);
            return res.status(500).json({ error: 'Failed to send reset code' });
        }
    } catch (error) {
        logger.error(`Forgot password error for ${email}: ${error.message}`);
        res.status(500).json({ error: 'Failed to process forgot password request' });
    }
});

app.post('/api/reset-password', [
    body('email').isEmail().withMessage('Invalid email format'),
    body('otp').notEmpty().withMessage('OTP is required'),
    body('newPassword').isLength({ min: 8 }).withMessage('New password must be at least 8 characters long')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    const { email, otp, newPassword } = req.body;
    try {
        const user = await User.findOne({ email, otp, otpExpires: { $gt: Date.now() } });
        if (!user) {
            return res.status(400).json({ error: 'Invalid or expired OTP' });
        }
        user.password = await bcrypt.hash(newPassword, 10);
        user.otp = null;
        user.otpExpires = null;
        await user.save();
        logger.info(`Password reset successfully for ${email}`);
        res.json({ message: 'Password reset successfully' });
    } catch (error) {
        logger.error(`Reset password error for ${email}: ${error.message}`);
        res.status(500).json({ error: 'Failed to reset password' });
    }
});

app.get('/api/health', async (req, res) => {
    try {
        if (mongoose.connection.readyState !== 1) {
            throw new Error('MongoDB is not connected');
        }
        await mongoose.connection.db.admin().ping();
        const services = {
            status: 'ok',
            mongodb: 'connected',
            cloudinary: cloudinary.config().cloud_name ? 'configured' : 'not configured',
            sentry: process.env.SENTRY_DSN ? 'configured' : 'not configured',
            timestamp: new Date()
        };
        res.json(services);
    } catch (error) {
        logger.error(`Health check error: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Server error', details: error.message });
    }
});


app.post('/api/subscribe', authenticateToken, async (req, res) => {
    try {
        const subscription = req.body;
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        user.notifications.push(subscription);
        await user.save();
        res.status(201).json({ message: 'Subscription saved' });
    } catch (error) {
        logger.error(`Error saving subscription: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to save subscription' });
    }
});

app.post('/api/ask', [
    body('question').notEmpty().withMessage('Question is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    const { question } = req.body;
    try {
        const context = await generateAIContext(`Question: ${question}`);
        const response = await axios.post(
            `${AI_API_URL}/api/ask`,
            { question: context },
            { headers: { 'Content-Type': 'application/json' } }
        );
        res.json({ answer: response.data.answer || 'Sorry, I could not generate an answer.' });
    } catch (error) {
        logger.error('Error processing question:', error.message);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to process question: ' + error.message });
    }
});

app.post('/api/chat', [
    body('message').notEmpty().withMessage('Message is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    const { message } = req.body;
    try {
        const context = await generateAIContext(`User message: ${message}`);
        const response = await axios.post(
            `${AI_API_URL}/api/ask`,
            { question: context },
            { headers: { 'Content-Type': 'application/json' } }
        );
        res.json({ reply: response.data.answer || 'Sorry, I could not generate a response.' });
    } catch (error) {
        logger.error('Error processing chat:', error.message);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Something went wrong' });
    }
});

const registerLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 5,
    message: 'Too many registration attempts, please try again later.',
    validate: { trustProxy: false }
});
app.use('/api/register', registerLimiter);

const commentLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 10,
    message: 'Too many comment attempts, please try again later.',
    validate: { trustProxy: false }
});
app.use('/api/comments', commentLimiter);

const converseLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 20,
    message: 'Too many chat attempts, please try again later.',
    validate: { trustProxy: false }
});
app.use('/api/converse', converseLimiter);

app.post('/api/converse', authenticateToken, [
    body('messages').isArray({ min: 1 }).withMessage('Messages must be a non-empty array'),
    body('messages.*.role').isIn(['user', 'assistant']).withMessage('Message role must be either user or assistant'),
    body('messages.*.content').notEmpty().withMessage('Message content is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    const { messages } = req.body;
    try {
        const MAX_CONVERSATIONS_PER_USER = 100;
        const conversationCount = await Conversation.countDocuments({ userId: req.user.userId });
        if (conversationCount >= MAX_CONVERSATIONS_PER_USER) {
            await Conversation.findOneAndDelete(
                { userId: req.user.userId },
                { sort: { 'messages.timestamp': 1 } }
            );
        }
        const conversation = messages.map(msg => `${msg.role}: ${msg.content}`).join('\n');
        const context = await generateAIContext(`Conversation:\n${conversation}\nRespond to the last user message in the conversation.`);
        const response = await axios.post(
            `${AI_API_URL}/api/ask`,
            { question: context },
            { headers: { 'Content-Type': 'application/json' } }
        );
        await Conversation.create({
            userId: req.user.userId,
            messages: messages.concat({ role: 'assistant', content: response.data.answer })
        });
        res.json({ response: response.data.answer || 'Sorry, I could not generate a response.' });
    } catch (error) {
        logger.error('Error processing conversation:', error.message);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to process conversation: ' + error.message });
    }
});

app.get('/api/conversations/export', authenticateToken, isAdmin, async (req, res) => {
    try {
        const conversations = await Conversation.find();
        const csvData = conversations.map(conv =>
            conv.messages.map(msg => `"${msg.role}: ${msg.content.replace(/"/g, '""')}"`).join(',')
        ).join('\n');
        res.header('Content-Type', 'text/csv');
        res.attachment('conversations.csv');
        res.send(csvData);
    } catch (error) {
        logger.error(`Error exporting conversations: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ error: 'Failed to export conversations: ' + error.message });
    }
});


//MARK_AI

app.get('/api/github-projects', async (req, res) => {
    try {
        const response = await axios.get('https://api.github.com/users/Mark-Lasfar/repos', {
            headers: { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` }
        });
        res.json(response.data);
    } catch (error) {
        res.status(500).json({ error: 'Failed to fetch GitHub projects' });
    }
});


// ---------------------------
// ============================================
// قائمة المهارات الشاملة
// ============================================

const SKILLS_DATABASE = {
    // 🌐 Frontend
    'html': 'HTML5', 'html5': 'HTML5', 'css': 'CSS3', 'css3': 'CSS3',
    'sass': 'Sass', 'scss': 'SCSS', 'less': 'Less', 'tailwind': 'Tailwind CSS',
    'bootstrap': 'Bootstrap', 'javascript': 'JavaScript', 'js': 'JavaScript',
    'ecmascript': 'JavaScript', 'es6': 'JavaScript (ES6)', 'typescript': 'TypeScript',
    'ts': 'TypeScript', 'react': 'React.js', 'reactjs': 'React.js', 'next': 'Next.js',
    'nextjs': 'Next.js', 'vue': 'Vue.js', 'vuejs': 'Vue.js', 'nuxt': 'Nuxt.js',
    'angular': 'Angular', 'angularjs': 'AngularJS', 'svelte': 'Svelte',
    'jquery': 'jQuery', 'webpack': 'Webpack', 'vite': 'Vite', 'babel': 'Babel',
    
    // 📱 Mobile
    'react native': 'React Native', 'reactnative': 'React Native', 'flutter': 'Flutter',
    'dart': 'Dart', 'swift': 'Swift', 'ios': 'iOS Development', 'kotlin': 'Kotlin',
    'android': 'Android Development', 'java': 'Java', 'xamarin': 'Xamarin',
    'ionic': 'Ionic', 'capacitor': 'Capacitor', 'cordova': 'Cordova',
    
    // ⚙️ Backend
    'node': 'Node.js', 'nodejs': 'Node.js', 'express': 'Express.js',
    'nestjs': 'NestJS', 'python': 'Python', 'django': 'Django', 'flask': 'Flask',
    'fastapi': 'FastAPI', 'php': 'PHP', 'laravel': 'Laravel', 'symfony': 'Symfony',
    'codeigniter': 'CodeIgniter', 'c#': 'C#', 'csharp': 'C#', 'dotnet': '.NET',
    'asp.net': 'ASP.NET', 'go': 'Go', 'golang': 'Go', 'rust': 'Rust',
    'ruby': 'Ruby', 'rails': 'Ruby on Rails', 'spring': 'Spring Boot', 'springboot': 'Spring Boot',
    
    // 🗄️ Databases
    'mongodb': 'MongoDB', 'mongo': 'MongoDB', 'mysql': 'MySQL',
    'postgresql': 'PostgreSQL', 'postgres': 'PostgreSQL', 'sqlite': 'SQLite',
    'oracle': 'Oracle Database', 'mssql': 'MS SQL Server', 'firebase': 'Firebase',
    'redis': 'Redis', 'elasticsearch': 'Elasticsearch', 'dynamodb': 'DynamoDB',
    
    // ☁️ Cloud & DevOps
    'aws': 'AWS', 'amazon web services': 'AWS', 'azure': 'Microsoft Azure',
    'gcp': 'Google Cloud', 'docker': 'Docker', 'kubernetes': 'Kubernetes', 'k8s': 'Kubernetes',
    'jenkins': 'Jenkins', 'terraform': 'Terraform', 'ansible': 'Ansible',
    
    // 🛠️ Tools
    'git': 'Git', 'github': 'GitHub', 'gitlab': 'GitLab', 'bitbucket': 'Bitbucket',
    'jira': 'Jira', 'trello': 'Trello', 'postman': 'Postman', 'figma': 'Figma',
    'photoshop': 'Photoshop', 'illustrator': 'Illustrator',
    
    // 📊 Data Science
    'machine learning': 'Machine Learning', 'ml': 'Machine Learning',
    'deep learning': 'Deep Learning', 'ai': 'Artificial Intelligence',
    'tensorflow': 'TensorFlow', 'pytorch': 'PyTorch', 'pandas': 'Pandas',
    'numpy': 'NumPy', 'data analysis': 'Data Analysis',
    
    // 🎨 Soft Skills
    'leadership': 'Leadership', 'project management': 'Project Management',
    'agile': 'Agile', 'scrum': 'Scrum', 'communication': 'Communication',
    'problem solving': 'Problem Solving', 'teamwork': 'Teamwork',
    'time management': 'Time Management',
    
    // 🎯 Additional
    'rest api': 'REST API', 'graphql': 'GraphQL', 'microservices': 'Microservices',
    'serverless': 'Serverless', 'seo': 'SEO', 'testing': 'Software Testing',
    'jest': 'Jest', 'cypress': 'Cypress',
    
    // 🌍 Languages
    'arabic': 'Arabic', 'english': 'English', 'french': 'French', 'german': 'German', 'spanish': 'Spanish',
};

// ============================================
// دوال استخراج البيانات الأساسية
// ============================================

function extractEmail(text) {
    const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
    const emails = text.match(emailRegex);
    return emails && emails.length > 0 ? emails[0] : '';
}

function extractPhone(text) {
    const phoneRegex = /(\+20|0)[1-9][0-9]{8,9}/g;
    const phones = text.match(phoneRegex);
    return phones && phones.length > 0 ? phones[0] : '';
}

function extractName(text) {
    const lines = text.split('\n');
    for (const line of lines) {
        const trimmed = line.trim();
        if (trimmed.length > 3 && trimmed.length < 50 && !trimmed.includes('@') && !trimmed.match(/\d/)) {
            return trimmed;
        }
    }
    return '';
}

function extractBio(text) {
    const lines = text.split('\n');
    for (const line of lines) {
        const trimmed = line.trim();
        if (trimmed.length > 30 && trimmed.length < 200 && !trimmed.includes('@') && !trimmed.match(/\d{10,}/)) {
            return trimmed;
        }
    }
    return text.length > 0 ? text.substring(0, 300).replace(/\n/g, ' ') : '';
}

// ============================================
// استخراج المسمى الوظيفي (نسخة واحدة موحدة)
// ============================================
function extractJobTitle(text) {
    const lines = text.split('\n');
    // قائمة موسعة بالمسميات الوظيفية
    const jobTitlesList = [
        // English
        'developer', 'engineer', 'architect', 'designer', 'analyst', 'manager', 
        'consultant', 'specialist', 'administrator', 'coordinator', 'director',
        'lead', 'senior', 'junior', 'full stack', 'frontend', 'front-end',
        'backend', 'back-end', 'devops', 'data scientist', 'data engineer',
        'product manager', 'project manager', 'software engineer', 'web developer',
        'mobile developer', 'ios developer', 'android developer', 'qa engineer',
        'system administrator', 'database administrator', 'security analyst',
        'network engineer', 'cloud architect', 'technical lead', 'tech lead',
        'cto', 'ceo', 'founder', 'co-founder', 'freelancer',
        // Arabic
        'مطور', 'مهندس', 'محلل', 'مدير', 'مصمم', 'خبير', 'قائد', 'مبرمج',
        'مهندس برمجيات', 'مطور ويب', 'مطور تطبيقات', 'مهندس نظم', 'مسؤول قواعد بيانات'
    ];
    
    for (const line of lines) {
        const lowerLine = line.toLowerCase();
        for (const title of jobTitlesList) {
            if (lowerLine.includes(title.toLowerCase())) {
                // تجنب الأسطر الطويلة جداً أو التي تحتوي على ايميل
                const trimmed = line.trim();
                if (trimmed.length < 100 && !trimmed.includes('@')) {
                    return trimmed;
                }
            }
        }
    }
    return '';
}

// ============================================
// استخراج الاهتمامات
// ============================================
function extractInterests(text) {
    const interests = [];
    const interestKeywords = [
        'reading', 'coding', 'design', 'photography', 'travel', 'music', 
        'sports', 'chess', 'painting', 'drawing', 'writing', 'blogging',
        'gaming', 'hiking', 'swimming', 'yoga', 'meditation', 'cooking',
        'dancing', 'singing', 'volunteering', 'teaching', 'learning',
        'قراءة', 'تصميم', 'سفر', 'موسيقى', 'رياضة', 'شطرنج', 'رسم', 'كتابة',
        'طبخ', 'رقص', 'تطوع', 'تعليم', 'تكنولوجيا', 'برمجة'
    ];
    const lowerText = text.toLowerCase();
    
    for (const interest of interestKeywords) {
        if (lowerText.includes(interest)) {
            interests.push(interest);
        }
    }
    return [...new Set(interests)].slice(0, 10);
}

// ============================================
// دالة الأيقونات الموحدة (تدعم المطابقة التامة والجزئية)
// ============================================
function getIconForSkill(name, options = {}) {
    const { exactMatch = false } = options;
    
    const iconMap = {
        // ===== Frontend (من الدالتين معاً) =====
        'react': 'bx bxl-react',
        'reactjs': 'bx bxl-react',
        'angular': 'bx bxl-angular',
        'angularjs': 'bx bxl-angular',
        'vue': 'bx bxl-vuejs',
        'vuejs': 'bx bxl-vuejs',
        'nuxt': 'bx bxl-vuejs',
        'nuxtjs': 'bx bxl-vuejs',
        'html': 'bx bxl-html5',
        'html5': 'bx bxl-html5',
        'css': 'bx bxl-css3',
        'css3': 'bx bxl-css3',
        'sass': 'bx bxl-sass',
        'scss': 'bx bxl-sass',
        'less': 'bx bxl-less',
        'tailwind': 'bx bxl-tailwind-css',
        'tailwindcss': 'bx bxl-tailwind-css',
        'bootstrap': 'bx bxl-bootstrap',
        'javascript': 'bx bxl-javascript',
        'js': 'bx bxl-javascript',
        'ecmascript': 'bx bxl-javascript',
        'es6': 'bx bxl-javascript',
        'typescript': 'bx bxl-typescript',
        'ts': 'bx bxl-typescript',
        'jquery': 'bx bxl-jquery',
        'webpack': 'bx bxl-webpack',
        'vite': 'bx bxl-vitejs',
        'vitejs': 'bx bxl-vitejs',
        'babel': 'bx bxl-babel',
        'next': 'bx bxl-react',
        'nextjs': 'bx bxl-react',
        'svelte': 'bx bxl-svelte',
        'solidjs': 'bx bxl-solidjs',
        'deno': 'bx bxl-deno',
        'bun': 'bx bxl-bun',
        
        // ===== Backend (من الدالتين معاً) =====
        'node': 'bx bxl-nodejs',
        'nodejs': 'bx bxl-nodejs',
        'express': 'bx bxl-nodejs',
        'expressjs': 'bx bxl-nodejs',
        'nestjs': 'bx bxl-nestjs',
        'python': 'bx bxl-python',
        'django': 'bx bxl-django',
        'flask': 'bx bxl-flask',
        'fastapi': 'bx bxl-fastapi',
        'java': 'bx bxl-java',
        'php': 'bx bxl-php',
        'laravel': 'bx bxl-laravel',
        'symfony': 'bx bxl-symfony',
        'codeigniter': 'bx bxl-codeigniter',
        'csharp': 'bx bxl-c-sharp',
        'c#': 'bx bxl-c-sharp',
        'dotnet': 'bx bxl-dot-net',
        '.net': 'bx bxl-dot-net',
        'asp.net': 'bx bxl-dot-net',
        'go': 'bx bxl-go-lang',
        'golang': 'bx bxl-go-lang',
        'rust': 'bx bxl-rust',
        'ruby': 'bx bxl-ruby',
        'rails': 'bx bxl-ruby-on-rails',
        'ruby on rails': 'bx bxl-ruby-on-rails',
        'spring': 'bx bxl-spring-boot',
        'springboot': 'bx bxl-spring-boot',
        
        // ===== Databases (من الدالتين معاً) =====
        'mongodb': 'bx bxl-mongodb',
        'mongo': 'bx bxl-mongodb',
        'mysql': 'bx bxl-mysql',
        'postgresql': 'bx bxl-postgresql',
        'postgres': 'bx bxl-postgresql',
        'sqlite': 'bx bxl-sqlite',
        'firebase': 'bx bxl-firebase',
        'redis': 'bx bxl-redis',
        'elasticsearch': 'bx bxl-elasticsearch',
        'dynamodb': 'bx bxl-dynamodb',
        'oracle': 'bx bxl-oracle',
        'mssql': 'bx bxl-microsoft',
        'sql server': 'bx bxl-microsoft',
        
        // ===== Cloud & DevOps (من الدالتين معاً) =====
        'aws': 'bx bxl-aws',
        'amazon web services': 'bx bxl-aws',
        'azure': 'bx bxl-microsoft',
        'microsoft azure': 'bx bxl-microsoft',
        'gcp': 'bx bxl-google-cloud',
        'google cloud': 'bx bxl-google-cloud',
        'docker': 'bx bxl-docker',
        'kubernetes': 'bx bxl-kubernetes',
        'k8s': 'bx bxl-kubernetes',
        'jenkins': 'bx bxl-jenkins',
        'terraform': 'bx bxl-terraform',
        'ansible': 'bx bxl-ansible',
        'git': 'bx bxl-git',
        'github': 'bx bxl-github',
        'gitlab': 'bx bxl-gitlab',
        'bitbucket': 'bx bxl-bitbucket',
        
        // ===== Mobile (من الدالتين معاً) =====
        'flutter': 'bx bxl-flutter',
        'dart': 'bx bxl-dart',
        'swift': 'bx bxl-swift',
        'kotlin': 'bx bxl-kotlin',
        'android': 'bx bxl-android',
        'android development': 'bx bxl-android',
        'ios': 'bx bxl-apple',
        'ios development': 'bx bxl-apple',
        'react native': 'bx bxl-react',
        'reactnative': 'bx bxl-react',
        'xamarin': 'bx bxl-xamarin',
        'ionic': 'bx bxl-ionic',
        'capacitor': 'bx bxl-capacitor',
        'cordova': 'bx bxl-cordova',
        
        // ===== Design (من الدالتين معاً) =====
        'figma': 'bx bxl-figma',
        'photoshop': 'bx bxl-photoshop',
        'illustrator': 'bx bxl-illustrator',
        'adobe xd': 'bx bxl-adobe',
        'adobexd': 'bx bxl-adobe',
        'sketch': 'bx bxl-sketch',
        'ui/ux': 'bx bxl-figma',
        'ui ux': 'bx bxl-figma',
        
        // ===== Data Science (من الدالتين معاً) =====
        'tensorflow': 'bx bxl-tensorflow',
        'pytorch': 'bx bxl-pytorch',
        'pandas': 'bx bxl-pandas',
        'numpy': 'bx bxl-numpy',
        'machine learning': 'bx bxl-ml',
        'ml': 'bx bxl-ml',
        'deep learning': 'bx bxl-deep-learning',
        'ai': 'bx bxl-ai',
        'artificial intelligence': 'bx bxl-ai',
        'data analysis': 'bx bxl-data',
        'data science': 'bx bxl-data',
        
        // ===== Other Tech (من الدالتين معاً) =====
        'graphql': 'bx bxl-graphql',
        'apollo': 'bx bxl-graphql',
        'rest api': 'bx bxl-rest-api',
        'microservices': 'bx bxl-microservices',
        'serverless': 'bx bxl-serverless',
        'seo': 'bx bxl-seo',
        'testing': 'bx bxl-testing',
        'jest': 'bx bxl-jest',
        'cypress': 'bx bxl-cypress',
        
        // ===== Soft Skills (من الدالتين معاً) =====
        'leadership': 'bx bxs-group',
        'management': 'bx bxs-group',
        'project management': 'bx bxs-group',
        'communication': 'bx bxs-chat',
        'teamwork': 'bx bxs-group',
        'problem solving': 'bx bxs-brain',
        'problem-solving': 'bx bxs-brain',
        'critical thinking': 'bx bxs-brain',
        'creativity': 'bx bxs-palette',
        'adaptability': 'bx bxs-flex',
        'time management': 'bx bxs-time',
        'agile': 'bx bxs-agile',
        'scrum': 'bx bxs-scrum',
        'kanban': 'bx bxs-kanban',
        
        // ===== Languages (من الدالتين معاً) =====
        'arabic': 'bx bxs-flag-alt',
        'english': 'bx bxs-flag-alt',
        'french': 'bx bxs-flag-alt',
        'german': 'bx bxs-flag-alt',
        'spanish': 'bx bxs-flag-alt',
        'chinese': 'bx bxs-flag-alt',
        'japanese': 'bx bxs-flag-alt',
        'korean': 'bx bxs-flag-alt',
        'russian': 'bx bxs-flag-alt',
        'italian': 'bx bxs-flag-alt',
        'portuguese': 'bx bxs-flag-alt',
        'dutch': 'bx bxs-flag-alt',
        'turkish': 'bx bxs-flag-alt',
    };
    
    const normalizedName = name.toLowerCase().trim();
    
    // 1️⃣ مطابقة تامة (للحالات الدقيقة)
    if (exactMatch && iconMap[normalizedName]) {
        return iconMap[normalizedName];
    }
    
    // 2️⃣ مطابقة تامة بدون exactMatch (للتوافق مع الكود القديم)
    if (iconMap[normalizedName]) {
        return iconMap[normalizedName];
    }
    
    // 3️⃣ بحث جزئي (للحالات الأوسع)
    for (const [key, icon] of Object.entries(iconMap)) {
        if (normalizedName.includes(key) || key.includes(normalizedName)) {
            return icon;
        }
    }
    
    // 4️⃣ أيقونة افتراضية
    return 'bx bx-code-alt';
}

// ============================================
// استخراج المهارات (النسخة النهائية)
// ============================================
function extractSkills(text) {
    const foundSkills = new Map();
    const lowerText = text.toLowerCase();
    
    for (const [keyword, skillName] of Object.entries(SKILLS_DATABASE)) {
        const regex = new RegExp(`\\b${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
        if (regex.test(lowerText)) {
            if (!foundSkills.has(skillName)) {
                const count = (lowerText.match(new RegExp(keyword, 'gi')) || []).length;
                let percentage = Math.min(95, 60 + (count * 5));
                
                // تحسين النسبة بناءً على السياق
                if (lowerText.includes(`advanced ${keyword}`) || lowerText.includes(`expert ${keyword}`)) {
                    percentage = Math.min(98, percentage + 10);
                } else if (lowerText.includes(`beginner ${keyword}`) || lowerText.includes(`basic ${keyword}`)) {
                    percentage = Math.max(40, percentage - 20);
                }
                
                // ✅ استخدام الدالة الموحدة (بحث جزئي تلقائي)
                const icon = getIconForSkill(keyword);
                foundSkills.set(skillName, { name: skillName, percentage, icon });
            }
        }
    }
    
    return Array.from(foundSkills.values())
        .sort((a, b) => b.percentage - a.percentage)
        .slice(0, 20);
}


// ============================================
// استخراج التعليم
// ============================================
function extractEducation(text) {
    const education = [];
    const lines = text.split('\n');
    const eduKeywords = ['university', 'college', 'institute', 'faculty', 'school', 
                         'bachelor', 'master', 'diploma', 'degree', 'phd', 'doctorate',
                         'جامعة', 'كلية', 'معهد', 'بكالوريوس', 'ماجستير', 'دكتوراه'];
    
    for (let i = 0; i < lines.length; i++) {
        const line = lines[i].toLowerCase();
        if (eduKeywords.some(keyword => line.includes(keyword))) {
            const institution = lines[i].trim();
            let degree = '';
            let year = '';
            
            const yearMatch = lines[i].match(/\b(19|20)\d{2}\b/);
            if (yearMatch) year = yearMatch[0];
            
            if (i + 1 < lines.length && lines[i + 1].length < 100) {
                degree = lines[i + 1].trim();
            }
            
            if (institution && institution.length > 2) {
                education.push({ institution, degree, year });
                if (education.length >= 4) break;
            }
        }
    }
    return education;
}

// ============================================
// استخراج الخبرات
// ============================================
function extractExperience(text) {
    const experience = [];
    const lines = text.split('\n');
    const expKeywords = ['experience', 'work', 'employment', 'job', 'company', 
                         'position', 'role', 'career', 'خبرة', 'عمل', 'شركة', 'وظيفة'];
    
    for (let i = 0; i < lines.length; i++) {
        const line = lines[i].toLowerCase();
        if (expKeywords.some(keyword => line.includes(keyword))) {
            const company = lines[i].trim();
            let role = '';
            let duration = '';
            
            const durationMatch = lines[i].match(/\b(19|20)\d{2}\s*[-–—]\s*(present|now|current|(19|20)\d{2}|\d{4})\b/i);
            if (durationMatch) duration = durationMatch[0];
            
            if (i + 1 < lines.length && lines[i + 1].length < 100) {
                role = lines[i + 1].trim();
            }
            
            if (company && company.length > 2 && !expKeywords.some(k => company.toLowerCase().includes(k))) {
                experience.push({ company, role, duration });
                if (experience.length >= 6) break;
            }
        }
    }
    return experience;
}

// ============================================
// استخراج الشهادات
// ============================================
function extractCertificates(text) {
    const certificates = [];
    const lines = text.split('\n');
    const certKeywords = ['certificate', 'certification', 'course', 'training', 
                          'diploma', 'credential', 'شهادة', 'دورة', 'تدريب'];
    
    for (let i = 0; i < lines.length; i++) {
        const line = lines[i].toLowerCase();
        if (certKeywords.some(keyword => line.includes(keyword))) {
            const name = lines[i].trim();
            let issuer = '';
            let year = '';
            
            const yearMatch = lines[i].match(/\b(19|20)\d{2}\b/);
            if (yearMatch) year = yearMatch[0];
            
            if (i + 1 < lines.length && lines[i + 1].length < 80) {
                issuer = lines[i + 1].trim();
            }
            
            if (name && name.length > 3 && !certKeywords.some(k => name.toLowerCase().includes(k))) {
                certificates.push({ name, issuer, year });
                if (certificates.length >= 6) break;
            }
        }
    }
    return certificates;
}


// ============================================
// POST /api/parse-resume - الـ endpoint الرئيسي
// ============================================
app.post('/api/parse-resume', authenticateToken, uploadPDF.single('resume'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ error: 'No file uploaded' });
        }
        
        if (req.file.mimetype !== 'application/pdf') {
            return res.status(400).json({ error: 'Only PDF files are allowed' });
        }
        
        // ✅ الملف موجود في req.file.buffer لأننا استخدمنا memoryStorage
        const pdfData = await pdfParse(req.file.buffer);
        const text = pdfData.text;
        
        if (!text || text.length < 50) {
            return res.status(400).json({ error: 'Could not extract text from PDF. Make sure it contains readable text.' });
        }
        
        const extractedData = {
            fullName: extractName(text),
            email: extractEmail(text),
            phone: extractPhone(text),
            bio: extractBio(text),
            jobTitle: extractJobTitle(text),
            skills: extractSkills(text),
            education: extractEducation(text),
            experience: extractExperience(text),
            certificates: extractCertificates(text),
            interests: extractInterests(text)
        };
        
        logger.info(`Resume parsed successfully for user ${req.user.userId}`);
        
        res.json({
            success: true,
            data: extractedData,
            message: 'Resume parsed successfully! Review and save the extracted data.'
        });
        
    } catch (error) {
        logger.error(`Error parsing resume: ${error.message}`);
        res.status(500).json({ error: 'Failed to parse resume: ' + error.message });
    }
});
// -----------------------------
app.post('/api/revoke-token', authenticateToken, [
    body('refreshToken').notEmpty().withMessage('Refresh token is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }

    const { refreshToken } = req.body;
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }

        // إزالة الـ Refresh Token المحدد
        user.refreshTokens = user.refreshTokens.filter(t => t.token !== refreshToken);
        await user.save();

        logger.info(`Refresh token revoked for user ${req.user.userId}`);
        res.json({ success: true, message: 'Refresh token revoked successfully' });
    } catch (error) {
        logger.error(`Error revoking refresh token: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ success: false, error: 'Failed to revoke refresh token: ' + error.message });
    }
});


// Endpoint لحذف ملف من Cloudinary
app.delete('/api/files/delete', authenticateToken, [
    body('public_id').notEmpty().withMessage('Public ID is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }

    const { public_id } = req.body;
    try {
        // حذف الملف من Cloudinary
        const result = await cloudinary.uploader.destroy(public_id);
        if (result.result !== 'ok') {
            return res.status(400).json({ success: false, error: 'Failed to delete file from Cloudinary' });
        }

        logger.info(`File deleted from Cloudinary: ${public_id} by user ${req.user.userId}`);
        res.json({ success: true, message: 'File deleted successfully' });
    } catch (error) {
        logger.error(`Error deleting file ${public_id}: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ success: false, error: 'Failed to delete file: ' + error.message });
    }
});

// Endpoint لاسترجاع قائمة الملفات
app.get('/api/files/list', authenticateToken, async (req, res) => {
    try {
        // ✅ التحقق من وجود cloudinary
        if (!cloudinary || !cloudinary.api) {
            logger.warn('Cloudinary not configured');
            return res.json({ success: true, data: [] });
        }
        
        // استرجاع الملفات من Cloudinary باستخدام prefix للمستخدم
        const result = await cloudinary.api.resources({
            resource_type: 'image',
            prefix: `Uploads/${req.user.userId}`,
            max_results: 100,
            type: 'upload'
        });
        
        // ✅ التحقق من وجود result.resources
        if (!result || !result.resources || !Array.isArray(result.resources)) {
            return res.json({ success: true, data: [] });
        }
        
        const files = result.resources.map(file => ({
            public_id: file.public_id,
            url: file.secure_url,
            format: file.format,
            created_at: file.created_at
        }));
        
        res.json({ success: true, data: files });
    } catch (error) {
        logger.error(`Error fetching file list for user ${req.user.userId}: ${error.message}`);
        // ✅ بدل 500، نرجع array فاضي
        res.json({ success: true, data: [] });
    }
});


app.get('/api/conversations/:userId', authenticateToken, async (req, res) => {
    const { userId } = req.params;

    // التحقق من أن المستخدم هو صاحب الـ userId أو Admin
    if (req.user.userId !== userId && !req.user.isAdmin) {
        return res.status(403).json({ success: false, error: 'Unauthorized access' });
    }

    try {
        const conversations = await Conversation.find({ userId })
            .sort({ 'messages.timestamp': -1 }) // ترتيب المحادثات حسب الوقت (الأحدث أولاً)
            .select('messages');
        res.json({ success: true, data: conversations });
    } catch (error) {
        logger.error(`Error fetching conversations for user ${userId}: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ success: false, error: 'Failed to fetch conversations: ' + error.message });
    }
});

app.get('/api/notifications/:userId', authenticateToken, async (req, res) => {
    const { userId } = req.params;

    // التحقق من أن المستخدم هو صاحب الـ userId أو Admin
    if (req.user.userId !== userId && !req.user.isAdmin) {
        return res.status(403).json({ success: false, error: 'Unauthorized access' });
    }

    try {
        const user = await User.findById(userId).select('notifications');
        if (!user) {
            return res.status(404).json({ success: false, error: 'User not found' });
        }
        res.json({ success: true, data: user.notifications || [] });
    } catch (error) {
        logger.error(`Error fetching notifications for user ${userId}: ${error.message}`);
        Sentry.captureException(error);
        res.status(500).json({ success: false, error: 'Failed to fetch notifications: ' + error.message });
    }
});


// ----------------------------------------------------------ADMIN SITE------------------



// ============================================
// GET /api/site-settings - جلب إعدادات الموقع
// ============================================
app.get('/api/site-settings', async (req, res) => {
    try {
        let settings = await SiteSettings.findOne();
        if (!settings) {
            settings = await SiteSettings.create({
                logo: '/assets/img/logo.svg',
                siteName: 'MGZon',
                navbarLinks: [
                    { label: 'Home', href: '/', order: 1 },
                    { label: 'Settings', href: '/settings.html', order: 2 }
                ],
                footerText: '© MGZon. All rights reserved'
            });
        }
        res.json(settings);
    } catch (error) {
        logger.error(`Error fetching site settings: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch site settings' });
    }
});

// ============================================
// PUT /api/site-settings - تحديث إعدادات الموقع (للأدمن فقط)
// ============================================
app.put('/api/site-settings', authenticateToken, isAdmin, [
    body('logo').optional().isURL(),
    body('siteName').optional().isString(),
    body('primaryColor').optional().matches(/^#[0-9A-Fa-f]{6}$/),
    body('navbarLinks').optional().isArray(),
    body('footerText').optional().isString()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const { logo, siteName, primaryColor, secondaryColor, navbarLinks, footerText } = req.body;
        
        let settings = await SiteSettings.findOne();
        if (!settings) {
            settings = new SiteSettings();
        }
        
        if (logo) settings.logo = logo;
        if (siteName) settings.siteName = siteName;
        if (primaryColor) settings.primaryColor = primaryColor;
        if (secondaryColor) settings.secondaryColor = secondaryColor;
        if (navbarLinks) settings.navbarLinks = navbarLinks;
        if (footerText) settings.footerText = footerText;
        settings.updatedAt = new Date();
        
        await settings.save();
        
        res.json({ success: true, data: settings });
    } catch (error) {
        logger.error(`Error updating site settings: ${error.message}`);
        res.status(500).json({ error: 'Failed to update site settings' });
    }
});

// ============================================
// POST /api/upload-logo - رفع شعار الموقع
// ============================================
app.post('/api/upload-logo', authenticateToken, isAdmin, upload.single('logo'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ error: 'No file uploaded' });
        }
        
        const logoUrl = req.file.path;
        
        let settings = await SiteSettings.findOne();
        if (!settings) {
            settings = new SiteSettings();
        }
        
        settings.logo = logoUrl;
        await settings.save();
        
        res.json({ success: true, logoUrl: logoUrl });
    } catch (error) {
        logger.error(`Error uploading logo: ${error.message}`);
        res.status(500).json({ error: 'Failed to upload logo' });
    }
});

// New endpoint for auth callback
app.get('/auth/callback', async (req, res) => {
    const { token, refreshToken, provider, error, redirect_uri } = req.query;

    // التحقق من redirect_uri
    const targetUri = redirect_uri && allowedRedirectUris.includes(redirect_uri)
        ? redirect_uri
        : allowedRedirectUris[0]; // fallback إلى أول URI مسموح بيه لو الـ redirect_uri مش موجود أو مش صحيح

    if (error) {
        logger.warn(`Auth callback error for provider ${provider}: ${error}`);
        return res.status(401).json({
            success: false,
            error: error,
            redirectUri: targetUri // الـ front-end يقرر يعمل إيه بالـ redirectUri
        });
    }

    // إرجاع JSON response بدل الـ redirect
    return res.redirect(`${targetUri}?token=${token}&refreshToken=${refreshToken}&provider=${provider}`);
});


// ============================================
// POST /api/posts - إنشاء منشور جديد (باستخدام uploadPost)
// ============================================
app.post('/api/posts', authenticateToken, uploadPost.array('images', 10), [
    body('content').notEmpty().withMessage('Content is required'),
    body('visibility').optional().isIn(['public', 'followers', 'only-me']),
    body('tags').optional().isArray(),
    body('mentions').optional().isArray()
], handleUploadError, async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const { content, visibility, tags, mentions } = req.body;
        
        // معالجة رفع الملفات
        const images = [];
        const videos = [];
        
        if (req.files) {
            for (const file of req.files) {
                const isVideo = file.mimetype?.startsWith('video/');
                const mediaData = {
                    url: file.path || file.secure_url,
                    publicId: file.filename || file.public_id,
                    width: file.width || null,
                    height: file.height || null
                };
                
                if (isVideo) {
                    videos.push({
                        ...mediaData,
                        duration: file.duration || null
                    });
                } else {
                    images.push(mediaData);
                }
            }
        }

        // معالجة الـ mentions (إذا كانت كائنات أو strings)
        let processedMentions = [];
        if (mentions && mentions.length > 0) {
            processedMentions = mentions.map(m => {
                if (typeof m === 'string') {
                    return { userId: m, username: null, position: 0 };
                }
                return m;
            });
        }

        const post = new Post({
            userId: req.user.userId,
            content,
            images: images,
            video: videos.length > 0 ? videos[0] : null,
            visibility: visibility || 'public',
            tags: tags || [],
            mentions: processedMentions
        });

        await post.save();

        // إشعارات للمستخدمين المذكورين
        if (processedMentions && processedMentions.length > 0) {
            const user = await User.findById(req.user.userId);
            const actorName = user?.profile?.nickname || user?.username || 'Someone';
            
            for (const mention of processedMentions) {
                if (mention.userId && mention.userId !== req.user.userId) {
                    await Notification.create({
                        userId: mention.userId,
                        type: 'mention',
                        actorId: req.user.userId,
                        actorName: actorName,
                        actorAvatar: user?.profile?.avatar || null,
                        targetId: post._id,
                        targetType: 'post',
                        content: `${actorName} mentioned you in a post`,
                        read: false
                    });
                }
            }
        }

        // ✅ إشعار للمتابعين بمنشور جديد (اختياري)
        await notifyFollowersAboutPost(req.user.userId, post._id);

        res.status(201).json({ success: true, data: post });
        
    } catch (error) {
        logger.error(`Error creating post: ${error.message}`);
        res.status(500).json({ error: 'Failed to create post: ' + error.message });
    }
});

// ============================================
// NOTIFY FOLLOWERS ABOUT POST - إشعار المتابعين بمنشور جديد
// ============================================
async function notifyFollowersAboutPost(userId, postId) {
    try {
        const followers = await Follow.find({
            followingId: userId,
            status: 'accepted'
        }).select('followerId');
        
        if (!followers.length) return;
        
        const user = await User.findById(userId).select('username profile.nickname profile.avatar');
        if (!user) return;
        
        const actorName = user.profile?.nickname || user.username || 'Someone';
        const actorAvatar = user.profile?.avatar || null;
        
        const notifications = followers.map(f => ({
            userId: f.followerId,
            type: 'system',
            actorId: userId,
            actorName: actorName,
            actorAvatar: actorAvatar,
            targetId: postId,
            targetType: 'post',
            content: `${actorName} posted a new update`,
            read: false,
            createdAt: new Date()
        }));
        
        await Notification.insertMany(notifications);
        logger.info(`📝 Post notifications sent to ${notifications.length} followers`);
        
    } catch (error) {
        logger.error(`Error sending post notifications: ${error.message}`);
    }
}

// ============================================
// GET /api/posts/feed - جلب Feed المنشورات
// ============================================
app.get('/api/posts/feed', authenticateToken, async (req, res) => {
    try {
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 20;
        const skip = (page - 1) * limit;

        // Get users that current user follows
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        }).select('followingId');

        const followingIds = following.map(f => f.followingId);
        
        // Include current user's own posts
        followingIds.push(req.user.userId);

        // Build query
        let query = {
            userId: { $in: followingIds },
            visibility: { $in: ['public', 'followers'] }
        };

        // Add filters
        if (req.query.type === 'recent') {
            // No additional filter
        } else if (req.query.type === 'popular') {
            query = { ...query, 'likes.1': { $exists: true } };
        }

        const posts = await Post.find(query)
            .sort({ pinned: -1, createdAt: -1 })
            .skip(skip)
            .limit(limit)
            .populate('userId', 'username profile.nickname profile.avatar')
            .lean();

        // Check if current user liked/saved each post
        const enrichedPosts = posts.map(post => ({
            ...post,
            isLiked: post.likes?.some(l => l.userId.toString() === req.user.userId),
            isSaved: post.saves?.some(s => s.userId.toString() === req.user.userId),
            likesCount: post.likes?.length || 0,
            commentsCount: post.comments?.length || 0,
            sharesCount: post.shares?.length || 0
        }));

        const total = await Post.countDocuments(query);

        res.json({
            success: true,
            data: enrichedPosts,
            pagination: {
                page,
                limit,
                total,
                pages: Math.ceil(total / limit)
            }
        });
    } catch (error) {
        logger.error(`Error fetching feed: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch feed' });
    }
});


// ============================================
// GET /api/posts/search - بحث في المنشورات
// ============================================
app.get('/api/posts/search', authenticateToken, async (req, res) => {
    try {
        const { q, type, page = 1, limit = 20 } = req.query;
        
        if (!q || q.length < 2) {
            return res.status(400).json({ error: 'Search query must be at least 2 characters' });
        }

        const skip = (parseInt(page) - 1) * parseInt(limit);

        let query = {
            $or: [
                { content: { $regex: q, $options: 'i' } },
                { tags: { $in: [new RegExp(q, 'i')] } }
            ],
            visibility: { $in: ['public', 'followers'] }
        };

        if (type === 'recent') {
            // Keep as is
        } else if (type === 'popular') {
            query = { ...query, 'likes.1': { $exists: true } };
        }

        const posts = await Post.find(query)
            .sort({ createdAt: -1 })
            .skip(skip)
            .limit(parseInt(limit))
            .populate('userId', 'username profile.nickname profile.avatar')
            .lean();

        const total = await Post.countDocuments(query);

        res.json({
            success: true,
            data: posts,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
    } catch (error) {
        logger.error(`Error searching posts: ${error.message}`);
        res.status(500).json({ error: 'Failed to search posts' });
    }
});

// ============================================
// GET /api/posts/suggested - جلب منشورات مقترحة
// ============================================
app.get('/api/posts/suggested', authenticateToken, async (req, res) => {
    try {
        const { limit = 5 } = req.query;
        
        // جلب المستخدمين الذين لا يتبعهم المستخدم الحالي
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        }).select('followingId');
        
        const followingIds = following.map(f => f.followingId);
        // إضافة المستخدم نفسه
        followingIds.push(req.user.userId);
        
        // جلب منشورات من مستخدمين غير متابعين
        const suggestedPosts = await Post.find({
            userId: { $nin: followingIds },
            visibility: { $in: ['public', 'followers'] }
        })
        .sort({ createdAt: -1 })
        .limit(parseInt(limit))
        .populate('userId', 'username profile.nickname profile.avatar profile.jobTitle')
        .lean();
        
        // إضافة معلومات إضافية
        const enrichedPosts = suggestedPosts.map(post => ({
            ...post,
            likesCount: post.likes?.length || 0,
            commentsCount: post.comments?.length || 0,
            sharesCount: post.shares?.length || 0,
            isLiked: post.likes?.some(l => l.userId.toString() === req.user.userId) || false,
            isSaved: post.saves?.some(s => s.userId.toString() === req.user.userId) || false
        }));
        
        res.json({
            success: true,
            data: enrichedPosts,
            count: enrichedPosts.length
        });
        
    } catch (error) {
        logger.error(`Error fetching suggested posts: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch suggested posts' });
    }
});
// ============================================
// GET /api/posts/user/:userId - منشورات مستخدم معين
// ============================================
app.get('/api/posts/user/:userId', authenticateToken, async (req, res) => {
    try {
        const { userId } = req.params;
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 20;
        const skip = (page - 1) * limit;

        // Check if viewing own profile or public posts
        const isOwner = userId === req.user.userId;
        
        let visibilityFilter = {};
        if (!isOwner) {
            visibilityFilter = { visibility: { $in: ['public', 'followers'] } };
        }

        const posts = await Post.find({
            userId,
            ...visibilityFilter
        })
        .sort({ pinned: -1, createdAt: -1 })
        .skip(skip)
        .limit(limit)
        .populate('userId', 'username profile.nickname profile.avatar')
        .lean();

        const enrichedPosts = posts.map(post => ({
            ...post,
            isLiked: post.likes?.some(l => l.userId.toString() === req.user.userId),
            isSaved: post.saves?.some(s => s.userId.toString() === req.user.userId)
        }));

        const total = await Post.countDocuments({ userId, ...visibilityFilter });

        res.json({
            success: true,
            data: enrichedPosts,
            pagination: { page, limit, total, pages: Math.ceil(total / limit) }
        });
    } catch (error) {
        logger.error(`Error fetching user posts: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch user posts' });
    }
});


// ============================================
// SAVED POSTS - UNIFIED ENDPOINT
// ============================================
// GET /api/posts/saved - المنشورات المحفوظة
app.get('/api/posts/saved', authenticateToken, async (req, res) => {
    try {
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 20;
        const skip = (page - 1) * limit;
        
        const posts = await Post.find({
            'saves.userId': req.user.userId
        })
        .sort({ 'saves.savedAt': -1 })
        .skip(skip)
        .limit(limit)
        .populate('userId', 'username profile.nickname profile.avatar')
        .lean();
        
        const enrichedPosts = posts.map(post => ({
            ...post,
            isSaved: true,
            likesCount: post.likes?.length || 0,
            commentsCount: post.comments?.length || 0,
            sharesCount: post.shares?.length || 0
        }));
        
        const total = await Post.countDocuments({ 'saves.userId': req.user.userId });
        
        res.json({
            success: true,
            data: enrichedPosts,
            pagination: { page, limit, total, pages: Math.ceil(total / limit) }
        });
    } catch (error) {
        logger.error(`Error fetching saved posts: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch saved posts' });
    }
});

// ============================================
// POST /api/posts/comments/:commentId/like - إعجاب/إلغاء إعجاب بتعليق بوست
// ============================================
app.post('/api/posts/comments/:commentId/like', authenticateToken, async (req, res) => {
    const { commentId } = req.params;
    
    try {
        // البحث عن البوست الذي يحتوي على هذا التعليق
        const post = await Post.findOne({ 'comments._id': commentId });
        if (!post) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        const comment = post.comments.id(commentId);
        if (!comment) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        const userId = req.user.userId;
        const hasLiked = comment.likes && comment.likes.includes(userId);
        
        if (hasLiked) {
            comment.likes = comment.likes.filter(id => id.toString() !== userId);
        } else {
            if (!comment.likes) comment.likes = [];
            comment.likes.push(userId);
        }
        
        await post.save();
        
        res.json({ 
            success: true, 
            likesCount: comment.likes.length, 
            hasLiked: !hasLiked 
        });
        
    } catch (error) {
        logger.error(`Error toggling like on post comment: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to toggle like' });
    }
});

// ============================================
// PUT /api/posts/comments/:commentId - تعديل تعليق بوست
// ============================================
app.put('/api/posts/comments/:commentId', authenticateToken, [
    body('text').notEmpty().withMessage('Comment text is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ success: false, error: errors.array().map(e => e.msg).join(', ') });
    }
    
    const { commentId } = req.params;
    const { text } = req.body;
    
    try {
        const post = await Post.findOne({ 'comments._id': commentId });
        if (!post) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        const comment = post.comments.id(commentId);
        if (!comment) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        // فقط صاحب التعليق أو الأدمن يمكنه التعديل
        if (comment.userId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ success: false, error: 'Unauthorized to edit this comment' });
        }
        
        comment.text = text;
        comment.edited = true;
        comment.editedAt = new Date();
        await post.save();
        
        res.json({ success: true, data: comment });
        
    } catch (error) {
        logger.error(`Error editing post comment: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to edit comment' });
    }
});

// ============================================
// DELETE /api/posts/comments/:commentId - حذف تعليق بوست
// ============================================
app.delete('/api/posts/comments/:commentId', authenticateToken, async (req, res) => {
    const { commentId } = req.params;
    
    try {
        const post = await Post.findOne({ 'comments._id': commentId });
        if (!post) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        const comment = post.comments.id(commentId);
        if (!comment) {
            return res.status(404).json({ success: false, error: 'Comment not found' });
        }
        
        // التحقق من الصلاحية
        const isCommentOwner = comment.userId.toString() === req.user.userId;
        const isPostOwner = post.userId.toString() === req.user.userId;
        const isAdminUser = req.user.isAdmin;
        
        if (!isCommentOwner && !isPostOwner && !isAdminUser) {
            return res.status(403).json({ success: false, error: 'Unauthorized to delete this comment' });
        }
        
        // حذف التعليق
        post.comments.pull({ _id: commentId });
        await post.save();
        
        res.json({ success: true, message: 'Comment deleted successfully' });
        
    } catch (error) {
        logger.error(`Error deleting post comment: ${error.message}`);
        res.status(500).json({ success: false, error: 'Failed to delete comment' });
    }
});

// ============================================
// POST /api/posts/comments/:commentId/report - التبليغ عن تعليق بوست
// ============================================
app.post('/api/posts/comments/:commentId/report', authenticateToken, async (req, res) => {
    const { commentId } = req.params;
    const { reason } = req.body;
    
    try {
        const post = await Post.findOne({ 'comments._id': commentId });
        if (!post) {
            return res.status(404).json({ error: 'Comment not found' });
        }
        
        const comment = post.comments.id(commentId);
        if (!comment) {
            return res.status(404).json({ error: 'Comment not found' });
        }
        
        // منع التبليغ عن تعليقك الخاص
        if (comment.userId.toString() === req.user.userId) {
            return res.status(400).json({ error: 'You cannot report your own comment' });
        }
        
        // منع التبليغ المتكرر
        if (!comment.reports) comment.reports = [];
        if (comment.reports.some(r => r.userId.toString() === req.user.userId)) {
            return res.status(400).json({ error: 'You already reported this comment' });
        }
        
        // إضافة التبليغ
        comment.reports.push({
            userId: req.user.userId,
            reason: reason || 'No reason provided',
            reportedAt: new Date()
        });
        comment.reportCount = (comment.reportCount || 0) + 1;
        
        await post.save();
        
        // إذا وصل لـ 3 تقارير، إخفاء التعليق
        let hiddenMessage = '';
        if (comment.reportCount >= 3) {
            comment.hidden = true;
            await post.save();
            hiddenMessage = ' Comment has been hidden.';
        }
        
        res.json({ 
            success: true, 
            message: comment.reportCount >= 3 ? 'Comment has been hidden due to multiple reports' : 'Report submitted successfully',
            reportCount: comment.reportCount,
            hidden: comment.hidden || false
        });
        
    } catch (error) {
        logger.error(`Error reporting post comment: ${error.message}`);
        res.status(500).json({ error: 'Failed to report comment' });
    }
});





// ============================================
// POST /api/reports - التبليغ عن محتوى
// ============================================
app.post('/api/reports', authenticateToken, [
    body('targetType').isIn(['post', 'comment', 'user', 'profile']),
    body('targetId').notEmpty(),
    body('reason').isIn(['spam', 'harassment', 'hate_speech', 'violence', 'nudity', 'misinformation', 'other']),
    body('details').optional().isLength({ max: 500 })
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const { targetType, targetId, reason, details } = req.body;

        // Check if already reported by this user
        const existingReport = await Report.findOne({
            reporterId: req.user.userId,
            targetType,
            targetId,
            status: 'pending'
        });

        if (existingReport) {
            return res.status(400).json({ error: 'You already reported this content' });
        }

        const report = new Report({
            reporterId: req.user.userId,
            targetType,
            targetId,
            reason,
            details: details || '',
            status: 'pending'
        });

        await report.save();

        // Notify admins
        const admins = await User.find({ isAdmin: true });
        for (const admin of admins) {
            await Notification.create({
                userId: admin._id,
                type: 'system',
                targetId: report._id,
                targetType: 'report',
                content: `New report: ${targetType} reported by ${req.user.username}`,
                read: false
            });
        }

        res.status(201).json({ success: true, message: 'Report submitted successfully' });
    } catch (error) {
        logger.error(`Error creating report: ${error.message}`);
        res.status(500).json({ error: 'Failed to submit report' });
    }
});

// ============================================
// POST /api/users/me/pin/:postId - تثبيت منشور
// ============================================
app.post('/api/users/me/pin/:postId', authenticateToken, async (req, res) => {
    try {
        const post = await Post.findOne({
            _id: req.params.postId,
            userId: req.user.userId
        });

        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        // Unpin all other posts
        if (!post.pinned) {
            await Post.updateMany(
                { userId: req.user.userId, pinned: true },
                { $set: { pinned: false, pinnedAt: null } }
            );
        }

        post.pinned = !post.pinned;
        post.pinnedAt = post.pinned ? new Date() : null;
        await post.save();

        res.json({ success: true, pinned: post.pinned });
    } catch (error) {
        logger.error(`Error pinning post: ${error.message}`);
        res.status(500).json({ error: 'Failed to pin post' });
    }
});

// ============================================
// GET /api/users/:userId/stats - إحصائيات المستخدم
// ============================================
app.get('/api/users/:userId/stats', async (req, res) => {
    try {
        const userId = req.params.userId;
        
        // ✅ التحقق من صحة الـ ObjectId (أهم شيء!)
        if (!mongoose.Types.ObjectId.isValid(userId)) {
            return res.status(400).json({ error: 'Invalid user ID format' });
        }
        
        const objectId = new mongoose.Types.ObjectId(userId);
        
        // ✅ جلب الإحصائيات من كل الموديلات
        const [
            postsCount,
            projectsCount,
            jobsCount,
            followersCount,
            followingCount,
            applicationsCount,
            savedPostsCount,
            savedJobsCount
        ] = await Promise.all([
            // من Post model
            Post.countDocuments({ userId: objectId }),
            
            // من Project model
            Project.countDocuments({ userId: objectId }),
            
            // من Job model (كصاحب عمل)
            Job.countDocuments({ employerId: objectId }),
            
            // من Follow model (متابعين)
            Follow.countDocuments({ followingId: objectId, status: 'accepted' }),
            
            // من Follow model (بيتابعهم)
            Follow.countDocuments({ followerId: objectId, status: 'accepted' }),
            
            // من JobApplication model (تقديمات على وظائف)
            JobApplication.countDocuments({ applicantId: objectId }),
            
            // من Post model (منشورات محفوظة)
            Post.countDocuments({ 'saves.userId': objectId }),
            
            // من JobSave model (وظائف محفوظة)
            JobSave.countDocuments({ userId: objectId })
        ]);
        
        // ✅ إجمالي الإعجابات المستلمة
        let totalLikes = 0;
        try {
            const likesReceived = await Post.aggregate([
                { $match: { userId: objectId } },
                { $project: { likesCount: { $size: '$likes' } } },
                { $group: { _id: null, total: { $sum: '$likesCount' } } }
            ]);
            totalLikes = likesReceived[0]?.total || 0;
        } catch (aggError) {
            console.error('Error in likes aggregation:', aggError);
            totalLikes = 0;
        }
        
        res.json({
            success: true,
            stats: {
                posts: postsCount || 0,
                projects: projectsCount || 0,
                jobs: jobsCount || 0,
                followers: followersCount || 0,
                following: followingCount || 0,
                applications: applicationsCount || 0,
                savedPosts: savedPostsCount || 0,
                savedJobs: savedJobsCount || 0,
                totalLikes: totalLikes
            }
        });
        
    } catch (error) {
        logger.error(`Error fetching user stats: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch user stats: ' + error.message });
    }
});


// ============================================
// GET /api/follow/requests - جلب طلبات المتابعة
// ============================================
app.get('/api/follow/requests', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;
        
        const requests = await Follow.find({
            followingId: userId,
            status: 'pending'
        }).populate('followerId', 'username profile.nickname profile.avatar profile.jobTitle');
        
        const formattedRequests = requests.map(req => ({
            _id: req._id,
            requester: {
                _id: req.followerId._id,
                username: req.followerId.username,
                profile: req.followerId.profile
            },
            requestedAt: req.createdAt
        }));
        
        res.json(formattedRequests);
        
    } catch (error) {
        logger.error(`Error fetching follow requests: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch follow requests' });
    }
});


// ============================================
// POST /api/follow/requests/:requestId/accept - قبول طلب متابعة
// ============================================
app.post('/api/follow/requests/:requestId/accept', authenticateToken, async (req, res) => {
    try {
        const { requestId } = req.params;
        
        if (!mongoose.Types.ObjectId.isValid(requestId)) {
            return res.status(400).json({ error: 'Invalid request ID' });
        }
        
        const follow = await Follow.findById(requestId);
        if (!follow) {
            return res.status(404).json({ error: 'Request not found' });
        }
        
        // التحقق من أن المستخدم هو المستهدف
        if (follow.followingId.toString() !== req.user.userId) {
            return res.status(403).json({ error: 'Unauthorized' });
        }
        
        follow.status = 'accepted';
        await follow.save();
        
        // إشعار للمستخدم اللي طلب المتابعة
        await Notification.create({
            userId: follow.followerId,
            type: 'follow',
            actorId: req.user.userId,
            actorName: req.user.username,
            content: `accepted your follow request`,
            read: false
        });
        
        res.json({ success: true, message: 'Request accepted' });
        
    } catch (error) {
        logger.error(`Error accepting follow request: ${error.message}`);
        res.status(500).json({ error: 'Failed to accept request' });
    }
});


// ============================================
// POST /api/follow/requests/:requestId/decline - رفض طلب متابعة
// ============================================
app.post('/api/follow/requests/:requestId/decline', authenticateToken, async (req, res) => {
    try {
        const { requestId } = req.params;
        
        if (!mongoose.Types.ObjectId.isValid(requestId)) {
            return res.status(400).json({ error: 'Invalid request ID' });
        }
        
        const follow = await Follow.findById(requestId);
        if (!follow) {
            return res.status(404).json({ error: 'Request not found' });
        }
        
        // التحقق من أن المستخدم هو المستهدف
        if (follow.followingId.toString() !== req.user.userId) {
            return res.status(403).json({ error: 'Unauthorized' });
        }
        
        await follow.deleteOne();
        
        res.json({ success: true, message: 'Request declined' });
        
    } catch (error) {
        logger.error(`Error declining follow request: ${error.message}`);
        res.status(500).json({ error: 'Failed to decline request' });
    }
});


// ============================================
// GET /api/posts/:postId/comments - جلب التعليقات
// ============================================
app.get('/api/posts/:postId/comments', authenticateToken, async (req, res) => {
    try {
        const post = await Post.findById(req.params.postId)
            .select('comments')
            .populate('comments.userId', 'username profile.nickname profile.avatar')
            .lean();

        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        res.json({ success: true, data: post.comments || [] });
    } catch (error) {
        logger.error(`Error fetching comments: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch comments' });
    }
});


// ============================================
// DELETE /api/comments/:postId/:commentId - حذف تعليق من منشور
// ============================================
app.delete('/api/comments/:postId/:commentId', authenticateToken, async (req, res) => {
    try {
        const { postId, commentId } = req.params;
        
        const post = await Post.findById(postId);
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }
        
        const commentIndex = post.comments.findIndex(c => c._id.toString() === commentId);
        if (commentIndex === -1) {
            return res.status(404).json({ error: 'Comment not found' });
        }
        
        const comment = post.comments[commentIndex];
        
        // Check permission
        if (comment.userId.toString() !== req.user.userId && 
            post.userId.toString() !== req.user.userId && 
            !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized to delete this comment' });
        }
        
        post.comments.splice(commentIndex, 1);
        await post.save();
        
        res.json({ success: true, message: 'Comment deleted' });
    } catch (error) {
        logger.error(`Error deleting comment: ${error.message}`);
        res.status(500).json({ error: 'Failed to delete comment' });
    }
});

// ============================================
// POST /api/posts/:postId/share - مشاركة منشور مع إشعار
// ============================================
app.post('/api/posts/:postId/share', authenticateToken, async (req, res) => {
    try {
        const post = await Post.findById(req.params.postId);
        
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        const hasShared = post.shares.some(s => s.userId.toString() === req.user.userId);

        if (!hasShared) {
            post.shares.push({ userId: req.user.userId, sharedAt: new Date() });
            await post.save();

            // ✅ إشعار لصاحب المنشور
            if (post.userId.toString() !== req.user.userId) {
                const actor = await User.findById(req.user.userId).select('username profile.nickname profile.avatar');
                const actorName = actor?.profile?.nickname || actor?.username || 'Someone';
                
                await Notification.create({
                    userId: post.userId,
                    type: 'share',
                    actorId: req.user.userId,
                    actorName: actorName,
                    actorAvatar: actor?.profile?.avatar,
                    targetId: post._id,
                    targetType: 'post',
                    content: `shared your post`,
                    link: `/post.html?id=${post._id}`,
                    read: false
                });

                // ✅ إشعار عن طريق البريد الإلكتروني (اختياري)
                try {
                    const postOwner = await User.findById(post.userId).select('email username');
                    await sendEmailWithBrevo(
                        postOwner.email,
                        `📤 ${actorName} shared your post`,
                        `<div>
                            <h2>${actorName} shared your post</h2>
                            <p>View it here: <a href="${FRONTEND_URL}/post.html?id=${post._id}">Open Post</a></p>
                        </div>`,
                        `${actorName} shared your post`
                    );
                } catch (emailError) {
                    logger.error(`Failed to send share email: ${emailError.message}`);
                }
            }
        }

        res.json({ success: true, sharesCount: post.shares.length });
    } catch (error) {
        logger.error(`Error sharing post: ${error.message}`);
        res.status(500).json({ error: 'Failed to share post' });
    }
});

// ============================================
// POST /api/posts/share-to-profile - مشاركة بوست على البروفايل الشخصي مع إشعار
// ============================================
app.post('/api/posts/share-to-profile', authenticateToken, [
    body('originalPostId').notEmpty().withMessage('Original post ID is required'),
    body('content').optional().isString()
], async (req, res) => {
    try {
        const { originalPostId, content } = req.body;
        
        // جلب البوست الأصلي
        const originalPost = await Post.findById(originalPostId)
            .populate('userId', 'username profile.nickname profile.avatar');
        
        if (!originalPost) {
            return res.status(404).json({ error: 'Original post not found' });
        }
        
        // إنشاء بوست جديد للمشاركة
        const authorName = originalPost.userId.profile?.nickname || originalPost.userId.username;
        const sharedContent = content || `Shared a post by ${authorName}: ${originalPost.content.substring(0, 200)}${originalPost.content.length > 200 ? '...' : ''}`;
        
        const sharedPost = new Post({
            userId: req.user.userId,
            content: sharedContent,
            visibility: 'public',
            sharedFrom: {
                originalPostId: originalPost._id,
                originalAuthorId: originalPost.userId._id,
                originalAuthorName: authorName,
                sharedAt: new Date()
            },
            createdAt: new Date()
        });
        
        await sharedPost.save();
        
        // ✅ إشعار لصاحب البوست الأصلي
        if (originalPost.userId._id.toString() !== req.user.userId) {
            const actor = await User.findById(req.user.userId).select('username profile.nickname profile.avatar');
            const actorName = actor?.profile?.nickname || actor?.username || 'Someone';
            
            await Notification.create({
                userId: originalPost.userId._id,
                type: 'share',
                actorId: req.user.userId,
                actorName: actorName,
                actorAvatar: actor?.profile?.avatar,
                targetId: originalPost._id,
                targetType: 'post',
                content: `shared your post on their profile`,
                link: `/profile/${actorName}`,
                read: false
            });

            // ✅ إشعار بريد إلكتروني (اختياري)
            try {
                const postOwner = await User.findById(originalPost.userId._id).select('email username');
                await sendEmailWithBrevo(
                    postOwner.email,
                    `📤 ${actorName} shared your post on their profile`,
                    `<div>
                        <h2>${actorName} shared your post</h2>
                        <p>View their profile: <a href="${FRONTEND_URL}/profile/${actorName}">${actorName}'s Profile</a></p>
                        <p>View original post: <a href="${FRONTEND_URL}/post.html?id=${originalPost._id}">Open Post</a></p>
                    </div>`,
                    `${actorName} shared your post on their profile`
                );
            } catch (emailError) {
                logger.error(`Failed to send share email: ${emailError.message}`);
            }
        }
        
        res.status(201).json({ 
            success: true, 
            message: 'Post shared to your profile',
            data: sharedPost 
        });
        
    } catch (error) {
        logger.error(`Error sharing post to profile: ${error.message}`);
        res.status(500).json({ error: 'Failed to share post' });
    }
});

// ============================================
// POST /api/users/:userId/follow - متابعة/إلغاء متابعة
// ============================================
app.post('/api/users/:userId/follow', authenticateToken, async (req, res) => {
    try {
        const targetUserId = req.params.userId;
        
        if (targetUserId === req.user.userId) {
            return res.status(400).json({ error: 'Cannot follow yourself' });
        }
        
        const existingFollow = await Follow.findOne({
            followerId: req.user.userId,
            followingId: targetUserId
        });
        
        if (existingFollow) {
            // ✅ إلغاء المتابعة
            await existingFollow.deleteOne();
            
            // ✅ حذف الإشعار المرتبط
            await Notification.deleteMany({
                userId: targetUserId,
                type: 'follow',
                actorId: req.user.userId
            });
            
            res.json({ success: true, isFollowing: false, message: 'Unfollowed successfully' });
        } else {
            // ✅ متابعة جديدة
            const follow = new Follow({
                followerId: req.user.userId,
                followingId: targetUserId,
                status: 'accepted'
            });
            await follow.save();
            
            // ✅ إنشاء إشعار
            const currentUserData = await User.findById(req.user.userId);
            await Notification.create({
                userId: targetUserId,
                type: 'follow',
                actorId: req.user.userId,
                actorName: currentUserData.profile?.nickname || currentUserData.username,
                actorAvatar: currentUserData.profile?.avatar,
                targetId: req.user.userId,
                targetType: 'user',
                content: `started following you`,
                read: false
            });
            
            res.json({ success: true, isFollowing: true, message: 'Followed successfully' });
        }
    } catch (error) {
        logger.error(`Error toggling follow: ${error.message}`);
        res.status(500).json({ error: 'Failed to toggle follow' });
    }
});


// ============================================
// GET /api/posts/:postId - جلب منشور معين
// ============================================
app.get('/api/posts/:postId', authenticateToken, async (req, res) => {
    try {
        const post = await Post.findById(req.params.postId)
            .populate('userId', 'username profile.nickname profile.avatar')
            .populate('comments.userId', 'username profile.nickname profile.avatar')
            .lean();

        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        // Check visibility
        const isOwner = post.userId._id.toString() === req.user.userId;
        const isFollowing = await Follow.findOne({
            followerId: req.user.userId,
            followingId: post.userId._id,
            status: 'accepted'
        });

        if (!isOwner && post.visibility === 'only-me') {
            return res.status(403).json({ error: 'This post is private' });
        }

        if (post.visibility === 'followers' && !isOwner && !isFollowing) {
            return res.status(403).json({ error: 'This post is only visible to followers' });
        }

        const enrichedPost = {
            ...post,
            isLiked: post.likes?.some(l => l.userId.toString() === req.user.userId),
            isSaved: post.saves?.some(s => s.userId.toString() === req.user.userId),
            likesCount: post.likes?.length || 0,
            commentsCount: post.comments?.length || 0,
            sharesCount: post.shares?.length || 0
        };

        res.json({ success: true, data: enrichedPost });
    } catch (error) {
        logger.error(`Error fetching post: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch post' });
    }
});

// ============================================
// PUT /api/posts/:postId - تحديث منشور
// ============================================
app.put('/api/posts/:postId', authenticateToken, [
    body('content').optional().notEmpty(),
    body('visibility').optional().isIn(['public', 'followers', 'only-me'])
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const post = await Post.findById(req.params.postId);
        
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        if (post.userId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized to edit this post' });
        }

        const { content, visibility, tags } = req.body;

        if (content) post.content = content;
        if (visibility) post.visibility = visibility;
        if (tags) post.tags = tags;
        
        post.isEdited = true;
        post.editedAt = new Date();

        await post.save();

        res.json({ success: true, data: post });
    } catch (error) {
        logger.error(`Error updating post: ${error.message}`);
        res.status(500).json({ error: 'Failed to update post' });
    }
});

// ============================================
// DELETE /api/posts/:postId - حذف منشور
// ============================================
app.delete('/api/posts/:postId', authenticateToken, async (req, res) => {
    try {
        const post = await Post.findById(req.params.postId);
        
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        if (post.userId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized to delete this post' });
        }

        // Delete images from Cloudinary
        if (post.images && post.images.length > 0) {
            for (const image of post.images) {
                if (image.publicId) {
                    await cloudinary.uploader.destroy(image.publicId);
                }
            }
        }

        await post.deleteOne();

        res.json({ success: true, message: 'Post deleted successfully' });
    } catch (error) {
        logger.error(`Error deleting post: ${error.message}`);
        res.status(500).json({ error: 'Failed to delete post' });
    }
});

// ============================================
// POST /api/posts/:postId/like - إعجاب/إلغاء إعجاب مع إشعار
// ============================================
app.post('/api/posts/:postId/like', authenticateToken, async (req, res) => {
    try {
        const post = await Post.findById(req.params.postId);
        
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        const hasLiked = post.likes.some(l => l.userId.toString() === req.user.userId);

        if (hasLiked) {
            post.likes = post.likes.filter(l => l.userId.toString() !== req.user.userId);
        } else {
            post.likes.push({ userId: req.user.userId, likedAt: new Date() });
            
            // ✅ إشعار لصاحب المنشور
            if (post.userId.toString() !== req.user.userId) {
                const actor = await User.findById(req.user.userId).select('username profile.nickname profile.avatar');
                const actorName = actor?.profile?.nickname || actor?.username || 'Someone';
                
                await Notification.create({
                    userId: post.userId,
                    type: 'like',
                    actorId: req.user.userId,
                    actorName: actorName,
                    actorAvatar: actor?.profile?.avatar,
                    targetId: post._id,
                    targetType: 'post',
                    content: `liked your post`,
                    link: `/post.html?id=${post._id}`,
                    read: false
                });

                // ✅ إشعار بريد إلكتروني (اختياري)
                try {
                    const postOwner = await User.findById(post.userId).select('email username');
                    await sendEmailWithBrevo(
                        postOwner.email,
                        `❤️ ${actorName} liked your post`,
                        `<div>
                            <h2>${actorName} liked your post</h2>
                            <p>View it here: <a href="${FRONTEND_URL}/post.html?id=${post._id}">Open Post</a></p>
                        </div>`,
                        `${actorName} liked your post`
                    );
                } catch (emailError) {
                    logger.error(`Failed to send like email: ${emailError.message}`);
                }
            }
        }

        await post.save();

        res.json({ 
            success: true, 
            likesCount: post.likes.length,
            isLiked: !hasLiked
        });
    } catch (error) {
        logger.error(`Error toggling like: ${error.message}`);
        res.status(500).json({ error: 'Failed to toggle like' });
    }
});

// ============================================
// POST /api/posts/:postId/save - حفظ/إلغاء حفظ (بدون إشعار - خاصية شخصية)
// ============================================
app.post('/api/posts/:postId/save', authenticateToken, async (req, res) => {
    try {
        const post = await Post.findById(req.params.postId);
        
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        const hasSaved = post.saves.some(s => s.userId.toString() === req.user.userId);

        if (hasSaved) {
            post.saves = post.saves.filter(s => s.userId.toString() !== req.user.userId);
        } else {
            post.saves.push({ userId: req.user.userId, savedAt: new Date() });
            // ❌ لا يوجد إشعار للحفظ (خاصية شخصية)
        }

        await post.save();

        res.json({ 
            success: true, 
            savesCount: post.saves.length,
            isSaved: !hasSaved
        });
    } catch (error) {
        logger.error(`Error toggling save: ${error.message}`);
        res.status(500).json({ error: 'Failed to toggle save' });
    }
});

// ============================================
// POST /api/posts/:postId/comments - إضافة تعليق مع إشعار
// ============================================
app.post('/api/posts/:postId/comments', authenticateToken, [
    body('text').notEmpty().withMessage('Comment text is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const post = await Post.findById(req.params.postId);
        
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        const comment = {
            userId: req.user.userId,
            text: req.body.text,
            createdAt: new Date(),
            likes: [],
            edited: false,
            reports: [],
            reportCount: 0,
            hidden: false
        };

        post.comments.push(comment);
        await post.save();

        // ✅ إشعار لصاحب المنشور
        if (post.userId.toString() !== req.user.userId) {
            const actor = await User.findById(req.user.userId).select('username profile.nickname profile.avatar');
            const actorName = actor?.profile?.nickname || actor?.username || 'Someone';
            const commentText = req.body.text.substring(0, 50);
            
            await Notification.create({
                userId: post.userId,
                type: 'comment',
                actorId: req.user.userId,
                actorName: actorName,
                actorAvatar: actor?.profile?.avatar,
                targetId: post._id,
                targetType: 'post',
                content: `commented on your post: "${commentText}${req.body.text.length > 50 ? '...' : ''}"`,
                link: `/post.html?id=${post._id}`,
                read: false
            });

            // ✅ إشعار بريد إلكتروني (اختياري)
            try {
                const postOwner = await User.findById(post.userId).select('email username');
                await sendEmailWithBrevo(
                    postOwner.email,
                    `💬 ${actorName} commented on your post`,
                    `<div>
                        <h2>${actorName} commented on your post</h2>
                        <p><strong>Comment:</strong> ${req.body.text}</p>
                        <p>View it here: <a href="${FRONTEND_URL}/post.html?id=${post._id}">Open Post</a></p>
                    </div>`,
                    `${actorName} commented: ${req.body.text}`
                );
            } catch (emailError) {
                logger.error(`Failed to send comment email: ${emailError.message}`);
            }
        }

        res.status(201).json({ success: true, data: comment });
    } catch (error) {
        logger.error(`Error adding comment: ${error.message}`);
        res.status(500).json({ error: 'Failed to add comment' });
    }
});

// ============================================
// POST /api/posts/:postId/comments/:commentId/reply - رد على تعليق مع إشعار
// ============================================
app.post('/api/posts/:postId/comments/:commentId/reply', authenticateToken, [
    body('text').notEmpty().withMessage('Reply text is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const { postId, commentId } = req.params;
        const { text } = req.body;

        const post = await Post.findById(postId);
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        // ✅ البحث عن التعليق الأصلي
        const parentComment = post.comments.id(commentId);
        if (!parentComment) {
            return res.status(404).json({ error: 'Comment not found' });
        }

        // ✅ إنشاء الرد مع `_id`
        const reply = {
            _id: new mongoose.Types.ObjectId(),  // ✅ إضافة _id يدوياً
            userId: req.user.userId,
            text: text.trim(),
            createdAt: new Date(),
            likes: [],
            edited: false,
            editedAt: null,
            reports: [],
            reportCount: 0,
            hidden: false
        };

        // ✅ إضافة الرد إلى الـ replies
        if (!parentComment.replies) {
            parentComment.replies = [];
        }
        parentComment.replies.push(reply);
        
        // ✅ حفظ البوست
        await post.save();

        // ✅ إشعار لصاحب التعليق الأصلي
        if (parentComment.userId.toString() !== req.user.userId) {
            const actor = await User.findById(req.user.userId).select('username profile.nickname profile.avatar');
            const actorName = actor?.profile?.nickname || actor?.username || 'Someone';
            
            await Notification.create({
                userId: parentComment.userId,
                type: 'reply',
                actorId: req.user.userId,
                actorName: actorName,
                actorAvatar: actor?.profile?.avatar,
                targetId: post._id,
                targetType: 'comment',
                content: `replied to your comment: "${text.substring(0, 50)}${text.length > 50 ? '...' : ''}"`,
                link: `/post.html?id=${post._id}`,
                read: false
            });

            // ✅ إشعار بريد إلكتروني (اختياري)
            try {
                const commentOwner = await User.findById(parentComment.userId).select('email username');
                await sendEmailWithBrevo(
                    commentOwner.email,
                    `💬 ${actorName} replied to your comment`,
                    `<div>
                        <h2>${actorName} replied to your comment</h2>
                        <p><strong>Reply:</strong> ${text}</p>
                        <p><strong>Original comment:</strong> ${parentComment.text}</p>
                        <p>View it here: <a href="${FRONTEND_URL}/post.html?id=${post._id}">Open Post</a></p>
                    </div>`,
                    `${actorName} replied: ${text}`
                );
            } catch (emailError) {
                logger.error(`Failed to send reply email: ${emailError.message}`);
            }
        }

        res.status(201).json({ 
            success: true, 
            data: reply 
        });

    } catch (error) {
        logger.error(`Error adding reply: ${error.message}`);
        res.status(500).json({ error: 'Failed to add reply' });
    }
});

// ============================================
// POST /api/posts/:postId/comments/:commentId/report - التبليغ عن تعليق مع إشعار
// ============================================
app.post('/api/posts/:postId/comments/:commentId/report', authenticateToken, async (req, res) => {
    const { postId, commentId } = req.params;
    const { reason } = req.body;

    try {
        const post = await Post.findById(postId);
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }

        const comment = post.comments.id(commentId);
        if (!comment) {
            return res.status(404).json({ error: 'Comment not found' });
        }

        // ✅ منع التبليغ عن تعليقك الخاص
        if (comment.userId.toString() === req.user.userId) {
            return res.status(400).json({ error: 'You cannot report your own comment' });
        }

        // ✅ منع التبليغ المتكرر من نفس المستخدم
        if (comment.reports?.some(r => r.userId.toString() === req.user.userId)) {
            return res.status(400).json({ error: 'You already reported this comment' });
        }

        // ✅ إضافة التبليغ
        comment.reports = comment.reports || [];
        comment.reports.push({
            userId: req.user.userId,
            reason: reason || 'No reason provided',
            reportedAt: new Date(),
            reporterUsername: req.user.username,
            resolved: false
        });
        comment.reportCount = (comment.reportCount || 0) + 1;

        await post.save();

        // ✅ إشعار لصاحب التعليق (تنبيه)
        if (comment.userId.toString() !== req.user.userId) {
            const reporter = await User.findById(req.user.userId).select('username profile.nickname');
            const reporterName = reporter?.profile?.nickname || reporter?.username || 'Someone';
            
            await Notification.create({
                userId: comment.userId,
                type: 'warning',
                actorId: req.user.userId,
                actorName: reporterName,
                targetId: post._id,
                targetType: 'comment',
                content: `⚠️ Your comment has been reported (${comment.reportCount}/3)`,
                link: `/post.html?id=${post._id}`,
                read: false,
                metadata: { reportCount: comment.reportCount }
            });
        }

        // ✅ إشعار للمشرفين
        if (comment.reportCount >= 2) {
            const adminUsers = await User.find({ isAdmin: true });
            const reporter = await User.findById(req.user.userId).select('username profile.nickname');
            const reporterName = reporter?.profile?.nickname || reporter?.username || 'Someone';
            const commentAuthor = await User.findById(comment.userId).select('username profile.nickname');
            const authorName = commentAuthor?.profile?.nickname || commentAuthor?.username || 'Unknown';

            for (const admin of adminUsers) {
                await Notification.create({
                    userId: admin._id,
                    type: 'admin_report',
                    actorId: req.user.userId,
                    actorName: reporterName,
                    targetId: post._id,
                    targetType: 'comment',
                    content: `🚨 ${reporterName} reported comment by ${authorName}: "${comment.text.substring(0, 50)}..." (${comment.reportCount}/3)`,
                    link: `/admin/comments?highlight=${commentId}`,
                    read: false,
                    metadata: { 
                        commentId: commentId,
                        postId: postId,
                        reportCount: comment.reportCount,
                        reason: reason || 'No reason provided'
                    }
                });
            }
        }

        // ✅ إذا وصل عدد التقارير لـ 3، إخفاء التعليق تلقائياً
        let hiddenMessage = '';
        if (comment.reportCount >= 3) {
            comment.hidden = true;
            await post.save();
            hiddenMessage = ' Comment has been hidden.';

            // إشعار لصاحب التعليق بأن تعليقه تم إخفاؤه
            await Notification.create({
                userId: comment.userId,
                type: 'warning',
                actorId: req.user.userId,
                targetId: post._id,
                targetType: 'comment',
                content: `🔒 Your comment has been hidden due to ${comment.reportCount} reports`,
                link: `/post.html?id=${post._id}`,
                read: false,
                metadata: { action: 'hidden', reportCount: comment.reportCount }
            });

            logger.info(`Comment ${commentId} hidden due to ${comment.reportCount} reports`);
        }

        res.json({ 
            success: true, 
            message: comment.reportCount >= 3 ? 'Comment has been hidden due to multiple reports' : 'Report submitted successfully',
            reportCount: comment.reportCount,
            hidden: comment.hidden || false
        });

    } catch (error) {
        logger.error(`Error reporting comment: ${error.message}`);
        res.status(500).json({ error: 'Failed to report comment' });
    }
});


// ============================================
// POST /api/posts/comments/:commentId/reply/:replyId/like - إعجاب/إلغاء إعجاب برد
// ============================================
app.post('/api/posts/comments/:commentId/reply/:replyId/like', authenticateToken, async (req, res) => {
    try {
        const { commentId, replyId } = req.params;
        
        // ✅ البحث عن البوست الذي يحتوي على هذا التعليق والرد
        const post = await Post.findOne({
            'comments._id': commentId,
            'comments.replies._id': replyId
        });
        
        if (!post) {
            return res.status(404).json({ error: 'Post not found' });
        }
        
        // ✅ البحث عن التعليق
        const comment = post.comments.id(commentId);
        if (!comment) {
            return res.status(404).json({ error: 'Comment not found' });
        }
        
        // ✅ البحث عن الرد (باستخدام id())
        const reply = comment.replies.id(replyId);
        if (!reply) {
            return res.status(404).json({ error: 'Reply not found' });
        }
        
        // ✅ التحقق من وجود الإعجاب
        const hasLiked = reply.likes && reply.likes.some(l => l.userId.toString() === req.user.userId);
        
        if (hasLiked) {
            // ✅ إلغاء الإعجاب
            reply.likes = reply.likes.filter(l => l.userId.toString() !== req.user.userId);
        } else {
            // ✅ إضافة إعجاب
            if (!reply.likes) reply.likes = [];
            reply.likes.push({ userId: req.user.userId, likedAt: new Date() });
            
            // ✅ إشعار لصاحب الرد
            if (reply.userId.toString() !== req.user.userId) {
                const actor = await User.findById(req.user.userId).select('username profile.nickname profile.avatar');
                const actorName = actor?.profile?.nickname || actor?.username || 'Someone';
                
                await Notification.create({
                    userId: reply.userId,
                    type: 'like',
                    actorId: req.user.userId,
                    actorName: actorName,
                    actorAvatar: actor?.profile?.avatar,
                    targetId: post._id,
                    targetType: 'reply',
                    content: `liked your reply: "${reply.text.substring(0, 50)}${reply.text.length > 50 ? '...' : ''}"`,
                    link: `/post.html?id=${post._id}`,
                    read: false
                });
            }
        }
        
        await post.save();
        
        res.json({
            success: true,
            likesCount: reply.likes.length,
            hasLiked: !hasLiked
        });
        
    } catch (error) {
        logger.error(`Error toggling reply like: ${error.message}`);
        res.status(500).json({ error: 'Failed to toggle reply like' });
    }
});

// ============================================
// GET /api/notifications - جلب الإشعارات
// ============================================
app.get('/api/notifications', authenticateToken, async (req, res) => {
    try {
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 30;
        const skip = (page - 1) * limit;
        
        // ✅ 1. جلب الإشعارات من موديل Notification (المتقدمة)
        const advancedNotifications = await Notification.find({ userId: req.user.userId })
            .sort({ createdAt: -1 })
            .limit(limit)
            .populate('actorId', 'username profile.nickname profile.avatar')
            .lean();
        
        // ✅ 2. جلب الإشعارات من User.notifications (القديمة/البسيطة)
        const user = await User.findById(req.user.userId).select('notifications');
        const simpleNotifications = (user?.notifications || []).map(notif => ({
            _id: notif._id,
            type: notif.type || 'system',
            actorId: null,
            actorName: null,
            actorAvatar: null,
            targetId: notif.link || null,
            targetType: 'system',
            content: notif.message,
            read: notif.read || false,
            createdAt: notif.createdAt,
            source: 'user' // لمعرفة مصدر الإشعار
        }));
        
        // ✅ 3. دمج وترتيب الإشعارات من المصدرين
        let allNotifications = [...advancedNotifications, ...simpleNotifications];
        
        // تحويل advanced notifications لإضافة source
        allNotifications = allNotifications.map(notif => ({
            ...notif,
            source: notif.source || 'advanced'
        }));
        
        // ترتيب من الأحدث إلى الأقدم
        allNotifications.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
        
        // ✅ 4. حساب الإحصائيات
        const unreadCount = allNotifications.filter(n => !n.read).length;
        const total = allNotifications.length;
        
        // ✅ 5. تطبيق pagination بعد الدمج
        const paginatedNotifications = allNotifications.slice(skip, skip + limit);
        
        res.json({
            success: true,
            data: paginatedNotifications,
            unreadCount,
            pagination: {
                page,
                limit,
                total,
                pages: Math.ceil(total / limit)
            }
        });
        
    } catch (error) {
        logger.error(`Error fetching unified notifications: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch notifications' });
    }
});
// ============================================
// PUT /api/notifications/:id/read - تعليم إشعار كمقروء
// ============================================
app.put('/api/notifications/:id/read', authenticateToken, async (req, res) => {
    try {
        const { id } = req.params;
        
        // ✅ 1. حاول البحث في Notification model أولاً
        const advancedResult = await Notification.updateOne(
            { _id: id, userId: req.user.userId },
            { $set: { read: true } }
        );
        
        if (advancedResult.matchedCount > 0) {
            return res.json({ success: true, source: 'advanced' });
        }
        
        // ✅ 2. إذا لم يوجد، حاول البحث في User.notifications
        const user = await User.findById(req.user.userId);
        if (user && user.notifications) {
            const notification = user.notifications.id(id);
            if (notification) {
                notification.read = true;
                await user.save();
                return res.json({ success: true, source: 'user' });
            }
        }
        
        return res.status(404).json({ error: 'Notification not found' });
        
    } catch (error) {
        logger.error(`Error marking notification as read: ${error.message}`);
        res.status(500).json({ error: 'Failed to mark notification as read' });
    }
});

// ============================================
// POST /api/stories - إنشاء story (باستخدام uploadStory)
// ============================================

app.post('/api/stories', authenticateToken, uploadStory.fields([
    { name: 'media', maxCount: 1 },
    { name: 'audio', maxCount: 1 }
]), [
    body('text').optional().isString(),
    body('backgroundColor').optional().isString(),
    body('textColor').optional().isString(),
    body('textStyle').optional().isString(),
    body('filter').optional().isString(),
    body('filterIntensity').optional().isNumeric(),
    body('allowDownload').optional().isBoolean(),
    body('visibility').optional().isIn(['public', 'followers', 'only-me'])
], handleUploadError, async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        let mediaUrl = null;
        let publicId = null;
        let mediaType = 'none';
        
        let audioUrl = null;
        let audioPublicId = null;
        let audioDuration = 0;

        // ✅ معالجة الميديا (صورة/فيديو)
        if (req.files && req.files.media && req.files.media[0]) {
            const file = req.files.media[0];
            mediaUrl = file.path || file.secure_url || null;
            publicId = file.filename || file.public_id || null;
            mediaType = file.mimetype?.startsWith('video') ? 'video' : 'image';
        }

        // ✅ معالجة الصوت
        if (req.files && req.files.audio && req.files.audio[0]) {
            const audioFile = req.files.audio[0];
            audioUrl = audioFile.path || audioFile.secure_url || null;
            audioPublicId = audioFile.filename || audioFile.public_id || null;
            audioDuration = parseInt(req.body.audioDuration) || 0;
            
            // ✅ إذا كان هناك صوت، نحدد نوع القصة كـ 'audio'
            if (audioUrl) {
                mediaType = 'audio';
            }
        }
        
        // ✅ التحقق من وجود محتوى
        if (!mediaUrl && !audioUrl && !req.body.text) {
            return res.status(400).json({ 
                error: 'Story must have media, audio, or text content' 
            });
        }
        
        const defaultTextStyle = {
            fontSize: 32,
            fontFamily: 'Inter',
            fontWeight: '700',
            textAlign: 'center',
            position: { x: 50, y: 50 },
            rotation: 0,
            opacity: 1,
            textShadow: '0 2px 10px rgba(0,0,0,0.5)',
            background: 'transparent',
            padding: '0',
            borderRadius: '0',
            maxWidth: 90
        };
        
        let textStyleObj = defaultTextStyle;
        if (req.body.textStyle) {
            try {
                const parsed = typeof req.body.textStyle === 'string' 
                    ? JSON.parse(req.body.textStyle) 
                    : req.body.textStyle;
                textStyleObj = { ...defaultTextStyle, ...parsed };
            } catch (e) {
                console.error('Error parsing textStyle:', e);
                textStyleObj = defaultTextStyle;
            }
        }

        // ✅ إنشاء القصة مع جميع الحقول
        const story = new Story({
            userId: req.user.userId,
            media: {
                url: mediaUrl,
                publicId: publicId,
                type: mediaType
            },
            audio: {
                url: audioUrl,
                publicId: audioPublicId,
                duration: audioDuration,
                waveform: req.body.waveform ? JSON.parse(req.body.waveform) : []
            },
            filter: req.body.filter || 'none',
            filterIntensity: parseFloat(req.body.filterIntensity) || 0.5,
            filterApplied: req.body.filter && req.body.filter !== 'none',
            text: req.body.text || '',
            backgroundColor: req.body.backgroundColor || '#000000',
            textColor: req.body.textColor || '#ffffff',
            textStyle: textStyleObj,
            allowDownload: req.body.allowDownload === 'true' || req.body.allowDownload === true,
            visibility: req.body.visibility || 'followers'
        });

        await story.save();
        await notifyFollowersAboutStory(story);
        
        res.status(201).json({ 
            success: true, 
            message: 'Story created successfully',
            data: story 
        });
        
    } catch (error) {
        logger.error(`Error creating story: ${error.message}`);
        if (error.code === 'LIMIT_FILE_SIZE') {
            return res.status(400).json({ error: 'File too large. Maximum size is 50MB.' });
        }
        if (error.message && error.message.includes('Only images')) {
            return res.status(400).json({ error: error.message });
        }
        res.status(500).json({ error: 'Failed to create story: ' + error.message });
    }
});

// ============================================
// NOTIFY FOLLOWERS ABOUT STORY - إشعار المتابعين بقصة جديدة
// ============================================
async function notifyFollowersAboutStory(story) {
    try {
        // ✅ التحقق من أن الإشعار لم يُرسل بالفعل
        if (story.notificationSent) return;
        
        const userId = story.userId;
        
        // جلب المتابعين
        const followers = await Follow.find({
            followingId: userId,
            status: 'accepted'
        }).select('followerId');
        
        if (!followers.length) return;
        
        // جلب معلومات المستخدم
        const user = await User.findById(userId).select('username profile.nickname profile.avatar');
        if (!user) return;
        
        const actorName = user.profile?.nickname || user.username || 'Someone';
        const actorAvatar = user.profile?.avatar || null;
        
        // إنشاء إشعار لكل متابع
        const notifications = followers.map(f => ({
            userId: f.followerId,
            type: 'system',
            actorId: userId,
            actorName: actorName,
            actorAvatar: actorAvatar,
            targetId: userId,
            targetType: 'story',
            content: `${actorName} posted a new story 📸`,
            read: false,
            createdAt: new Date()
        }));
        
        // إدخال الإشعارات دفعة واحدة
        await Notification.insertMany(notifications);
        
        // ✅ تحديث حالة الإشعار في القصة
        story.notificationSent = true;
        await story.save();
        
        logger.info(`📸 Story notifications sent to ${notifications.length} followers`);
        
    } catch (error) {
        logger.error(`Error sending story notifications: ${error.message}`);
    }
}

// ============================================
// GET /api/stories/feed - جلب stories للمتابعين
// ============================================
app.get('/api/stories/feed', authenticateToken, async (req, res) => {
    try {
        // جلب المستخدمين الذين يتابعهم المستخدم الحالي
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        }).select('followingId');
        
        const userIds = [...following.map(f => f.followingId), req.user.userId];
        
        // جلب القصص النشطة
        const stories = await Story.find({
            userId: { $in: userIds },
            expiresAt: { $gt: new Date() },
            $or: [
                { visibility: 'public' },
                { visibility: 'followers' },
                { 
                    visibility: 'only-me', 
                    userId: req.user.userId 
                }
            ]
        })
        .sort({ createdAt: -1 })
        .populate('userId', 'username profile.nickname profile.avatar')
        .lean();
        
        // تجميع القصص حسب المستخدم
        const storiesByUser = {};
        stories.forEach(story => {
            const userId = story.userId._id.toString();
            if (!storiesByUser[userId]) {
                storiesByUser[userId] = {
                    user: story.userId,
                    stories: []
                };
            }
            // إضافة معلومات المشاهدة لكل قصة
            const hasViewed = story.views?.some(v => v.userId.toString() === req.user.userId);
            storiesByUser[userId].stories.push({
                ...story,
                hasViewed: hasViewed || false,
                viewsCount: story.views?.length || 0,
                reactionsCount: story.reactions?.length || 0
            });
        });
        
        res.json({ 
            success: true, 
            data: Object.values(storiesByUser) 
        });
        
    } catch (error) {
        logger.error(`Error fetching stories: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch stories' });
    }
});


// ============================================
// GET /api/stories/all - جلب جميع القصص (متكامل)
// ============================================
app.get('/api/stories/all', authenticateToken, async (req, res) => {
    try {
        const { limit = 20, page = 1 } = req.query;
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        // 1. جلب المستخدمين الذين يتابعهم المستخدم الحالي
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        }).select('followingId');
        
        const followingIds = following.map(f => f.followingId.toString());
        
        // 2. جلب جميع القصص النشطة (من كل المستخدمين)
        const allStories = await Story.find({
            expiresAt: { $gt: new Date() },
            $or: [
                // قصص عامة من أي مستخدم
                { visibility: 'public' },
                // قصص المتابعين
                { 
                    userId: { $in: followingIds },
                    visibility: { $in: ['public', 'followers'] }
                },
                // قصص المستخدم نفسه
                { userId: req.user.userId }
            ]
        })
        .sort({ createdAt: -1 })
        .populate('userId', 'username profile.nickname profile.avatar')
        .lean();
        
        // 3. تجميع القصص حسب المستخدم مع معلومات إضافية
        const storiesMap = {};
        const userIds = new Set();
        
        allStories.forEach(story => {
            const userId = story.userId._id.toString();
            userIds.add(userId);
            
            if (!storiesMap[userId]) {
                storiesMap[userId] = {
                    user: story.userId,
                    stories: [],
                    isFollowing: followingIds.includes(userId),
                    isCurrentUser: userId === req.user.userId
                };
            }
            
            // إضافة معلومات المشاهدة
            const hasViewed = story.views?.some(v => v.userId.toString() === req.user.userId);
            
            storiesMap[userId].stories.push({
                ...story,
                hasViewed: hasViewed || false,
                viewsCount: story.views?.length || 0,
                reactionsCount: story.reactions?.length || 0,
                isFollowing: followingIds.includes(userId),
                isCurrentUser: userId === req.user.userId
            });
        });
        
        // 4. ترتيب المجموعات (المتابعين أولاً، ثم الباقي)
        const sortedGroups = Object.values(storiesMap).sort((a, b) => {
            // المتابعين أولاً
            if (a.isFollowing && !b.isFollowing) return -1;
            if (!a.isFollowing && b.isFollowing) return 1;
            // المستخدم الحالي في البداية
            if (a.isCurrentUser && !b.isCurrentUser) return -1;
            if (!a.isCurrentUser && b.isCurrentUser) return 1;
            // عدد القصص الأحدث
            return b.stories.length - a.stories.length;
        });
        
        // 5. تطبيق Pagination
        const paginatedData = sortedGroups.slice(skip, skip + parseInt(limit));
        const total = sortedGroups.length;
        
        // 6. إحصائيات إضافية
        const totalStories = allStories.length;
        const totalUsers = userIds.size;
        const followingStories = allStories.filter(s => 
            followingIds.includes(s.userId._id.toString())
        ).length;
        const otherStories = totalStories - followingStories;
        
        res.json({
            success: true,
            data: paginatedData,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            },
            stats: {
                totalStories,
                totalUsers,
                followingStories,
                otherStories,
                followingCount: followingIds.length
            }
        });
        
    } catch (error) {
        logger.error(`Error fetching all stories: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch stories' });
    }
});


// ============================================
// GET /api/stories/discover - اكتشاف قصص جديدة
// ============================================
app.get('/api/stories/discover', authenticateToken, async (req, res) => {
    try {
        const { limit = 10 } = req.query;
        
        // 1. جلب المستخدمين الذين يتابعهم المستخدم الحالي
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        }).select('followingId');
        
        const followingIds = following.map(f => f.followingId);
        followingIds.push(req.user.userId); // استثناء المستخدم نفسه
        
        // 2. جلب القصص العامة من مستخدمين غير متابعين
        const discoverStories = await Story.find({
            userId: { $nin: followingIds },
            visibility: 'public',
            expiresAt: { $gt: new Date() }
        })
        .sort({ createdAt: -1 })
        .limit(parseInt(limit))
        .populate('userId', 'username profile.nickname profile.avatar')
        .lean();
        
        // 3. تجميع حسب المستخدم
        const storiesByUser = {};
        discoverStories.forEach(story => {
            const userId = story.userId._id.toString();
            if (!storiesByUser[userId]) {
                storiesByUser[userId] = {
                    user: story.userId,
                    stories: [],
                    isFollowing: false
                };
            }
            
            const hasViewed = story.views?.some(v => v.userId.toString() === req.user.userId);
            storiesByUser[userId].stories.push({
                ...story,
                hasViewed: hasViewed || false,
                viewsCount: story.views?.length || 0,
                isFollowing: false
            });
        });
        
        res.json({
            success: true,
            data: Object.values(storiesByUser),
            count: Object.keys(storiesByUser).length
        });
        
    } catch (error) {
        logger.error(`Error discovering stories: ${error.message}`);
        res.status(500).json({ error: 'Failed to discover stories' });
    }
});

// ============================================
// GET /api/stories/stats - إحصائيات القصص
// ============================================
app.get('/api/stories/stats', authenticateToken, async (req, res) => {
    try {
        // 1. جلب المستخدمين الذين يتابعهم المستخدم الحالي
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        }).select('followingId');
        
        const followingIds = following.map(f => f.followingId);
        followingIds.push(req.user.userId);
        
        // 2. إحصائيات القصص
        const [
            totalStories,
            myStories,
            followingStories,
            discoverStories,
            mostViewedStories,
            recentStories
        ] = await Promise.all([
            // إجمالي القصص النشطة
            Story.countDocuments({
                expiresAt: { $gt: new Date() },
                visibility: 'public'
            }),
            
            // قصصي
            Story.countDocuments({
                userId: req.user.userId,
                expiresAt: { $gt: new Date() }
            }),
            
            // قصص المتابعين
            Story.countDocuments({
                userId: { $in: followingIds },
                expiresAt: { $gt: new Date() },
                visibility: { $in: ['public', 'followers'] }
            }),
            
            // قصص للاكتشاف (غير متابعين)
            Story.countDocuments({
                userId: { $nin: followingIds },
                expiresAt: { $gt: new Date() },
                visibility: 'public'
            }),
            
            // أكثر القصص مشاهدة
            Story.find({
                expiresAt: { $gt: new Date() },
                visibility: 'public'
            })
            .sort({ 'views': -1 })
            .limit(5)
            .populate('userId', 'username profile.nickname profile.avatar')
            .lean(),
            
            // أحدث القصص
            Story.find({
                expiresAt: { $gt: new Date() },
                visibility: 'public'
            })
            .sort({ createdAt: -1 })
            .limit(5)
            .populate('userId', 'username profile.nickname profile.avatar')
            .lean()
        ]);
        
        res.json({
            success: true,
            stats: {
                totalStories,
                myStories,
                followingStories,
                discoverStories,
                followingCount: followingIds.length - 1 // استبعاد المستخدم نفسه
            },
            trending: mostViewedStories.map(s => ({
                _id: s._id,
                user: s.userId,
                viewsCount: s.views?.length || 0,
                createdAt: s.createdAt
            })),
            recent: recentStories.map(s => ({
                _id: s._id,
                user: s.userId,
                viewsCount: s.views?.length || 0,
                createdAt: s.createdAt
            }))
        });
        
    } catch (error) {
        logger.error(`Error fetching story stats: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch story stats' });
    }
});


// ============================================
// DELETE /api/stories/expired - حذف القصص المنتهية
// ============================================
app.delete('/api/stories/expired', authenticateToken, async (req, res) => {
    try {
        // فقط الأدمن يمكنه تنفيذ هذا
        const user = await User.findById(req.user.userId);
        if (!user || !user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized' });
        }
        
        const expiredStories = await Story.find({
            expiresAt: { $lt: new Date() }
        });
        
        // حذف الميديا من Cloudinary
        for (const story of expiredStories) {
            if (story.media?.publicId) {
                try {
                    await cloudinary.uploader.destroy(story.media.publicId);
                } catch (err) {
                    logger.warn(`Failed to delete media: ${err.message}`);
                }
            }
        }
        
        const result = await Story.deleteMany({
            expiresAt: { $lt: new Date() }
        });
        
        res.json({
            success: true,
            message: `Deleted ${result.deletedCount} expired stories`,
            deletedCount: result.deletedCount
        });
        
    } catch (error) {
        logger.error(`Error deleting expired stories: ${error.message}`);
        res.status(500).json({ error: 'Failed to delete expired stories' });
    }
});


// ============================================
// GET /api/stories/user/:userId - جلب قصص مستخدم معين
// ============================================
app.get('/api/stories/user/:userId', authenticateToken, async (req, res) => {
    try {
        const { userId } = req.params;
        
        // التحقق من صحة الـ ID
        if (!mongoose.Types.ObjectId.isValid(userId)) {
            return res.status(400).json({ error: 'Invalid user ID' });
        }
        
        // التحقق من أن المستخدم موجود
        const targetUser = await User.findById(userId);
        if (!targetUser) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        // التحقق من الصلاحية (إذا كانت القصة خاصة)
        const isOwner = userId === req.user.userId;
        const isFollowing = await Follow.exists({
            followerId: req.user.userId,
            followingId: userId,
            status: 'accepted'
        });
        
        // بناء استعلام الرؤية
        let visibilityQuery = {
            userId: userId,
            expiresAt: { $gt: new Date() }
        };
        
        if (!isOwner) {
            visibilityQuery.$or = [
                { visibility: 'public' },
                { 
                    visibility: 'followers',
                    $and: [{ userId: userId }]
                }
            ];
            
            // إذا كان المستخدم لا يتابع، فقط القصص العامة
            if (!isFollowing) {
                visibilityQuery.visibility = 'public';
            }
        }
        
        const stories = await Story.find(visibilityQuery)
            .sort({ createdAt: -1 })
            .populate('userId', 'username profile.nickname profile.avatar')
            .lean();
        
        // إضافة معلومات المشاهدة
        const enrichedStories = stories.map(story => ({
            ...story,
            hasViewed: story.views?.some(v => v.userId.toString() === req.user.userId) || false,
            viewsCount: story.views?.length || 0,
            reactionsCount: story.reactions?.length || 0
        }));
        
        res.json({
            success: true,
            data: enrichedStories,
            count: enrichedStories.length
        });
        
    } catch (error) {
        logger.error(`Error fetching user stories: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch stories' });
    }
});

// ============================================
// POST /api/stories/:storyId/view - تسجيل مشاهدة
// ============================================
app.post('/api/stories/:storyId/view', authenticateToken, async (req, res) => {
    try {
        const story = await Story.findById(req.params.storyId);
        if (!story) {
            return res.status(404).json({ error: 'Story not found' });
        }
        
        // التحقق من أن القصة لم تنتهي
        if (story.isExpired()) {
            return res.status(400).json({ error: 'Story has expired' });
        }
        
        // منع تسجيل المشاهدة لنفس المستخدم
        if (story.userId.toString() === req.user.userId) {
            return res.json({ 
                success: true, 
                viewsCount: story.views.length,
                message: 'You cannot view your own story'
            });
        }
        
        const hasViewed = story.views.some(v => v.userId.toString() === req.user.userId);
        
        if (!hasViewed) {
            story.views.push({ 
                userId: req.user.userId,
                viewedAt: new Date()
            });
            await story.save();
        }
        
        res.json({ 
            success: true, 
            viewsCount: story.views.length,
            hasViewed: true
        });
        
    } catch (error) {
        logger.error(`Error recording story view: ${error.message}`);
        res.status(500).json({ error: 'Failed to record view' });
    }
});


// ============================================
// POST /api/stories/:storyId/reaction - إضافة تفاعل
// ============================================
app.post('/api/stories/:storyId/reaction', authenticateToken, [
    body('type').isIn(['❤️', '😂', '😮', '😢', '😡'])
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const story = await Story.findById(req.params.storyId);
        if (!story) {
            return res.status(404).json({ error: 'Story not found' });
        }
        
        if (story.isExpired()) {
            return res.status(400).json({ error: 'Story has expired' });
        }
        
        const { type } = req.body;
        const userId = req.user.userId;
        
        // التحقق من وجود تفاعل سابق
        const existingReaction = story.reactions.find(
            r => r.userId.toString() === userId
        );
        
        if (existingReaction) {
            // تحديث التفاعل الموجود
            existingReaction.type = type;
            existingReaction.createdAt = new Date();
        } else {
            // إضافة تفاعل جديد
            story.reactions.push({
                userId: userId,
                type: type,
                createdAt: new Date()
            });
        }
        
        await story.save();
        
        res.json({
            success: true,
            message: 'Reaction added successfully',
            reactionsCount: story.reactions.length,
            reaction: type
        });
        
    } catch (error) {
        logger.error(`Error adding reaction: ${error.message}`);
        res.status(500).json({ error: 'Failed to add reaction' });
    }
});

// ============================================
// DELETE /api/stories/:storyId - حذف قصة
// ============================================
app.delete('/api/stories/:storyId', authenticateToken, async (req, res) => {
    try {
        const story = await Story.findById(req.params.storyId);
        if (!story) {
            return res.status(404).json({ error: 'Story not found' });
        }
        
        // التحقق من أن المستخدم هو صاحب القصة
        if (story.userId.toString() !== req.user.userId) {
            return res.status(403).json({ error: 'Unauthorized to delete this story' });
        }
        
        // حذف الميديا من Cloudinary إذا وجدت
        if (story.media?.publicId) {
            try {
                await cloudinary.uploader.destroy(story.media.publicId);
            } catch (cloudinaryError) {
                logger.warn(`Failed to delete story media: ${cloudinaryError.message}`);
            }
        }
        
        await story.deleteOne();
        
        res.json({
            success: true,
            message: 'Story deleted successfully'
        });
        
    } catch (error) {
        logger.error(`Error deleting story: ${error.message}`);
        res.status(500).json({ error: 'Failed to delete story' });
    }
});


// ============================================
// JOBS SYSTEM - COMPLETE ENDPOINTS
// ============================================



// ---------- JOB CATEGORIES ----------

// ============================================
// GET /api/jobs/categories - جلب التصنيفات (متعدد اللغات)
// ============================================
app.get('/api/jobs/categories', async (req, res) => {
    try {
        const { lang = 'en' } = req.query; // 'en' or 'ar'
        
        let categories = await JobCategory.find({ isActive: true }).sort({ order: 1 });
        
        // إذا لم توجد تصنيفات، أنشئ التصنيفات الافتراضية
        if (categories.length === 0) {
            const defaultCategories = [
                { name: 'Technology', nameAr: 'تكنولوجيا المعلومات', icon: 'bx-code-alt', color: '#3b82f6', order: 1 },
                { name: 'Design', nameAr: 'تصميم', icon: 'bx-palette', color: '#8b5cf6', order: 2 },
                { name: 'Marketing', nameAr: 'تسويق', icon: 'bx-line-chart', color: '#10b981', order: 3 },
                { name: 'Sales', nameAr: 'مبيعات', icon: 'bx-trending-up', color: '#f59e0b', order: 4 },
                { name: 'Customer Service', nameAr: 'خدمة عملاء', icon: 'bx-headphone', color: '#ef4444', order: 5 },
                { name: 'Finance', nameAr: 'مالية', icon: 'bx-dollar-circle', color: '#14b8a6', order: 6 },
                { name: 'Human Resources', nameAr: 'موارد بشرية', icon: 'bx-group', color: '#8b5cf6', order: 7 },
                { name: 'Education', nameAr: 'تعليم', icon: 'bx-book-open', color: '#06b6d4', order: 8 },
                { name: 'Healthcare', nameAr: 'رعاية صحية', icon: 'bx-heart', color: '#ec4899', order: 9 },
                { name: 'Legal', nameAr: 'قانون', icon: 'bx-gavel', color: '#6b7280', order: 10 },
                { name: 'Consulting', nameAr: 'استشارات', icon: 'bx-bulb', color: '#8b5cf6', order: 11 },
                { name: 'Other', nameAr: 'أخرى', icon: 'bx-briefcase', color: '#6b7280', order: 12 }
            ];
            
            categories = await JobCategory.insertMany(defaultCategories);
        }
        
        // جلب عدد الوظائف لكل تصنيف
        const categoriesWithStats = await Promise.all(categories.map(async (cat) => {
            const count = await Job.countDocuments({ 
                category: cat.name, 
                status: 'active',
                deadline: { $gt: new Date() }
            });
            
            // اختيار الاسم والوصف حسب اللغة
            const displayName = lang === 'ar' ? (cat.nameAr || cat.name) : cat.name;
            
            return {
                _id: cat._id,
                name: cat.name,
                nameAr: cat.nameAr,
                displayName: displayName,
                icon: cat.icon || 'bx-briefcase',
                color: cat.color || '#6b7280',
                order: cat.order,
                isActive: cat.isActive,
                count: count,
                // روابط مفيدة
                links: {
                    jobs: `/jobs.html?category=${encodeURIComponent(cat.name)}`,
                    search: `/search.html?type=jobs&filter=${encodeURIComponent(cat.name)}`
                }
            };
        }));
        
        // ترتيب حسب العدد (الأكثر طلباً أولاً) أو حسب الترتيب المحدد
        const sortedCategories = categoriesWithStats.sort((a, b) => {
            if (a.order !== b.order) return a.order - b.order;
            return b.count - a.count;
        });
        
        // إحصائيات عامة
        const totalJobs = await Job.countDocuments({ status: 'active', deadline: { $gt: new Date() } });
        
        res.json({
            success: true,
            data: sortedCategories,
            meta: {
                totalJobs,
                totalCategories: sortedCategories.length,
                lang
            }
        });
        
    } catch (error) {
        logger.error(`Error fetching categories: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch categories' });
    }
});



// ============================================
// ADMIN: POST /api/admin/jobs/categories - إضافة تصنيف جديد
// ============================================
app.post('/api/admin/jobs/categories', authenticateToken, isAdmin, [
    body('name').notEmpty().withMessage('Category name is required'),
    body('nameAr').optional(),
    body('icon').optional(),
    body('color').optional().matches(/^#[0-9A-Fa-f]{6}$/),
    body('order').optional().isInt({ min: 0 })
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const { name, nameAr, icon, color, order } = req.body;
        
        // التحقق من عدم وجود التصنيف مسبقاً
        const existingCategory = await JobCategory.findOne({ name });
        if (existingCategory) {
            return res.status(400).json({ error: 'Category already exists' });
        }
        
        const category = new JobCategory({
            name,
            nameAr: nameAr || '',
            icon: icon || 'bx-briefcase',
            color: color || '#6b7280',
            order: order || 0,
            isActive: true
        });
        
        await category.save();
        
        logger.info(`Admin ${req.user.userId} created category: ${name}`);
        res.status(201).json({ success: true, data: category });
        
    } catch (error) {
        logger.error(`Error creating category: ${error.message}`);
        res.status(500).json({ error: 'Failed to create category' });
    }
});

// ============================================
// ADMIN: PUT /api/admin/jobs/categories/:categoryId - تحديث تصنيف
// ============================================
app.put('/api/admin/jobs/categories/:categoryId', authenticateToken, isAdmin, async (req, res) => {
    try {
        const { categoryId } = req.params;
        const { name, nameAr, icon, color, order, isActive } = req.body;
        
        const category = await JobCategory.findById(categoryId);
        if (!category) {
            return res.status(404).json({ error: 'Category not found' });
        }
        
        if (name) category.name = name;
        if (nameAr !== undefined) category.nameAr = nameAr;
        if (icon) category.icon = icon;
        if (color) category.color = color;
        if (order !== undefined) category.order = order;
        if (isActive !== undefined) category.isActive = isActive;
        
        await category.save();
        
        logger.info(`Admin ${req.user.userId} updated category: ${category.name}`);
        res.json({ success: true, data: category });
        
    } catch (error) {
        logger.error(`Error updating category: ${error.message}`);
        res.status(500).json({ error: 'Failed to update category' });
    }
});

// ============================================
// ADMIN: DELETE /api/admin/jobs/categories/:categoryId - حذف تصنيف
// ============================================
app.delete('/api/admin/jobs/categories/:categoryId', authenticateToken, isAdmin, async (req, res) => {
    try {
        const { categoryId } = req.params;
        
        const category = await JobCategory.findById(categoryId);
        if (!category) {
            return res.status(404).json({ error: 'Category not found' });
        }
        
        // التحقق من وجود وظائف بهذا التصنيف
        const jobsCount = await Job.countDocuments({ category: category.name });
        if (jobsCount > 0) {
            return res.status(400).json({ 
                error: `Cannot delete category with ${jobsCount} jobs. Move or delete jobs first.` 
            });
        }
        
        await category.deleteOne();
        
        logger.info(`Admin ${req.user.userId} deleted category: ${category.name}`);
        res.json({ success: true, message: 'Category deleted successfully' });
        
    } catch (error) {
        logger.error(`Error deleting category: ${error.message}`);
        res.status(500).json({ error: 'Failed to delete category' });
    }
});

// ============================================
// GET /api/jobs/categories/stats - إحصائيات التصنيفات
// ============================================
app.get('/api/jobs/categories/stats', async (req, res) => {
    try {
        const categoryStats = await Job.aggregate([
            { $match: { status: 'active', deadline: { $gt: new Date() } } },
            { $group: { _id: '$category', count: { $sum: 1 } } },
            { $sort: { count: -1 } },
            { $limit: 10 }
        ]);
        
        // جلب أسماء التصنيفات بالعربية
        const categoriesWithNames = await Promise.all(categoryStats.map(async (stat) => {
            const category = await JobCategory.findOne({ name: stat._id });
            return {
                name: stat._id,
                nameAr: category?.nameAr || stat._id,
                icon: category?.icon || 'bx-briefcase',
                color: category?.color || '#6b7280',
                count: stat.count
            };
        }));
        
        res.json({
            success: true,
            data: categoriesWithNames,
            totalActiveJobs: await Job.countDocuments({ status: 'active', deadline: { $gt: new Date() } })
        });
        
    } catch (error) {
        logger.error(`Error fetching category stats: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch category stats' });
    }
});




// ---------- JOB POSTINGS (إنشاء وإدارة الوظائف) ----------

// POST /api/jobs - إنشاء وظيفة جديدة
app.post('/api/jobs', authenticateToken, [
    body('title').notEmpty().withMessage('Job title is required'),
    body('description').notEmpty().withMessage('Job description is required'),
    body('requirements').notEmpty().withMessage('Job requirements are required'),
    body('category').notEmpty().withMessage('Category is required'),
    body('jobType').notEmpty().withMessage('Job type is required'),
    body('experienceLevel').notEmpty().withMessage('Experience level is required'),
    body('location').notEmpty().withMessage('Location is required'),
    body('deadline').isISO8601().withMessage('Valid deadline date is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const user = await User.findById(req.user.userId);
        
        const jobData = {
            ...req.body,
            employerId: req.user.userId,
            companyName: req.body.companyName || user.profile?.portfolioName || user.username,
            companyLogo: req.body.companyLogo || user.profile?.avatar
        };
        
        const job = new Job(jobData);
        await job.save();
        
        // Create notification for job post
        await Notification.create({
            userId: req.user.userId,
            type: 'system',
            content: `Your job "${job.title}" has been posted successfully!`,
            targetId: job._id,
            targetType: 'job'
        });
        
        res.status(201).json({ success: true, data: job });
    } catch (error) {
        logger.error(`Error creating job: ${error.message}`);
        res.status(500).json({ error: 'Failed to create job' });
    }
});

// GET /api/jobs - جلب الوظائف (مع فلترة وبحث)
app.get('/api/jobs', async (req, res) => {
    try {
        const {
            page = 1,
            limit = 20,
            search,
            category,
            jobType,
            experienceLevel,
            location,
            isRemote,
            salaryMin,
            salaryMax,
            sortBy = 'latest'
        } = req.query;
        
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        let query = { status: 'active', deadline: { $gt: new Date() } };
        
        // Search
        if (search) {
            query.$text = { $search: search };
        }
        
        // Filters
        if (category) query.category = category;
        if (jobType) query.jobType = jobType;
        if (experienceLevel) query.experienceLevel = experienceLevel;
        if (location) query.location = { $regex: location, $options: 'i' };
        if (isRemote === 'true') query.isRemote = true;
        if (salaryMin) query.salaryMin = { $gte: parseInt(salaryMin) };
        if (salaryMax) query.salaryMax = { $lte: parseInt(salaryMax) };
        
        // Sorting
        let sort = {};
        switch (sortBy) {
            case 'latest':
                sort = { postedAt: -1 };
                break;
            case 'oldest':
                sort = { postedAt: 1 };
                break;
            case 'salary-high':
                sort = { salaryMax: -1 };
                break;
            case 'salary-low':
                sort = { salaryMin: 1 };
                break;
            case 'deadline':
                sort = { deadline: 1 };
                break;
            default:
                sort = { postedAt: -1 };
        }
        
        // First get featured jobs
        let featuredJobs = [];
        if (parseInt(page) === 1) {
            featuredJobs = await Job.find({
                ...query,
                isFeatured: true,
                featuredUntil: { $gt: new Date() }
            })
            .sort({ postedAt: -1 })
            .limit(3)
            .populate('employerId', 'username profile.nickname profile.avatar')
            .lean();
        }
        
        // Get regular jobs
        const jobs = await Job.find(query)
            .sort(sort)
            .skip(skip)
            .limit(parseInt(limit))
            .populate('employerId', 'username profile.nickname profile.avatar')
            .lean();
        
        // Check if user has applied to these jobs
        let userApplications = [];
        if (req.headers.authorization) {
            try {
                const token = req.headers.authorization.split(' ')[1];
                const payload = jwt.verify(token, JWT_SECRET);
                userApplications = await JobApplication.find({
                    applicantId: payload.userId,
                    jobId: { $in: jobs.map(j => j._id) }
                }).select('jobId status');
            } catch (e) {}
        }
        
        const appliedMap = new Map(userApplications.map(a => [a.jobId.toString(), a.status]));
        
        const enrichedJobs = jobs.map(job => ({
            ...job,
            hasApplied: appliedMap.has(job._id.toString()),
            applicationStatus: appliedMap.get(job._id.toString()) || null
        }));
        
        const total = await Job.countDocuments(query);
        
        res.json({
            success: true,
            featured: featuredJobs,
            data: enrichedJobs,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
    } catch (error) {
        logger.error(`Error fetching jobs: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch jobs' });
    }
});

// GET /api/jobs/my - جلب وظائفي (اللي أنا نشرتها)
app.get('/api/jobs/my', authenticateToken, async (req, res) => {
    try {
        const { page = 1, limit = 20, status } = req.query;
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        let query = { employerId: req.user.userId };
        if (status) query.status = status;
        
        const jobs = await Job.find(query)
            .sort({ postedAt: -1 })
            .skip(skip)
            .limit(parseInt(limit))
            .lean();
        
        // Get application counts for each job
        const jobsWithStats = await Promise.all(jobs.map(async (job) => {
            const applicationsCount = await JobApplication.countDocuments({ jobId: job._id });
            const pendingCount = await JobApplication.countDocuments({ jobId: job._id, status: 'pending' });
            
            return {
                ...job,
                applicationsCount,
                pendingCount
            };
        }));
        
        const total = await Job.countDocuments(query);
        
        res.json({
            success: true,
            data: jobsWithStats,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
    } catch (error) {
        logger.error(`Error fetching my jobs: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch your jobs' });
    }
});

// GET /api/jobs/my/applications - كل التقديمات على وظائفي
// GET /api/jobs/my/applications - كل التقديمات على وظائفي
app.get('/api/jobs/my/applications', authenticateToken, async (req, res) => {
    try {
        const { page = 1, limit = 20, status } = req.query;
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        // ✅ التحقق من وجود userId
        const employerId = req.user.userId;
        if (!employerId) {
            return res.status(401).json({ error: 'Unauthorized: User ID not found' });
        }
        
        // Get user's jobs
        const userJobs = await Job.find({ employerId: employerId }).select('_id');
        const jobIds = userJobs.map(j => j._id);
        
        // ✅ إذا لم يكن لدى المستخدم وظائف، أرجع مصفوفة فارغة فوراً
        if (jobIds.length === 0) {
            return res.json({
                success: true,
                data: [],
                pagination: {
                    page: parseInt(page),
                    limit: parseInt(limit),
                    total: 0,
                    pages: 0
                }
            });
        }
        
        let query = { jobId: { $in: jobIds } };
        if (status && status !== 'all') {
            query.status = status;
        }
        
        // ✅ استخدم try-catch منفصل للـ populate
        let applications = [];
        try {
            applications = await JobApplication.find(query)
                .sort({ appliedAt: -1 })
                .skip(skip)
                .limit(parseInt(limit))
                .populate('jobId', 'title companyName location salaryMin salaryMax')
                .lean();
        } catch (populateError) {
            console.error('Populate error:', populateError.message);
            // Fallback: جلب بدون populate
            applications = await JobApplication.find(query)
                .sort({ appliedAt: -1 })
                .skip(skip)
                .limit(parseInt(limit))
                .lean();
        }
        
        const total = await JobApplication.countDocuments(query);
        
        res.json({
            success: true,
            data: applications,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total: total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
        
    } catch (error) {
        console.error('Error in /api/jobs/my/applications:', error);
        logger.error(`Error fetching my applications: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch applications: ' + error.message });
    }
});

// GET /api/jobs/:jobId - جلب تفاصيل وظيفة
app.get('/api/jobs/:jobId', async (req, res) => {
    try {
        const job = await Job.findById(req.params.jobId)
            .populate('employerId', 'username profile.nickname profile.avatar profile.bio profile.phone')
            .lean();
        
        if (!job) {
            return res.status(404).json({ error: 'Job not found' });
        }
        
        // Increment view count
        await Job.findByIdAndUpdate(req.params.jobId, { $inc: { views: 1 } });
        
        // Check if user has applied
        let hasApplied = false;
        let applicationStatus = null;
        let myApplication = null;
        
        if (req.headers.authorization) {
            try {
                const token = req.headers.authorization.split(' ')[1];
                const payload = jwt.verify(token, JWT_SECRET);
                const application = await JobApplication.findOne({
                    jobId: job._id,
                    applicantId: payload.userId
                });
                if (application) {
                    hasApplied = true;
                    applicationStatus = application.status;
                    myApplication = application;
                }
            } catch (e) {}
        }
        
        // Check if saved
        let isSaved = false;
        if (req.headers.authorization) {
            try {
                const token = req.headers.authorization.split(' ')[1];
                const payload = jwt.verify(token, JWT_SECRET);
                const saved = await JobSave.findOne({
                    jobId: job._id,
                    userId: payload.userId
                });
                isSaved = !!saved;
            } catch (e) {}
        }
        
        res.json({
            success: true,
            data: {
                ...job,
                hasApplied,
                applicationStatus,
                myApplication,
                isSaved
            }
        });
    } catch (error) {
        logger.error(`Error fetching job: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch job' });
    }
});

// PUT /api/jobs/:jobId - تحديث وظيفة
app.put('/api/jobs/:jobId', authenticateToken, async (req, res) => {
    try {
        const job = await Job.findById(req.params.jobId);
        
        if (!job) {
            return res.status(404).json({ error: 'Job not found' });
        }
        
        if (job.employerId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized to update this job' });
        }
        
        const allowedUpdates = [
            'title', 'description', 'requirements', 'responsibilities',
            'category', 'jobType', 'experienceLevel', 'location', 'isRemote',
            'salaryMin', 'salaryMax', 'salaryCurrency', 'isSalaryNegotiable',
            'requiredSkills', 'educationLevel', 'vacancies', 'deadline', 'status'
        ];
        
        allowedUpdates.forEach(field => {
            if (req.body[field] !== undefined) {
                job[field] = req.body[field];
            }
        });
        
        await job.save();
        
        res.json({ success: true, data: job });
    } catch (error) {
        logger.error(`Error updating job: ${error.message}`);
        res.status(500).json({ error: 'Failed to update job' });
    }
});

// DELETE /api/jobs/:jobId - حذف وظيفة
app.delete('/api/jobs/:jobId', authenticateToken, async (req, res) => {
    try {
        const job = await Job.findById(req.params.jobId);
        
        if (!job) {
            return res.status(404).json({ error: 'Job not found' });
        }
        
        if (job.employerId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized to delete this job' });
        }
        
        // Delete all applications for this job
        await JobApplication.deleteMany({ jobId: job._id });
        await JobSave.deleteMany({ jobId: job._id });
        
        await job.deleteOne();
        
        res.json({ success: true, message: 'Job deleted successfully' });
    } catch (error) {
        logger.error(`Error deleting job: ${error.message}`);
        res.status(500).json({ error: 'Failed to delete job' });
    }
});

// ---------- JOB APPLICATIONS (التقديم على الوظائف) ----------

// POST /api/jobs/:jobId/apply - التقديم على وظيفة
app.post('/api/jobs/:jobId/apply', authenticateToken, upload.single('resume'), [
    body('fullName').notEmpty().withMessage('Full name is required'),
    body('email').isEmail().withMessage('Valid email is required'),
    body('phone').optional(),
    body('coverLetter').optional(),
    body('portfolio').optional().isURL(),
    body('linkedin').optional().isURL(),
    body('github').optional().isURL()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const job = await Job.findById(req.params.jobId);
        if (!job) {
            return res.status(404).json({ error: 'Job not found' });
        }
        
        if (job.status !== 'active' || job.deadline < new Date()) {
            return res.status(400).json({ error: 'This job is no longer accepting applications' });
        }
        
        // Check for duplicate application
        const existingApplication = await JobApplication.findOne({
            jobId: job._id,
            applicantId: req.user.userId
        });
        
        if (existingApplication) {
            return res.status(400).json({ error: 'You have already applied for this job' });
        }
        
        let resumeData = null;
        if (req.file) {
            resumeData = {
                url: req.file.path,
                publicId: req.file.filename,
                fileName: req.file.originalname
            };
        }
        
        const application = new JobApplication({
            jobId: job._id,
            applicantId: req.user.userId,
            fullName: req.body.fullName,
            email: req.body.email,
            phone: req.body.phone,
            resume: resumeData,
            coverLetter: req.body.coverLetter,
            portfolio: req.body.portfolio,
            linkedin: req.body.linkedin,
            github: req.body.github,
            answers: req.body.answers || []
        });
        
        await application.save();
        
        // Update job applications count
        await Job.findByIdAndUpdate(job._id, { $inc: { applicationsCount: 1 } });
        
        // Notification to job owner
        const applicant = await User.findById(req.user.userId);
        await Notification.create({
            userId: job.employerId,
            type: 'system',
            content: `New application from ${applicant.profile?.nickname || applicant.username} for "${job.title}"`,
            targetId: application._id,
            targetType: 'application'
        });
        
        // Email notification to job owner (using Brevo)
        const employer = await User.findById(job.employerId);
        if (employer && employer.email) {
            try {
                await sendEmailWithBrevo(
                    employer.email,
                    `New Job Application: ${job.title}`,
                    `<div style="font-family: Arial, sans-serif;">
                        <h2>New Application Received</h2>
                        <p><strong>Position:</strong> ${job.title}</p>
                        <p><strong>Applicant:</strong> ${req.body.fullName}</p>
                        <p><strong>Email:</strong> ${req.body.email}</p>
                        <p><strong>Phone:</strong> ${req.body.phone || 'Not provided'}</p>
                        <a href="${FRONTEND_URL}/jobs/applications/${application._id}" style="background: #3b82f6; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px;">View Application</a>
                    </div>`,
                    `New application for ${job.title} from ${req.body.fullName}`
                );
            } catch (emailError) {
                logger.error(`Failed to send application email: ${emailError.message}`);
            }
        }
        
        res.status(201).json({ success: true, message: 'Application submitted successfully', data: application });
    } catch (error) {
        logger.error(`Error applying for job: ${error.message}`);
        res.status(500).json({ error: 'Failed to submit application' });
    }
});

// GET /api/jobs/applications/my - طلبات التقديم الخاصة بي (كـ متقدم)
app.get('/api/jobs/applications/my', authenticateToken, async (req, res) => {
    try {
        const { page = 1, limit = 20, status } = req.query;
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        let query = { applicantId: req.user.userId };
        if (status) query.status = status;
        
        const applications = await JobApplication.find(query)
            .sort({ appliedAt: -1 })
            .skip(skip)
            .limit(parseInt(limit))
            .populate('jobId', 'title companyName location jobType salaryMin salaryMax deadline status')
            .lean();
        
        const total = await JobApplication.countDocuments(query);
        
        res.json({
            success: true,
            data: applications,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
    } catch (error) {
        logger.error(`Error fetching my applications: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch applications' });
    }
});


// ============================================
// POST /api/jobs/applications/:applicationId/withdraw - سحب طلب التقديم
// ============================================
app.post('/api/jobs/applications/:applicationId/withdraw', authenticateToken, async (req, res) => {
    try {
        const { applicationId } = req.params;
        
        const application = await JobApplication.findById(applicationId);
        
        if (!application) {
            return res.status(404).json({ error: 'Application not found' });
        }
        
        // التحقق من صلاحية المستخدم (صاحب الطلب فقط)
        if (application.applicantId.toString() !== req.user.userId) {
            return res.status(403).json({ error: 'Unauthorized to withdraw this application' });
        }
        
        // التحقق من أن الحالة تسمح بالسحب
        if (application.status !== 'pending') {
            return res.status(400).json({ error: `Cannot withdraw application with status: ${application.status}` });
        }
        
        // تحديث الحالة
        application.status = 'withdrawn';
        application.updatedAt = new Date();
        await application.save();
        
        // إشعار لصاحب الوظيفة (اختياري)
        const job = await Job.findById(application.jobId);
        if (job && job.employerId.toString() !== req.user.userId) {
            await Notification.create({
                userId: job.employerId,
                type: 'application',
                actorId: req.user.userId,
                targetId: application._id,
                targetType: 'job_application',
                content: `withdrew their application for "${job.title}"`,
                read: false
            });
        }
        
        logger.info(`Application ${applicationId} withdrawn by user ${req.user.userId}`);
        
        res.json({ 
            success: true, 
            message: 'Application withdrawn successfully',
            data: application
        });
        
    } catch (error) {
        logger.error(`Error withdrawing application: ${error.message}`);
        res.status(500).json({ error: 'Failed to withdraw application' });
    }
});
// GET /api/jobs/:jobId/applications - جلب المتقدمين لوظيفة (لصاحب الوظيفة فقط)
app.get('/api/jobs/:jobId/applications', authenticateToken, async (req, res) => {
    try {
        const job = await Job.findById(req.params.jobId);
        
        if (!job) {
            return res.status(404).json({ error: 'Job not found' });
        }
        
        if (job.employerId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized to view applications for this job' });
        }
        
        const { page = 1, limit = 20, status } = req.query;
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        let query = { jobId: job._id };
        if (status) query.status = status;
        
        const applications = await JobApplication.find(query)
            .sort({ appliedAt: -1 })
            .skip(skip)
            .limit(parseInt(limit))
            .populate('applicantId', 'username profile.nickname profile.avatar profile.bio profile.skills')
            .lean();
        
        const total = await JobApplication.countDocuments(query);
        
        res.json({
            success: true,
            data: applications,
            job: { title: job.title, companyName: job.companyName },
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
    } catch (error) {
        logger.error(`Error fetching applications: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch applications' });
    }
});

// GET /api/jobs/applications/:applicationId - تفاصيل تقديم معين
app.get('/api/jobs/applications/:applicationId', authenticateToken, async (req, res) => {
    try {
        const application = await JobApplication.findById(req.params.applicationId)
            .populate('jobId')
            .populate('applicantId', 'username profile.nickname profile.avatar profile.bio profile.skills profile.education profile.experience')
            .lean();
        
        if (!application) {
            return res.status(404).json({ error: 'Application not found' });
        }
        
        // Check permission
        const isOwner = application.applicantId._id.toString() === req.user.userId;
        const isEmployer = application.jobId.employerId.toString() === req.user.userId;
        
        if (!isOwner && !isEmployer && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized to view this application' });
        }
        
        res.json({ success: true, data: application });
    } catch (error) {
        logger.error(`Error fetching application: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch application' });
    }
});

// PUT /api/jobs/applications/:applicationId/status - تحديث حالة التقديم
app.put('/api/jobs/applications/:applicationId/status', authenticateToken, [
    body('status').isIn(['pending', 'reviewed', 'shortlisted', 'interview', 'accepted', 'rejected']),
    body('employerNotes').optional()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const application = await JobApplication.findById(req.params.applicationId)
            .populate('jobId');
        
        if (!application) {
            return res.status(404).json({ error: 'Application not found' });
        }
        
        // Only job owner or admin can update status
        if (application.jobId.employerId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized to update this application' });
        }
        
        const oldStatus = application.status;
        application.status = req.body.status;
        if (req.body.employerNotes) application.employerNotes = req.body.employerNotes;
        await application.save();
        
        // Notification to applicant
        let statusMessage = '';
        switch (req.body.status) {
            case 'shortlisted':
                statusMessage = 'You have been shortlisted for the position!';
                break;
            case 'interview':
                statusMessage = 'You have been invited for an interview. Check your email for details.';
                break;
            case 'accepted':
                statusMessage = 'Congratulations! Your application has been accepted.';
                break;
            case 'rejected':
                statusMessage = 'We appreciate your interest, but your application was not selected at this time.';
                break;
            default:
                statusMessage = `Your application status has been updated to: ${req.body.status}`;
        }
        
        await Notification.create({
            userId: application.applicantId,
            type: 'system',
            content: `${statusMessage} (${application.jobId.title})`,
            targetId: application._id,
            targetType: 'application'
        });
        
        // Send email to applicant
        const applicant = await User.findById(application.applicantId);
        if (applicant && applicant.email) {
            try {
                await sendEmailWithBrevo(
                    applicant.email,
                    `Application Update: ${application.jobId.title}`,
                    `<div style="font-family: Arial, sans-serif;">
                        <h2>Application Status Update</h2>
                        <p><strong>Position:</strong> ${application.jobId.title}</p>
                        <p><strong>New Status:</strong> ${req.body.status}</p>
                        ${req.body.employerNotes ? `<p><strong>Notes from employer:</strong> ${req.body.employerNotes}</p>` : ''}
                        <a href="${FRONTEND_URL}/jobs/my-applications" style="background: #3b82f6; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px;">View My Applications</a>
                    </div>`,
                    `Your application for ${application.jobId.title} has been updated to: ${req.body.status}`
                );
            } catch (emailError) {
                logger.error(`Failed to send status email: ${emailError.message}`);
            }
        }
        
        res.json({ success: true, data: application });
    } catch (error) {
        logger.error(`Error updating application status: ${error.message}`);
        res.status(500).json({ error: 'Failed to update application status' });
    }
});

// POST /api/jobs/applications/:applicationId/interview - جدولة مقابلة
app.post('/api/jobs/applications/:applicationId/interview', authenticateToken, [
    body('scheduledAt').isISO8601(),
    body('type').isIn(['phone', 'video', 'onsite', 'technical']),
    body('meetingLink').optional().isURL()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const application = await JobApplication.findById(req.params.applicationId)
            .populate('jobId');
        
        if (!application) {
            return res.status(404).json({ error: 'Application not found' });
        }
        
        if (application.jobId.employerId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized' });
        }
        
        const interview = {
            scheduledAt: new Date(req.body.scheduledAt),
            type: req.body.type,
            meetingLink: req.body.meetingLink || null,
            status: 'scheduled'
        };
        
        application.interviews.push(interview);
        application.status = 'interview';
        await application.save();
        
        // Notify applicant
        const applicant = await User.findById(application.applicantId);
        await Notification.create({
            userId: application.applicantId,
            type: 'system',
            content: `Interview scheduled for ${application.jobId.title} on ${new Date(req.body.scheduledAt).toLocaleString()}`,
            targetId: application._id,
            targetType: 'interview'
        });
        
        // Send email
        if (applicant && applicant.email) {
            await sendEmailWithBrevo(
                applicant.email,
                `Interview Scheduled: ${application.jobId.title}`,
                `<div>
                    <h2>Interview Scheduled</h2>
                    <p><strong>Date:</strong> ${new Date(req.body.scheduledAt).toLocaleString()}</p>
                    <p><strong>Type:</strong> ${req.body.type}</p>
                    ${req.body.meetingLink ? `<p><strong>Meeting Link:</strong> <a href="${req.body.meetingLink}">${req.body.meetingLink}</a></p>` : ''}
                </div>`,
                `Interview scheduled for ${application.jobId.title} on ${new Date(req.body.scheduledAt).toLocaleString()}`
            );
        }
        
        res.json({ success: true, data: application.interviews });
    } catch (error) {
        logger.error(`Error scheduling interview: ${error.message}`);
        res.status(500).json({ error: 'Failed to schedule interview' });
    }
});

// ---------- SAVE JOBS (حفظ الوظائف) ----------

// POST /api/jobs/:jobId/save - حفظ/إلغاء حفظ وظيفة
app.post('/api/jobs/:jobId/save', authenticateToken, async (req, res) => {
    try {
        const job = await Job.findById(req.params.jobId);
        if (!job) {
            return res.status(404).json({ error: 'Job not found' });
        }
        
        const existingSave = await JobSave.findOne({
            jobId: job._id,
            userId: req.user.userId
        });
        
        if (existingSave) {
            await existingSave.deleteOne();
            res.json({ success: true, isSaved: false, message: 'Job removed from saved' });
        } else {
            await JobSave.create({
                jobId: job._id,
                userId: req.user.userId
            });
            res.json({ success: true, isSaved: true, message: 'Job saved successfully' });
        }
    } catch (error) {
        logger.error(`Error saving job: ${error.message}`);
        res.status(500).json({ error: 'Failed to save job' });
    }
});

// GET /api/jobs/saved - الوظائف المحفوظة
app.get('/api/jobs/saved', authenticateToken, async (req, res) => {
    try {
        const { page = 1, limit = 20 } = req.query;
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        const savedJobs = await JobSave.find({ userId: req.user.userId })
            .sort({ savedAt: -1 })
            .skip(skip)
            .limit(parseInt(limit))
            .populate('jobId')
            .lean();
        
        const jobs = savedJobs.map(s => s.jobId).filter(j => j);
        
        const total = await JobSave.countDocuments({ userId: req.user.userId });
        
        res.json({
            success: true,
            data: jobs,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
    } catch (error) {
        logger.error(`Error fetching saved jobs: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch saved jobs' });
    }
});


// ---------- JOB STATISTICS ----------

// GET /api/jobs/stats - إحصائيات الوظائف
app.get('/api/jobs/stats', async (req, res) => {
    try {
        const totalJobs = await Job.countDocuments({ status: 'active', deadline: { $gt: new Date() } });
        const totalCompanies = await Job.distinct('employerId').then(arr => arr.length);
        const categoriesStats = await Job.aggregate([
            { $match: { status: 'active', deadline: { $gt: new Date() } } },
            { $group: { _id: '$category', count: { $sum: 1 } } },
            { $sort: { count: -1 } },
            { $limit: 5 }
        ]);
        
        const remoteJobsCount = await Job.countDocuments({ isRemote: true, status: 'active', deadline: { $gt: new Date() } });
        
        res.json({
            success: true,
            stats: {
                totalJobs,
                totalCompanies,
                remoteJobs: remoteJobsCount,
                topCategories: categoriesStats
            }
        });
    } catch (error) {
        logger.error(`Error fetching job stats: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch stats' });
    }
});

// POST /api/jobs/:jobId/duplicate - نسخ وظيفة
app.post('/api/jobs/:jobId/duplicate', authenticateToken, async (req, res) => {
    try {
        const originalJob = await Job.findById(req.params.jobId);
        if (!originalJob) {
            return res.status(404).json({ error: 'Job not found' });
        }
        
        if (originalJob.employerId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Unauthorized' });
        }
        
        const newJob = new Job({
            ...originalJob.toObject(),
            _id: undefined,
            title: `${originalJob.title} (Copy)`,
            postedAt: new Date(),
            views: 0,
            applicationsCount: 0,
            status: 'draft'
        });
        
        await newJob.save();
        res.json({ success: true, data: newJob });
    } catch (error) {
        logger.error(`Error duplicating job: ${error.message}`);
        res.status(500).json({ error: 'Failed to duplicate job' });
    }
});


// ============================================
// FOLLOW SYSTEM - COMPLETE ENDPOINTS
// ============================================

// ============================================
// GET /api/users/me/following - جلب المستخدمين اللي أنا متابعهم (مع pagination وإحصائيات)
// ============================================
app.get('/api/users/me/following', authenticateToken, async (req, res) => {
    try {
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 20;
        const skip = (page - 1) * limit;
        
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        })
        .skip(skip)
        .limit(limit)
        .populate('followingId', 'username profile.nickname profile.avatar profile.jobTitle');
        
        const followingWithInfo = await Promise.all(following.map(async (f) => {
            const followed = f.followingId;
            const postsCount = await Post.countDocuments({ userId: followed._id });
            const followersCount = await Follow.countDocuments({ followingId: followed._id, status: 'accepted' });
            const isFollowedBack = await Follow.exists({ 
                followerId: followed._id, 
                followingId: req.user.userId, 
                status: 'accepted' 
            });
            
            return {
                _id: followed._id,
                username: followed.username,
                profile: followed.profile,
                stats: {
                    posts: postsCount,
                    followers: followersCount
                },
                isFollowedBack: !!isFollowedBack
            };
        }));
        
        const total = await Follow.countDocuments({ followerId: req.user.userId, status: 'accepted' });
        
        res.json({
            success: true,
            data: followingWithInfo,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / limit)
            }
        });
    } catch (error) {
        logger.error(`Error fetching following: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch following' });
    }
});

// GET /api/users/me/followers - جلب المتابعين بتاعي
app.get('/api/users/me/followers', authenticateToken, async (req, res) => {
    try {
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 20;
        const skip = (page - 1) * limit;
        
        // ✅ البحث في Follow model
        const followers = await Follow.find({ 
            followingId: req.user.userId, 
            status: 'accepted' 
        })
        .skip(skip)
        .limit(limit)
        .populate('followerId', 'username profile.nickname profile.avatar profile.jobTitle');
        
        // ✅ إضافة معلومات إضافية لكل متابع
        const followersWithInfo = await Promise.all(followers.map(async (f) => {
            const follower = f.followerId;
            const postsCount = await Post.countDocuments({ userId: follower._id });
            const isFollowing = await Follow.exists({ 
                followerId: req.user.userId, 
                followingId: follower._id,
                status: 'accepted' 
            });
            
            return {
                _id: follower._id,
                username: follower.username,
                profile: follower.profile,
                stats: {
                    posts: postsCount
                },
                isFollowing: !!isFollowing
            };
        }));
        
        const total = await Follow.countDocuments({ followingId: req.user.userId, status: 'accepted' });
        
        res.json({
            success: true,
            data: followersWithInfo,
            pagination: { page, limit, total, pages: Math.ceil(total / limit) }
        });
    } catch (error) {
        logger.error(`Error fetching followers: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch followers' });
    }
});


// ============================================
// GET /api/users/:userId/follow - التحقق من حالة المتابعة
// ============================================
app.get('/api/users/:userId/follow', authenticateToken, async (req, res) => {
    try {
        const { userId } = req.params;
        const currentUserId = req.user.userId;
        
        // ✅ التحقق من صحة الـ ObjectId
        if (!mongoose.Types.ObjectId.isValid(userId)) {
            return res.status(400).json({ error: 'Invalid user ID' });
        }
        
        // منع التحقق من متابعة النفس
        if (userId === currentUserId) {
            return res.json({ isFollowing: false });
        }
        
        const follow = await Follow.findOne({
            followerId: currentUserId,
            followingId: userId,
            status: 'accepted'
        });
        
        res.json({ isFollowing: !!follow });
        
    } catch (error) {
        logger.error(`Error checking follow status: ${error.message}`);
        res.status(500).json({ error: 'Failed to check follow status' });
    }
});

// ============================================
// GET /api/users/:userId/followers - جلب متابعين مستخدم معين (مع pagination و isFollowing)
// ============================================
app.get('/api/users/:userId/followers', authenticateToken, async (req, res) => {
    try {
        const { userId } = req.params;
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 20;
        const skip = (page - 1) * limit;

        const followers = await Follow.find({ 
            followingId: userId, 
            status: 'accepted' 
        })
        .skip(skip)
        .limit(limit)
        .populate('followerId', 'username profile.nickname profile.avatar profile.jobTitle');

        const followersUsers = await Promise.all(followers.map(async (f) => ({
            _id: f.followerId._id,
            username: f.followerId.username,
            profile: f.followerId.profile,
            isFollowing: await Follow.exists({ 
                followerId: req.user.userId, 
                followingId: f.followerId._id,
                status: 'accepted'
            })
        })));

        const total = await Follow.countDocuments({ followingId: userId, status: 'accepted' });

        res.json({
            success: true,
            data: followersUsers,
            pagination: { page, limit, total, pages: Math.ceil(total / limit) }
        });
    } catch (error) {
        logger.error(`Error fetching followers: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch followers' });
    }
});

// ============================================
// GET /api/users/:userId/following - جلب اللي بيتبعهم مستخدم معين (مع pagination و isFollowing)
// ============================================
app.get('/api/users/:userId/following', authenticateToken, async (req, res) => {
    try {
        const { userId } = req.params;
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 20;
        const skip = (page - 1) * limit;

        const following = await Follow.find({ 
            followerId: userId, 
            status: 'accepted' 
        })
        .skip(skip)
        .limit(limit)
        .populate('followingId', 'username profile.nickname profile.avatar profile.jobTitle');

        const followingUsers = await Promise.all(following.map(async (f) => ({
            _id: f.followingId._id,
            username: f.followingId.username,
            profile: f.followingId.profile,
            isFollowing: await Follow.exists({ 
                followerId: req.user.userId, 
                followingId: f.followingId._id,
                status: 'accepted'
            })
        })));

        const total = await Follow.countDocuments({ followerId: userId, status: 'accepted' });

        res.json({
            success: true,
            data: followingUsers,
            pagination: { page, limit, total, pages: Math.ceil(total / limit) }
        });
    } catch (error) {
        logger.error(`Error fetching following: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch following' });
    }
});




// GET /api/users/me/following/ids - IDs اللي أنا متابعهم (سريع)
app.get('/api/users/me/following/ids', authenticateToken, async (req, res) => {
    try {
        const following = await Follow.find({ 
            followerId: req.user.userId, 
            status: 'accepted' 
        }).select('followingId');
        
        const followingIds = following.map(f => f.followingId);
        
        res.json({ success: true, data: followingIds });
    } catch (error) {
        logger.error(`Error fetching following IDs: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch following IDs' });
    }
});


// POST /api/users/:userId/follow - متابعة/إلغاء متابعة (موجودة بس هنضيفلها تحسينات)
// هعدل الـ endpoint الموجود عشان يبقى أكتمل

// DELETE /api/users/:userId/follow - إلغاء متابعة (بديل)
app.delete('/api/users/:userId/follow', authenticateToken, async (req, res) => {
    try {
        const { userId } = req.params;
        
        if (userId === req.user.userId) {
            return res.status(400).json({ error: 'Cannot unfollow yourself' });
        }
        
        const follow = await Follow.findOneAndDelete({
            followerId: req.user.userId,
            followingId: userId
        });
        
        if (!follow) {
            return res.status(404).json({ error: 'Not following this user' });
        }
        
        // ✅ حذف الإشعار
        await Notification.deleteMany({
            userId: userId,
            type: 'follow',
            actorId: req.user.userId
        });
        
        res.json({ success: true, isFollowing: false, message: 'Unfollowed successfully' });
    } catch (error) {
        logger.error(`Error unfollowing user: ${error.message}`);
        res.status(500).json({ error: 'Failed to unfollow user' });
    }
});

// GET /api/users/me/following/check - التحقق من متابعة عدة مستخدمين مرة واحدة
app.post('/api/users/me/following/check', authenticateToken, async (req, res) => {
    try {
        const { userIds } = req.body;
        
        if (!userIds || !Array.isArray(userIds)) {
            return res.status(400).json({ error: 'userIds array is required' });
        }
        
        const following = await Follow.find({
            followerId: req.user.userId,
            followingId: { $in: userIds },
            status: 'accepted'
        }).select('followingId');
        
        const followingSet = new Set(following.map(f => f.followingId.toString()));
        
        const result = {};
        userIds.forEach(id => {
            result[id] = followingSet.has(id);
        });
        
        res.json({ success: true, data: result });
    } catch (error) {
        logger.error(`Error checking follow status: ${error.message}`);
        res.status(500).json({ error: 'Failed to check follow status' });
    }
});



// ============================================
// MESSAGING SYSTEM - COMPLETE ENDPOINTS
// ============================================

// POST /api/conversations - بدء محادثة جديدة
app.post('/api/conversations', authenticateToken, [
    body('userId').isMongoId().withMessage('Valid user ID required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const { userId } = req.body;
        
        if (userId === req.user.userId) {
            return res.status(400).json({ error: 'Cannot start conversation with yourself' });
        }

        // Check if conversation already exists
        let conversation = await Conversation.findOne({
            participants: { $all: [req.user.userId, userId], $size: 2 }
        });

        if (conversation) {
            return res.json({ success: true, data: conversation });
        }

        conversation = new Conversation({
            participants: [req.user.userId, userId],
            unreadCount: new Map()
        });
        
        conversation.unreadCount.set(req.user.userId.toString(), 0);
        conversation.unreadCount.set(userId, 0);
        
        await conversation.save();

        // Populate other user info
        const populated = await conversation.populate('participants', 'username profile.nickname profile.avatar');
        
        res.status(201).json({ success: true, data: populated });
    } catch (error) {
        logger.error(`Error creating conversation: ${error.message}`);
        res.status(500).json({ error: 'Failed to create conversation' });
    }
});

// ============================================
// GET /api/conversations - جلب كل المحادثات (نسخة آمنة)
// ============================================
app.get('/api/conversations', authenticateToken, async (req, res) => {
    try {
        const conversations = await Conversation.find({
            participants: req.user.userId
        })
        .sort({ updatedAt: -1 })
        .populate('participants', 'username profile.nickname profile.avatar profile.jobTitle')
        .lean();

        const enrichedConversations = conversations.map(conv => {
            const otherUser = conv.participants.find(p => p._id.toString() !== req.user.userId);
            
            // ✅ معالجة آمنة لـ unreadCount (تجنب خطأ .get)
            let unread = 0;
            if (conv.unreadCount) {
                if (typeof conv.unreadCount.get === 'function') {
                    unread = conv.unreadCount.get(req.user.userId.toString()) || 0;
                } else if (conv.unreadCount instanceof Map) {
                    unread = conv.unreadCount.get(req.user.userId.toString()) || 0;
                } else if (typeof conv.unreadCount === 'object') {
                    unread = conv.unreadCount[req.user.userId.toString()] || 0;
                }
            }
            
            return {
                _id: conv._id,
                otherUser: {
                    _id: otherUser?._id,
                    name: otherUser?.profile?.nickname || otherUser?.username || 'Unknown User',
                    avatar: otherUser?.profile?.avatar || '/assets/img/default-avatar.png',
                    jobTitle: otherUser?.profile?.jobTitle || 'Professional',
                    online: false
                },
                lastMessage: conv.lastMessage?.text || '',
                lastMessageTime: conv.lastMessage?.createdAt || conv.updatedAt,
                unreadCount: unread,
                updatedAt: conv.updatedAt
            };
        });

        res.json(enrichedConversations);
    } catch (error) {
        logger.error(`Error fetching conversations: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch conversations' });
    }
});

// GET /api/conversations/:conversationId/messages - جلب رسائل المحادثة
app.get('/api/conversations/:conversationId/messages', authenticateToken, async (req, res) => {
    try {
        const { conversationId } = req.params;
        const { limit = 50, before } = req.query;

        // Verify user is part of conversation
        const conversation = await Conversation.findOne({
            _id: conversationId,
            participants: req.user.userId
        });

        if (!conversation) {
            return res.status(403).json({ error: 'Not authorized to view this conversation' });
        }

        let query = { conversationId, isDeleted: false, deletedFor: { $ne: req.user.userId } };
        if (before) {
            query.createdAt = { $lt: new Date(before) };
        }

        const messages = await Message.find(query)
            .sort({ createdAt: -1 })
            .limit(parseInt(limit))
            .populate('senderId', 'username profile.nickname profile.avatar')
            .lean();

        // Mark messages as read
        const unreadMessages = messages.filter(m => 
            m.senderId._id.toString() !== req.user.userId &&
            !m.readBy.some(r => r.userId.toString() === req.user.userId)
        );

        if (unreadMessages.length > 0) {
            await Message.updateMany(
                { _id: { $in: unreadMessages.map(m => m._id) } },
                { $addToSet: { readBy: { userId: req.user.userId, readAt: new Date() } } }
            );

            // Update conversation unread count
            const currentUnread = conversation.unreadCount?.get(req.user.userId.toString()) || 0;
            const newUnread = Math.max(0, currentUnread - unreadMessages.length);
            conversation.unreadCount.set(req.user.userId.toString(), newUnread);
            await conversation.save();
        }

        res.json(messages.reverse());
    } catch (error) {
        logger.error(`Error fetching messages: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch messages' });
    }
});

// ============================================
// DELETE /api/conversations/:conversationId/clear - مسح المحادثة (للمستخدم الحالي فقط)
// ============================================
app.delete('/api/conversations/:conversationId/clear', authenticateToken, async (req, res) => {
    try {
        const { conversationId } = req.params;
        
        const conversation = await Conversation.findOne({
            _id: conversationId,
            participants: req.user.userId
        });
        
        if (!conversation) {
            return res.status(404).json({ error: 'Conversation not found' });
        }
        
        // Soft delete - mark all messages as deleted for this user
        await Message.updateMany(
            { conversationId, deletedFor: { $ne: req.user.userId } },
            { $addToSet: { deletedFor: req.user.userId } }
        );
        
        // Reset unread count for this user
        conversation.unreadCount.set(req.user.userId.toString(), 0);
        conversation.lastMessage = {
            text: 'Chat cleared',
            senderId: req.user.userId,
            readBy: [req.user.userId],
            createdAt: new Date()
        };
        await conversation.save();
        
        logger.info(`User ${req.user.userId} cleared conversation ${conversationId}`);
        res.json({ success: true, message: 'Chat cleared successfully' });
        
    } catch (error) {
        logger.error(`Error clearing conversation: ${error.message}`);
        res.status(500).json({ error: 'Failed to clear conversation' });
    }
});



app.post('/api/conversations/:conversationId/pin', authenticateToken, async (req, res) => {
    try {
        const { conversationId } = req.params;
        const { messageId } = req.body;
        
        // تحديث آخر رسالة مثبتة
        await Conversation.findByIdAndUpdate(conversationId, {
            pinnedMessage: messageId,
            pinnedAt: new Date()
        });
        
        res.json({ success: true });
    } catch (error) {
        res.status(500).json({ error: 'Failed to pin message' });
    }
});


app.post('/api/messages/:messageId/forward', authenticateToken, async (req, res) => {
    try {
        const { messageId } = req.params;
        const { recipientId } = req.body;
        
        const originalMessage = await Message.findById(messageId);
        if (!originalMessage) {
            return res.status(404).json({ error: 'Message not found' });
        }
        
        const newMessage = new Message({
            conversationId: null, // سيتم إنشاء محادثة جديدة أو إضافتها لاحقاً
            senderId: req.user.userId,
            text: `Forwarded: ${originalMessage.text}`,
            attachments: originalMessage.attachments,
            isForwarded: true,
            originalMessageId: messageId
        });
        
        await newMessage.save();
        
        res.json({ success: true });
    } catch (error) {
        res.status(500).json({ error: 'Failed to forward message' });
    }
});


// ============================================
// GET /api/socket/config - جلب إعدادات Socket.IO
// ============================================
app.get('/api/socket/config', authenticateToken, async (req, res) => {
    try {
        const socketUrl = process.env.SOCKET_URL;
        
        if (!socketUrl) {
            logger.warn('SOCKET_URL not configured in environment variables');
            return res.json({ 
                url: null, 
                enabled: false,
                message: 'Socket.IO not configured'
            });
        }
        
        res.json({
            url: socketUrl,
            enabled: true,
            version: '2.0.0'
        });
        
    } catch (error) {
        logger.error(`Error getting Socket config: ${error.message}`);
        res.status(500).json({ 
            url: null, 
            enabled: false,
            error: error.message 
        });
    }
});

app.post('/api/messages/:messageId/reaction', authenticateToken, async (req, res) => {
    try {
        const { messageId } = req.params;
        const { reaction } = req.body;
        
        const message = await Message.findById(messageId);
        if (!message) {
            return res.status(404).json({ error: 'Message not found' });
        }
        
        if (!message.reactions) message.reactions = new Map();
        
        const users = message.reactions.get(reaction) || [];
        const userIndex = users.indexOf(req.user.userId);
        
        if (userIndex === -1) {
            users.push(req.user.userId);
        } else {
            users.splice(userIndex, 1);
        }
        
        if (users.length === 0) {
            message.reactions.delete(reaction);
        } else {
            message.reactions.set(reaction, users);
        }
        
        await message.save();
        res.json({ success: true });
    } catch (error) {
        res.status(500).json({ error: 'Failed to add reaction' });
    }
});

// ============================================
// POST /api/conversations/:conversationId/typing - إشارة الكتابة
// ============================================
app.post('/api/conversations/:conversationId/typing', authenticateToken, async (req, res) => {
    try {
        const { conversationId } = req.params;
        const { isTyping } = req.body;
        
        const conversation = await Conversation.findOne({
            _id: conversationId,
            participants: req.user.userId
        });
        
        if (!conversation) {
            return res.status(404).json({ error: 'Conversation not found' });
        }
        
        // Get the other participant
        const otherParticipant = conversation.participants.find(p => p.toString() !== req.user.userId);
        
        if (!otherParticipant) {
            return res.json({ success: true });
        }
        
        // Store typing status in memory or Redis (for production)
        // For now, we'll just return success
        // In production, you'd emit a socket event here
        
        res.json({ success: true, isTyping });
        
    } catch (error) {
        logger.error(`Error in typing indicator: ${error.message}`);
        res.status(500).json({ error: 'Failed to update typing status' });
    }
});

// ============================================
// POST /api/conversations/:conversationId/messages - إرسال رسالة (يدعم الملفات)
// ============================================
app.post('/api/conversations/:conversationId/messages', authenticateToken, messageUpload.array('attachments', 5), [
    body('text').optional().isString(),
    body('replyTo').optional().isMongoId()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const { conversationId } = req.params;
        const { text, replyTo } = req.body;
        
        const hasText = text && text.trim() !== '';
        const hasAttachments = req.files && req.files.length > 0;
        
        if (!hasText && !hasAttachments) {
            return res.status(400).json({ error: 'Either text or attachments are required' });
        }

        // Verify user is part of conversation
        const conversation = await Conversation.findOne({
            _id: conversationId,
            participants: req.user.userId
        });

        if (!conversation) {
            return res.status(403).json({ error: 'Not authorized to send messages' });
        }

        // Process attachments and upload to Cloudinary
        let attachments = [];
        if (hasAttachments) {
            for (const file of req.files) {
                try {
                    // Upload to Cloudinary
                    const result = await new Promise((resolve, reject) => {
                        const uploadStream = cloudinary.uploader.upload_stream(
                            {
                                folder: `messages/${conversationId}`,
                                resource_type: 'auto',
                                public_id: `${Date.now()}_${file.originalname.replace(/[^a-zA-Z0-9.]/g, '_')}`
                            },
                            (error, result) => {
                                if (error) reject(error);
                                else resolve(result);
                            }
                        );
                        uploadStream.end(file.buffer);
                    });
                    
                   let attachmentType = 'file';
                    if (file.mimetype.startsWith('image/')) attachmentType = 'image';
                    else if (file.mimetype.startsWith('video/')) attachmentType = 'video';
                    else if (file.mimetype.startsWith('audio/')) attachmentType = 'audio';
                    else if (file.mimetype === 'application/pdf') attachmentType = 'pdf';
                    else attachmentType = 'file';
                    
                    attachments.push({
                        type: attachmentType,
                        url: result.secure_url,
                        publicId: result.public_id,
                        name: file.originalname,
                        size: file.size
                    });
                } catch (uploadError) {
                    logger.error(`File upload error: ${uploadError.message}`);
                    // Continue with other files
                }
            }
        }

        // Determine final text
        let finalText = text || '';
        if ((!finalText || finalText.trim() === '') && attachments.length > 0) {
            if (attachments[0].type === 'audio') finalText = '🎤 Voice message';
            else if (attachments[0].type === 'image') finalText = '📷 Photo';
            else finalText = '📎 Attachment';
        }

        const message = new Message({
            conversationId,
            senderId: req.user.userId,
            text: finalText,
            attachments: attachments,
            replyTo: replyTo || null,
            readBy: [{ userId: req.user.userId, readAt: new Date() }]
        });

        await message.save();

        // Update conversation last message
        const otherParticipant = conversation.participants.find(p => p.toString() !== req.user.userId);
        const currentUnread = conversation.unreadCount?.get(otherParticipant.toString()) || 0;
        conversation.unreadCount.set(otherParticipant.toString(), currentUnread + 1);
        conversation.lastMessage = {
            text: finalText.substring(0, 100),
            senderId: req.user.userId,
            readBy: [req.user.userId],
            createdAt: new Date()
        };
        conversation.updatedAt = new Date();
        await conversation.save();

        // Create notification for other user
        const sender = await User.findById(req.user.userId);
        await Notification.create({
            userId: otherParticipant,
            type: 'message',
            actorId: req.user.userId,
            actorName: sender.profile?.nickname || sender.username,
            targetId: conversationId,
            targetType: 'conversation',
            content: `New message from ${sender.profile?.nickname || sender.username}`,
            read: false
        });

        const populatedMessage = await message.populate('senderId', 'username profile.nickname profile.avatar');
        

            try {
                const socketClient = getSocketClient(); // يجب استيرادها من ملف منفصل
                // بث الرسالة لكل من في غرفة المحادثة
                socketClient.to(`conv_${conversationId}`).emit('new_message', populatedMessage);
                // إرسال إشعار للمستلم
                socketClient.to(`user_${otherParticipant}`).emit('new_message_notification', {
                    conversationId,
                    sender: {
                        id: req.user.userId,
                        username: sender.profile?.nickname || sender.username,
                        avatar: sender.profile?.avatar
                    },
                    message: populatedMessage
                });
                logger.info(`📢 Broadcasted message ${populatedMessage._id} via Socket.IO`);
            } catch (socketError) {
                // لا نوقف الـ response إذا فشل البث، فقط نسجل الخطأ
                logger.error(`Socket broadcast failed: ${socketError.message}`);
            }

        res.status(201).json({ success: true, data: populatedMessage });
        
    } catch (error) {
        logger.error(`Error sending message: ${error.message}`);
        res.status(500).json({ error: 'Failed to send message: ' + error.message });
    }
});

// DELETE /api/messages/:messageId - حذف رسالة (لنفسي فقط)
app.delete('/api/messages/:messageId', authenticateToken, async (req, res) => {
    try {
        const { messageId } = req.params;
        
        const message = await Message.findById(messageId);
        if (!message) {
            return res.status(404).json({ error: 'Message not found' });
        }

        if (message.senderId.toString() !== req.user.userId && !req.user.isAdmin) {
            return res.status(403).json({ error: 'Can only delete your own messages' });
        }

        // Soft delete - add to deletedFor array
        message.deletedFor.push(req.user.userId);
        
        if (message.deletedFor.length === 2) {
            // Both users deleted, hard delete
            await message.deleteOne();
        } else {
            await message.save();
        }

        res.json({ success: true, message: 'Message deleted' });
    } catch (error) {
        logger.error(`Error deleting message: ${error.message}`);
        res.status(500).json({ error: 'Failed to delete message' });
    }
});

// PUT /api/conversations/:conversationId/read - تعليم المحادثة كمقروءة
app.put('/api/conversations/:conversationId/read', authenticateToken, async (req, res) => {
    try {
        const { conversationId } = req.params;
        
        const conversation = await Conversation.findOne({
            _id: conversationId,
            participants: req.user.userId
        });

        if (!conversation) {
            return res.status(404).json({ error: 'Conversation not found' });
        }

        // Mark all unread messages as read
        await Message.updateMany(
            {
                conversationId,
                senderId: { $ne: req.user.userId },
                'readBy.userId': { $ne: req.user.userId }
            },
            { $addToSet: { readBy: { userId: req.user.userId, readAt: new Date() } } }
        );

        // Reset unread count
        conversation.unreadCount.set(req.user.userId.toString(), 0);
        await conversation.save();

        res.json({ success: true });
    } catch (error) {
        logger.error(`Error marking conversation as read: ${error.message}`);
        res.status(500).json({ error: 'Failed to mark as read' });
    }
});

// GET /api/conversations/unread/count - عدد الرسائل غير المقروءة
app.get('/api/conversations/unread/count', authenticateToken, async (req, res) => {
    try {
        const conversations = await Conversation.find({
            participants: req.user.userId
        });

        let totalUnread = 0;
        for (const conv of conversations) {
            totalUnread += conv.unreadCount?.get(req.user.userId.toString()) || 0;
        }

        res.json({ success: true, count: totalUnread });
    } catch (error) {
        logger.error(`Error fetching unread count: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch unread count' });
    }
});


// GET /api/users/:userId/contributions
app.get('/api/users/:userId/contributions', async (req, res) => {
    try {
        const { userId } = req.params;
        const { year = new Date().getFullYear() } = req.query;
        
        const data = await buildContributionGraph(userId, year);
        
        res.json({
            success: true,
            ...data
        });
        
    } catch (error) {
        console.error('Error getting contributions:', error);
        res.status(500).json({ error: 'Failed to get contributions' });
    }
});

// ✅ Endpoint جديد للتفاصيل (عند الضغط على يوم)
app.get('/api/users/:userId/contributions/:date', async (req, res) => {
    try {
        const { userId, date } = req.params;
        
        const activities = await getDayActivities(userId, date);
        
        res.json({
            date,
            activities
        });
        
    } catch (error) {
        console.error('Error getting day activities:', error);
        res.status(500).json({ error: 'Failed to get activities' });
    }
});


// ============================================
// ✅ Service موحدة لبناء Contribution Graph
// ============================================
async function buildContributionGraph(userId, year) {
    if (!userId) {
        return { total: 0, days: {}, year: year || new Date().getFullYear(), months: [], weekDays: [] };
    }
    
    const targetYear = year || new Date().getFullYear();
    const startDate = new Date(targetYear, 0, 1);
    const endDate = new Date(targetYear, 11, 31, 23, 59, 59);
    
    try {
        // ✅ جلب البيانات المجمعة (بدون countDocuments منفصلة)
        const [
            posts,
            projectComments,
            postComments,
            likes,
            shares,
            applications
        ] = await Promise.all([
            getPostsAggregation(userId, startDate, endDate),
            getCommentsAggregation(userId, startDate, endDate),
            getPostCommentsAggregation(userId, startDate, endDate),
            getLikesAggregation(userId, startDate, endDate),
            getSharesAggregation(userId, startDate, endDate),
            getApplicationsAggregation(userId, startDate, endDate)
        ]);
        
        // ✅ دمج البيانات في Map
        const daily = new Map();
        
        function merge(data) {
            data.forEach(item => {
                const date = item._id;
                if (!daily.has(date)) daily.set(date, 0);
                daily.set(date, daily.get(date) + item.count);
            });
        }
        
        merge(posts);
        merge(projectComments);
        merge(postComments);
        merge(likes);
        merge(shares);
        merge(applications);
        
        // ✅ حساب total وتحويل Map إلى Object (الأيام النشطة بس)
        let total = 0;
        const days = {};
        
        for (const [date, count] of daily) {
            days[date] = count;
            total += count;
        }
        
        return {
            total,
            year: targetYear,
            days,  // ← بس الأيام اللي فيها نشاط!
            months: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
            weekDays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
        };
        
    } catch (error) {
        console.error('Error in buildContributionGraph:', error);
        return { total: 0, days: {}, year: targetYear, months: [], weekDays: [] };
    }
}

// ============================================
// ✅ دوال الـ Aggregation (من غير activities)
// ============================================
async function getPostsAggregation(userId, startDate, endDate) {
    return await Post.aggregate([
        { 
            $match: { 
                userId: new mongoose.Types.ObjectId(userId), 
                createdAt: { $gte: startDate, $lte: endDate } 
            } 
        },
        { 
            $group: { 
                _id: { $dateToString: { format: "%Y-%m-%d", date: "$createdAt" } }, 
                count: { $sum: 1 } 
            } 
        }
    ]);
}

async function getCommentsAggregation(userId, startDate, endDate) {
    return await Comment.aggregate([
        { 
            $match: { 
                userId: new mongoose.Types.ObjectId(userId), 
                timestamp: { $gte: startDate, $lte: endDate } 
            } 
        },
        { 
            $group: { 
                _id: { $dateToString: { format: "%Y-%m-%d", date: "$timestamp" } }, 
                count: { $sum: 1 } 
            } 
        }
    ]);
}


async function getPostCommentsAggregation(userId, startDate, endDate) {
    return await Post.aggregate([
        {
            $unwind: "$comments"
        },
        {
            $match: {
                "comments.userId": new mongoose.Types.ObjectId(userId),
                "comments.createdAt": {
                    $gte: startDate,
                    $lte: endDate
                }
            }
        },
        {
            $group: {
                _id: {
                    $dateToString: {
                        format: "%Y-%m-%d",
                        date: "$comments.createdAt"
                    }
                },
                count: {
                    $sum: 1
                }
            }
        }
    ]);
}

async function getLikesAggregation(userId, startDate, endDate) {
    return await Post.aggregate([
        {
            $unwind: "$likes"
        },
        {
            $match: {
                "likes.userId": new mongoose.Types.ObjectId(userId),
                "likes.likedAt": {
                    $gte: startDate,
                    $lte: endDate
                }
            }
        },
        {
            $group: {
                _id: {
                    $dateToString: {
                        format: "%Y-%m-%d",
                        date: "$likes.likedAt"
                    }
                },
                count: {
                    $sum: 1
                }
            }
        }
    ]);
}

async function getSharesAggregation(userId, startDate, endDate) {
    return await Post.aggregate([
        { 
            $match: { 
                'shares.userId': new mongoose.Types.ObjectId(userId), 
                'shares.sharedAt': { $gte: startDate, $lte: endDate } 
            } 
        },
        { $unwind: "$shares" },
        { 
            $match: { 
                'shares.userId': new mongoose.Types.ObjectId(userId) 
            } 
        },
        { 
            $group: { 
                _id: { $dateToString: { format: "%Y-%m-%d", date: "$shares.sharedAt" } }, 
                count: { $sum: 1 } 
            } 
        }
    ]);
}

async function getApplicationsAggregation(userId, startDate, endDate) {
    return await JobApplication.aggregate([
        { 
            $match: { 
                applicantId: new mongoose.Types.ObjectId(userId), 
                appliedAt: { $gte: startDate, $lte: endDate } 
            } 
        },
        { 
            $group: { 
                _id: { $dateToString: { format: "%Y-%m-%d", date: "$appliedAt" } }, 
                count: { $sum: 1 } 
            } 
        }
    ]);
}

// ============================================
// ✅ جلب الأنشطة ليوم معين (عند الضغط)
// ============================================
async function getDayActivities(userId, date) {
    const startDate = new Date(date);
    const endDate = new Date(date);
    endDate.setDate(endDate.getDate() + 1);
    
    const [
        posts,
        projectComments,
        postComments,
        likes,
        shares,
        applications
    ] = await Promise.all([
        Post.find({ 
            userId: new mongoose.Types.ObjectId(userId), 
            createdAt: { $gte: startDate, $lte: endDate } 
        }).select('_id title content').lean(),
        Comment.find({ 
            userId: new mongoose.Types.ObjectId(userId), 
            timestamp: { $gte: startDate, $lte:endDate } 
        }).select('_id text projectId').lean(),


        // ✅ Post.comments
        Post.aggregate([
            {
                $unwind: "$comments"
            },
            {
                $match:{
                    "comments.userId": new mongoose.Types.ObjectId(userId),
                    "comments.createdAt":{
                        $gte:startDate,
                        $lte:endDate
                    }
                }
            },
            {
                $project:{
                    _id:"$comments._id",
                    text:"$comments.text",
                    postId:"$_id"
                }
            }
        ]),


        // ✅ Likes
        Post.aggregate([
            {
                $unwind:"$likes"
            },
            {
                $match:{
                    "likes.userId": new mongoose.Types.ObjectId(userId),
                    "likes.likedAt":{
                        $gte:startDate,
                        $lte:endDate
                    }
                }
            },
            {
                $project:{
                    postId:"$_id"
                }
            }
        ]),

        Post.aggregate([
            {
                $unwind:"$shares"
            },
            {
                $match:{
                    "shares.userId": new mongoose.Types.ObjectId(userId),
                    "shares.sharedAt":{
                        $gte:startDate,
                        $lte:endDate
                    }
                }
            },
            {
                $project:{
                    postId:"$_id"
                }
            }
        ]),
        
        JobApplication.find({ 
            applicantId: new mongoose.Types.ObjectId(userId), 
            appliedAt: { $gte: startDate, $lte: endDate } 
        }).select('_id jobId').lean()
    ]);
    
    const activities = [];
    
    posts.forEach(p => {
        activities.push({ 
            type: 'post', 
            id: p._id, 
            title: p.title || p.content?.substring(0, 50) || 'Untitled' 
        });
    });
    
    projectComments.forEach(c => {
        activities.push({ 
            type: 'comment', 
            id: c._id, 
            text: c.text?.substring(0, 100) || 'Comment',
            projectId: c.projectId 
        });
    });

    postComments.forEach(c => {
        activities.push({
            type:'post_comment',
            id:c._id,
            text:c.text?.substring(0,100) || 'Comment',
            postId:c.postId
        });
    });
    
    likes.forEach(l => {
        activities.push({ type: 'like', postId: l.postId });
    });
    
    shares.forEach(s => {
        activities.push({ type: 'share', postId: s.postId });
    });
    
    applications.forEach(j => {
        activities.push({ 
            type: 'job_application', 
            id: j._id, 
            jobId: j.jobId 
        });
    });
    
    return activities;
}

// ============================================
// GET /api/analytics/also-viewed - جلب المستخدمين الذين شاهدوا هذا الملف أيضاً
// ============================================
app.get('/api/analytics/also-viewed', authenticateToken, async (req, res) => {
    try {
        const { userId } = req.query;
        
        if (!userId) {
            return res.status(400).json({ error: 'userId is required' });
        }
        
        // ✅ التحقق من المستخدم الحالي
        const isOwner = req.user && req.user.userId === userId;
        
        // ============================
        // ✅ 1. جلب المشاهدات من AlsoViewed (جديدة)
        // ============================
        const alsoViewed = await AlsoViewed.find({ targetUserId: userId })
            .sort({ viewedAt: -1 })
            .limit(20);
        
        // ============================
        // ✅ 2. جلب المشاهدات من ProfileAnalytics (للمشاهدات القديمة)
        // ============================
        const analytics = await ProfileAnalytics.findOne({ userId });
        let historicalViews = [];
        
        if (analytics && analytics.profileViews && analytics.profileViews.length > 0) {
            const views = analytics.profileViews;
            const viewerMap = new Map();
            
            views.forEach((view, index) => {
                // ✅ مفتاح فريد لكل مشاهدة
                let key = null;
                
                if (view.viewerId) {
                    key = view.viewerId.toString();
                } else if (view.viewerIp) {
                    key = view.viewerIp;
                } else {
                    // ✅ للمشاهدات القديمة جداً (بدون viewerId ولا viewerIp)
                    key = `legacy_${index}_${Date.now()}`;
                }
                
                if (!viewerMap.has(key)) {
                    viewerMap.set(key, {
                        viewerId: view.viewerId || null,
                        viewerIp: view.viewerIp || null,
                        viewedAt: view.viewedAt,
                        count: 1
                    });
                } else {
                    const existing = viewerMap.get(key);
                    if (view.viewedAt > existing.viewedAt) {
                        existing.viewedAt = view.viewedAt;
                    }
                    existing.count++;
                }
            });
            
            historicalViews = Array.from(viewerMap.values())
                .sort((a, b) => new Date(b.viewedAt) - new Date(a.viewedAt))
                .slice(0, 20);
        }
        
        // ============================
        // ✅ 3. دمج المشاهدات
        // ============================
        const allViewers = [];
        const processedIds = new Set();
        
        // ✅ أضف المشاهدات من AlsoViewed أولاً
        for (const item of alsoViewed) {
            let key = null;
            if (item.viewerId) {
                key = item.viewerId.toString();
            } else if (item.viewerIp) {
                key = item.viewerIp;
            } else {
                key = `also_${item._id}`;
            }
            
            if (!processedIds.has(key)) {
                processedIds.add(key);
                allViewers.push({
                    viewerId: item.viewerId || null,
                    viewerIp: item.viewerIp || null,
                    viewedAt: item.viewedAt,
                    source: 'alsoViewed'
                });
            }
        }
        
        // ✅ أضف المشاهدات التاريخية
        for (const item of historicalViews) {
            let key = null;
            if (item.viewerId) {
                key = item.viewerId.toString();
            } else if (item.viewerIp) {
                key = item.viewerIp;
            } else {
                key = `legacy_${Math.random().toString(36).substring(7)}`;
            }
            
            if (!processedIds.has(key)) {
                processedIds.add(key);
                allViewers.push({
                    viewerId: item.viewerId || null,
                    viewerIp: item.viewerIp || null,
                    viewedAt: item.viewedAt,
                    source: 'historical'
                });
            }
        }
        
        // ✅ ترتيب حسب الأحدث
        allViewers.sort((a, b) => new Date(b.viewedAt) - new Date(a.viewedAt));
        
        // ============================
        // ✅ 4. جلب بيانات المستخدمين (للمشاهدات التي لها viewerId)
        // ============================
        const userIds = allViewers
            .filter(v => v.viewerId)
            .map(v => v.viewerId);
        
        let userMap = {};
        if (userIds.length > 0) {
            const users = await User.find({ _id: { $in: userIds } })
                .select('username profile.nickname profile.avatar profile.jobTitle');
            
            users.forEach(u => {
                userMap[u._id.toString()] = u;
            });
        }
        
        // ============================
        // ✅ 5. تنسيق النتيجة النهائية
        // ============================
        const registeredViewers = [];
        const guestViewers = [];
        
        allViewers.forEach(item => {
            // ✅ إذا كان viewerId موجود وتم جلب بياناته
            if (item.viewerId && userMap[item.viewerId.toString()]) {
                const user = userMap[item.viewerId.toString()];
                registeredViewers.push({
                    _id: user._id,
                    name: user.profile?.nickname || user.username || 'Someone',
                    nickname: user.profile?.nickname,
                    username: user.username,
                    avatar: user.profile?.avatar || '/assets/img/default-avatar.png',
                    title: user.profile?.jobTitle || 'Professional',
                    viewedAt: item.viewedAt,
                    isGuest: false
                });
            } 
            // ✅ إذا كان viewerId موجود لكن لم يتم جلب بياناته (مستخدم محذوف)
            else if (item.viewerId) {
                registeredViewers.push({
                    _id: item.viewerId,
                    name: 'Deleted User',
                    nickname: null,
                    username: null,
                    avatar: '/assets/img/default-avatar.png',
                    title: 'Unknown',
                    viewedAt: item.viewedAt,
                    isGuest: false
                });
            } 
            // ✅ زائر (غير مسجل)
            else {
                guestViewers.push({
                    viewerIp: item.viewerIp || 'Unknown',
                    viewedAt: item.viewedAt
                });
            }
        });
        
        // ============================
        // ✅ 6. خلط عشوائي (للمسجلين فقط)
        // ============================
        function shuffleArray(array) {
            const shuffled = [...array];
            for (let i = shuffled.length - 1; i > 0; i--) {
                const j = Math.floor(Math.random() * (i + 1));
                [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
            }
            return shuffled;
        }
        
        const shuffledRegistered = shuffleArray(registeredViewers);
        const guestCount = guestViewers.length;
        
        // ============================
        // ✅ 7. بناء النتيجة النهائية
        // ============================
        let data = shuffledRegistered.slice(0, 5);
        
        // ✅ للمالك فقط: أضف معلومات الزوار كـ "others"
        if (isOwner === true && guestCount > 0) {
            data.push({
                _id: null,
                name: `+ ${guestCount} others from outside XCV`,
                nickname: null,
                username: null,
                avatar: null,
                title: 'Guest Visitors',
                viewedAt: null,
                isGuest: true,
                isSummary: true,
                guestCount: guestCount
            });
        }
        
        // ============================
        // ✅ 8. إرجاع النتيجة
        // ============================
        res.json({
            data: data,
            total: registeredViewers.length + guestViewers.length,
            registered: registeredViewers.length,
            guests: guestCount,
            lastUpdated: new Date().toISOString()
        });
        
    } catch (error) {
        console.error('❌ Error in also-viewed:', error);
        res.status(500).json({ error: 'Failed to fetch also viewed data' });
    }
});

// ============================================
// GET /api/pages/suggestions - جلب اقتراحات الصفحات
// ============================================
app.get('/api/pages/suggestions', async (req, res) => {
    try {
        const { limit = 5, category } = req.query;
        
        let query = { isActive: true };
        if (category && category !== 'all') {
            query.category = category;
        }
        
        // جلب الصفحات الأكثر متابعة
        const pages = await PageSuggestion.find(query)
            .sort({ followers: -1 })
            .limit(parseInt(limit));
        
        // جلب عدد المتابعين لكل صفحة
        const pagesWithFollowers = await Promise.all(pages.map(async (page) => {
            const followersCount = await User.countDocuments({ 
                'profile.followedPages': page._id 
            });
            
            // التحقق إذا كان المستخدم الحالي يتابع هذه الصفحة
            let isFollowing = false;
            if (req.user?.userId) {
                const user = await User.findById(req.user.userId);
                isFollowing = user?.profile?.followedPages?.includes(page._id) || false;
            }
            
            return {
                _id: page._id,
                name: page.name,
                nameAr: page.nameAr,
                description: page.description,
                logo: page.logo,
                url: page.url,
                category: page.category,
                followersCount: followersCount,
                isFollowing: isFollowing
            };
        }));
        
        res.json(pagesWithFollowers);
        
    } catch (error) {
        logger.error(`Error fetching page suggestions: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch page suggestions' });
    }
});

// ============================================
// POST /api/pages/:pageId/follow - متابعة/إلغاء متابعة صفحة
// ============================================
app.post('/api/pages/:pageId/follow', authenticateToken, async (req, res) => {
    try {
        const { pageId } = req.params;
        
        const page = await PageSuggestion.findById(pageId);
        if (!page) {
            return res.status(404).json({ error: 'Page not found' });
        }
        
        const user = await User.findById(req.user.userId);
        if (!user.profile.followedPages) {
            user.profile.followedPages = [];
        }
        
        const isFollowing = user.profile.followedPages.includes(pageId);
        
        if (isFollowing) {
            user.profile.followedPages = user.profile.followedPages.filter(id => id.toString() !== pageId);
            await user.save();
            res.json({ success: true, isFollowing: false, message: 'Unfollowed page' });
        } else {
            user.profile.followedPages.push(pageId);
            await user.save();
            res.json({ success: true, isFollowing: true, message: 'Followed page' });
        }
        
    } catch (error) {
        logger.error(`Error following page: ${error.message}`);
        res.status(500).json({ error: 'Failed to follow page' });
    }
});

// ============================================
// GET /api/analytics/profile - جلب تحليلات الملف الشخصي (للمالك فقط)
// ============================================
app.get('/api/analytics/profile', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;
        
        // جلب أو إنشاء تحليلات المستخدم
        let analytics = await ProfileAnalytics.findOne({ userId });
        
        if (!analytics) {
            analytics = new ProfileAnalytics({ userId });
            await analytics.save();
        }
        
        // حساب الإحصائيات
        const profileViews = analytics.profileViews?.length || 0;
        const uniqueProfileViews = analytics.profileViews 
            ? new Set(analytics.profileViews.map(v => v.viewerId?.toString())).size 
            : 0;
        
        const postImpressions = analytics.postImpressions?.length || 0;
        const searchAppearances = analytics.searchAppearances?.length || 0;
        
        // جلب آخر 7 أيام من المشاهدات
        const last7Days = new Date();
        last7Days.setDate(last7Days.getDate() - 7);
        
        const weeklyViews = analytics.profileViews?.filter(v => 
            new Date(v.viewedAt) >= last7Days
        ).length || 0;
        
        res.json({
            views: profileViews,
            uniqueViews: uniqueProfileViews,
            weeklyViews: weeklyViews,
            impressions: postImpressions,
            searches: searchAppearances,
            lastUpdated: analytics.lastUpdated
        });
        
    } catch (error) {
        logger.error(`Error fetching profile analytics: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch profile analytics' });
    }
});

// ============================================
// POST /api/analytics/track-view - تسجيل مشاهدة للملف الشخصي
// ============================================
app.post('/api/analytics/track-view', async (req, res) => {
    try {
        const { targetUserId } = req.body;
        
        if (!targetUserId) {
            return res.status(400).json({ error: 'targetUserId is required' });
        }
        
        // ✅ لا تسجل مشاهدة لنفس المستخدم
        if (req.user?.userId === targetUserId) {
            return res.json({ success: true, message: 'Self view not tracked' });
        }
        
        // ============================
        // 📊 1. تسجيل في ProfileAnalytics (لكل المشاهدات)
        // ============================
        let analytics = await ProfileAnalytics.findOne({ userId: targetUserId });
        
        if (!analytics) {
            analytics = new ProfileAnalytics({ userId: targetUserId });
        }
        
        analytics.profileViews = analytics.profileViews || [];
        analytics.profileViews.push({
            viewerId: req.user?.userId || null,
            viewerIp: req.ip || req.headers['x-forwarded-for'] || req.connection.remoteAddress,
            viewedAt: new Date()
        });
        
        // ✅ الاحتفاظ بآخر 100 مشاهدة فقط
        if (analytics.profileViews.length > 100) {
            analytics.profileViews = analytics.profileViews.slice(-100);
        }
        
        analytics.lastUpdated = new Date();
        await analytics.save();
        
        // ============================
        // 👥 2. تسجيل في AlsoViewed (للمستخدمين المسجلين والزوار)
        // ============================
        const viewerIp = req.ip || req.headers['x-forwarded-for'] || req.connection.remoteAddress;
        
        if (req.user?.userId) {
            // ✅ مستخدم مسجل
            await AlsoViewed.findOneAndUpdate(
                { targetUserId, viewerId: req.user.userId },
                { 
                    viewedAt: new Date(),
                    viewerIp: viewerIp 
                },
                { upsert: true }
            );
        } else {
            // ✅ زائر (غير مسجل) - نستخدم IP
            const existingView = await AlsoViewed.findOne({
                targetUserId,
                viewerIp: viewerIp,
                viewedAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) }
            });
            
            if (!existingView) {
                await AlsoViewed.create({
                    targetUserId,
                    viewerId: null,
                    viewerIp: viewerIp,
                    viewedAt: new Date()
                });
            }
        }
        
        // ============================
        // 🏆 3. تحديث البرونزيات للمستخدم المستهدف
        // ============================
        const badgeResult = await updateUserBadges(targetUserId);
        
        // ✅ الرد مع بيانات البرونزيات
        res.json({
            success: true,
            message: 'View tracked successfully',
            badges: badgeResult,
            // ✅ أضف الإحصائيات للـ Frontend
            stats: {
                viewCount: badgeResult?.viewCount || 0,
                likeCount: badgeResult?.likeCount || 0,
                replyCount: badgeResult?.replyCount || 0,
                totalBadges: badgeResult?.totalBadgeCount || 0
            }
        });
        
    } catch (error) {
        logger.error(`Error tracking profile view: ${error.message}`);
        // ✅ لا نرسل خطأ للمستخدم حتى لا يسبب مشاكل
        res.json({ success: true });
    }
});
// ============================================
// POST /api/ratings - تقييم مستخدم
// ============================================
app.post('/api/ratings', authenticateToken, [
    body('targetUserId').isMongoId().withMessage('Valid user ID required'),
    body('rating').isInt({ min: 1, max: 5 }).withMessage('Rating must be between 1 and 5'),
    body('review').optional().isString().isLength({ max: 500 })
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const { targetUserId, rating, review } = req.body;
        const raterUserId = req.user.userId;
        
        // منع تقييم النفس
        if (targetUserId === raterUserId) {
            return res.status(400).json({ error: 'You cannot rate yourself' });
        }
        
        // التحقق من وجود المستخدم المستهدف
        const targetUser = await User.findById(targetUserId);
        if (!targetUser) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        // تحديث أو إنشاء تقييم
        const existingRating = await Rating.findOne({ targetUserId, raterUserId });
        
        if (existingRating) {
            existingRating.rating = rating;
            existingRating.review = review || existingRating.review;
            existingRating.updatedAt = new Date();
            await existingRating.save();
        } else {
            const newRating = new Rating({
                targetUserId,
                raterUserId,
                rating,
                review: review || ''
            });
            await newRating.save();
        }
        
        // حساب متوسط التقييمات للمستخدم
        const allRatings = await Rating.find({ targetUserId });
        const averageRating = allRatings.reduce((sum, r) => sum + r.rating, 0) / allRatings.length;
        
        // تحديث متوسط التقييم في ملف المستخدم
        await User.findByIdAndUpdate(targetUserId, {
            'profile.averageRating': averageRating,
            'profile.totalRatings': allRatings.length
        });
        
        // إشعار للمستخدم المستهدف
        const rater = await User.findById(raterUserId).select('username profile.nickname');
        const raterName = rater?.profile?.nickname || rater?.username || 'Someone';
        
        await Notification.create({
            userId: targetUserId,
            type: 'system',
            content: `${raterName} rated you ${rating} stars${review ? `: "${review.substring(0, 50)}"` : ''}`,
            targetId: targetUserId,
            targetType: 'rating',
            read: false
        });
        
        res.json({
            success: true,
            message: 'Rating submitted successfully',
            averageRating: averageRating,
            totalRatings: allRatings.length
        });
        
    } catch (error) {
        logger.error(`Error submitting rating: ${error.message}`);
        res.status(500).json({ error: 'Failed to submit rating' });
    }
});

// ============================================
// GET /api/ratings/:userId - جلب تقييمات مستخدم
// ============================================
app.get('/api/ratings/:userId', async (req, res) => {
    try {
        const { userId } = req.params;
        const { page = 1, limit = 10 } = req.query;
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        const ratings = await Rating.find({ targetUserId: userId })
            .sort({ createdAt: -1 })
            .skip(skip)
            .limit(parseInt(limit))
            .populate('raterUserId', 'username profile.nickname profile.avatar profile.jobTitle');
        
        const total = await Rating.countDocuments({ targetUserId: userId });
        
        // حساب متوسط التقييمات
        const allRatings = await Rating.find({ targetUserId: userId });
        const averageRating = allRatings.length > 0 
            ? allRatings.reduce((sum, r) => sum + r.rating, 0) / allRatings.length 
            : 0;
        
        res.json({
            success: true,
            data: ratings,
            averageRating,
            totalRatings: total,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
        
    } catch (error) {
        logger.error(`Error fetching ratings: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch ratings' });
    }
});



// ============================================
// POST /api/messages/:messageId/report - التبليغ عن رسالة مخالفة
// ============================================
app.post('/api/messages/:messageId/report', authenticateToken, [
    body('reason').notEmpty().withMessage('Reason is required')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }

    try {
        const { messageId } = req.params;
        const { reason } = req.body;
        
        // التحقق من وجود الرسالة
        const message = await Message.findById(messageId)
            .populate('senderId', 'username email profile.nickname');
        
        if (!message) {
            return res.status(404).json({ error: 'Message not found' });
        }
        
        // منع التبليغ عن رسالتك الخاصة
        if (message.senderId._id.toString() === req.user.userId) {
            return res.status(400).json({ error: 'You cannot report your own message' });
        }
        
        // التحقق من عدم تكرار التبليغ من نفس المستخدم
        const existingReport = await MessageReport.findOne({
            messageId,
            reporterId: req.user.userId
        });
        
        if (existingReport) {
            return res.status(400).json({ error: 'You already reported this message' });
        }
        
        // إنشاء تقرير جديد
        const report = new MessageReport({
            messageId,
            reporterId: req.user.userId,
            reporterUsername: req.user.username,
            reportedUserId: message.senderId._id,
            reason: reason,
            messageContent: message.text,
            messageAttachments: message.attachments,
            conversationId: message.conversationId,
            status: 'pending',
            reportedAt: new Date()
        });
        
        await report.save();
        
        // ✅ إشعار للمشرفين
        const adminUsers = await User.find({ isAdmin: true });
        for (const admin of adminUsers) {
            // إضافة إشعار في Notification model
            await Notification.create({
                userId: admin._id,
                type: 'admin_report',
                actorId: req.user.userId,
                actorName: req.user.username,
                targetId: report._id,
                targetType: 'message_report',
                content: `🚨 New message report from ${req.user.username} against ${message.senderId.profile?.nickname || message.senderId.username}`,
                link: `/admin/messages?report=${report._id}`,
                read: false
            });
            
            // ✅ إضافة إشعار في User.notifications (للتطابق مع القديم)
            admin.notifications = admin.notifications || [];
            admin.notifications.push({
                message: `🚨 New message report from ${req.user.username} against ${message.senderId.profile?.nickname || message.senderId.username}: "${message.text.substring(0, 80)}${message.text.length > 80 ? '...' : ''}"`,
                type: 'admin_report',
                link: `/admin/messages?report=${report._id}`,
                read: false,
                createdAt: new Date(),
                metadata: {
                    reportId: report._id,
                    messageId: messageId,
                    reporterId: req.user.userId,
                    reportedUserId: message.senderId._id
                }
            });
            await admin.save();
        }
        
        // ✅ إشعار لصاحب الرسالة (اختياري - تنبيه)
        const reportedUser = await User.findById(message.senderId._id);
        if (reportedUser && reportedUser._id.toString() !== req.user.userId) {
            reportedUser.notifications = reportedUser.notifications || [];
            reportedUser.notifications.push({
                message: `⚠️ Your message has been reported to admins for review: "${message.text.substring(0, 60)}${message.text.length > 60 ? '...' : ''}"`,
                type: 'warning',
                link: `/messages.html?conversation=${message.conversationId}`,
                read: false,
                createdAt: new Date(),
                metadata: { messageId: messageId, reportId: report._id }
            });
            await reportedUser.save();
        }
        
        // ✅ إرسال بريد إلكتروني للمشرفين (اختياري)
        try {
            for (const admin of adminUsers) {
                await sendEmailWithBrevo(
                    admin.email,
                    '🚨 New Message Report - MGZon',
                    `
                    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
                        <h2 style="color: #ef4444;">New Message Report</h2>
                        <p><strong>Reported by:</strong> ${req.user.username}</p>
                        <p><strong>Message author:</strong> ${message.senderId.profile?.nickname || message.senderId.username}</p>
                        <p><strong>Reason:</strong> ${reason}</p>
                        <div style="background: #f3f4f6; padding: 12px; border-radius: 8px; margin: 16px 0;">
                            <p><strong>Message content:</strong></p>
                            <p>"${message.text}"</p>
                        </div>
                        <a href="${FRONTEND_URL}/admin/messages?report=${report._id}" 
                           style="display: inline-block; background: #3b82f6; color: white; padding: 10px 20px; border-radius: 8px; text-decoration: none;">
                            Review Report
                        </a>
                    </div>
                    `,
                    `New message report from ${req.user.username}`
                );
            }
        } catch (emailError) {
            logger.error(`Failed to send admin email: ${emailError.message}`);
        }
        
        logger.info(`Message ${messageId} reported by user ${req.user.userId}`);
        res.status(201).json({ 
            success: true, 
            message: 'Report submitted successfully. Our team will review it shortly.',
            reportId: report._id
        });
        
    } catch (error) {
        logger.error(`Error reporting message: ${error.message}`);
        res.status(500).json({ error: 'Failed to submit report' });
    }
});

// ============================================
// GET /api/admin/messages/reports - جلب تقارير الرسائل (للمشرف فقط)
// ============================================
app.get('/api/admin/messages/reports', authenticateToken, isAdmin, async (req, res) => {
    try {
        const { status, page = 1, limit = 20 } = req.query;
        const skip = (parseInt(page) - 1) * parseInt(limit);
        
        let query = {};
        if (status && status !== 'all') {
            query.status = status;
        }
        
        const reports = await MessageReport.find(query)
            .sort({ reportedAt: -1 })
            .skip(skip)
            .limit(parseInt(limit))
            .populate('reporterId', 'username profile.nickname profile.avatar')
            .populate('reportedUserId', 'username profile.nickname profile.avatar');
        
        const total = await MessageReport.countDocuments(query);
        
        res.json({
            success: true,
            data: reports,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
        
    } catch (error) {
        logger.error(`Error fetching message reports: ${error.message}`);
        res.status(500).json({ error: 'Failed to fetch reports' });
    }
});

// ============================================
// PUT /api/admin/messages/reports/:reportId/resolve - حل تبليغ رسالة (للمشرف فقط)
// ============================================
app.put('/api/admin/messages/reports/:reportId/resolve', authenticateToken, isAdmin, [
    body('action').isIn(['dismiss', 'warn', 'delete', 'hide']),
    body('adminNote').optional().isString()
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    
    try {
        const { reportId } = req.params;
        const { action, adminNote } = req.body;
        
        const report = await MessageReport.findById(reportId);
        if (!report) {
            return res.status(404).json({ error: 'Report not found' });
        }
        
        report.status = 'resolved';
        report.resolvedAt = new Date();
        report.resolvedBy = req.user.userId;
        report.adminNote = adminNote || '';
        report.resolution = action;
        await report.save();
        
        // تنفيذ الإجراء بناءً على الاختيار
        let actionMessage = '';
        if (action === 'delete') {
            await Message.findByIdAndDelete(report.messageId);
            actionMessage = 'The reported message has been deleted.';
        } else if (action === 'hide') {
            await Message.findByIdAndUpdate(report.messageId, { hidden: true });
            actionMessage = 'The reported message has been hidden.';
        } else if (action === 'warn') {
            actionMessage = 'A warning has been issued to the user.';
        } else {
            actionMessage = 'The report has been dismissed.';
        }
        
        // إشعار للمبلغ
        await Notification.create({
            userId: report.reporterId,
            type: 'system',
            content: `✅ Your message report has been reviewed. ${actionMessage}`,
            targetId: report._id,
            targetType: 'report',
            read: false
        });
        
        res.json({ success: true, message: 'Report resolved successfully' });
        
    } catch (error) {
        logger.error(`Error resolving report: ${error.message}`);
        res.status(500).json({ error: 'Failed to resolve report' });
    }
});


// ============================================
// GET /api/websocket/config - جلب إعدادات WebSocket
// ============================================
app.get('/api/websocket/config', authenticateToken, async (req, res) => {
    try {
        const wsUrl = process.env.WEBSOCKET_URL;
        
        if (!wsUrl) {
            logger.warn('WEBSOCKET_URL not configured in environment variables');
            return res.json({ 
                url: null, 
                enabled: false,
                message: 'WebSocket not configured'
            });
        }
        
        res.json({
            url: wsUrl,
            enabled: true,
            version: '1.0.0'
        });
        
    } catch (error) {
        logger.error(`Error getting WebSocket config: ${error.message}`);
        res.status(500).json({ 
            url: null, 
            enabled: false,
            error: error.message 
        });
    }
});


// ============================================
// POST /api/websocket/token - توليد token للـ WebSocket
// ============================================
app.post('/api/websocket/token', authenticateToken, async (req, res) => {
    try {
        // توليد token قصير العمر (ساعة واحدة)
        const wsToken = jwt.sign(
            { userId: req.user.userId, purpose: 'websocket' },
            process.env.JWT_SECRET,
            { expiresIn: '30d' }
        );
        
        res.json({ token: wsToken });
    } catch (error) {
        logger.error(`Error generating WebSocket token: ${error.message}`);
        res.status(500).json({ error: 'Failed to generate token' });
    }
});



// ============================================
// ============================================
// 🥇 برونزيات
// ============================================
// ============================================
// ============================================
// 🥇 برونزيات المشاهدات (Profile Views)
// ============================================
const VIEW_BADGE_THRESHOLDS = {
    SILVER: 20,
    GOLD: 100,
    RED: 200
};

const VIEW_BADGE_ICONS = {
    silver: '/assets/img/fire.svg',
    gold: '/assets/img/firegolden.svg',
    red: '/assets/img/firered.svg'
};

// ============================================
// ❤️ برونزيات الإعجابات (Post Likes)
// ============================================
const LIKE_BADGE_THRESHOLDS = {
    BRONZE: 10,
    RED: 128,
    SILVER: 512,
    GOLD: 4096
};

const LIKE_BADGE_ICONS = {
    bronze: '/assets/img/StarStruck_SkinTone1.png',
    red: '/assets/img/StarStruck_Bronze.png',
    silver: '/assets/img/StarStruck_Silver.png',
    gold: '/assets/img/StarStruck_Gold.png'
};

// ============================================
// 💬 برونزيات التفاعل (Comments/Replies)
// ============================================
const INTERACTION_BADGE_THRESHOLDS = {
    BRONZE: 10  // 10 ردود على تعليقات الآخرين
};

const INTERACTION_BADGE_ICONS = {
    bronze: '/assets/img/QuickDraw_SkinTone1.png'
};


/**
 * الحصول على أيقونة البرونزية المناسبة حسب النوع والمستوى
 * @param {string} type - نوع البرونزية: 'views', 'likes', 'interaction'
 * @param {string} level - المستوى: 'silver', 'gold', 'red', 'bronze'
 * @returns {string} - مسار الأيقونة
 */
function getBadgeIcon(type, level) {
    // ✅ برونزيات المشاهدات
    if (type === 'views') {
        if (level === 'silver') return VIEW_BADGE_ICONS.silver;
        if (level === 'gold') return VIEW_BADGE_ICONS.gold;
        if (level === 'red') return VIEW_BADGE_ICONS.red;
    }
    
    // ✅ برونزيات الإعجابات
    if (type === 'likes') {
        if (level === 'bronze') return LIKE_BADGE_ICONS.bronze;
        if (level === 'red') return LIKE_BADGE_ICONS.red;
        if (level === 'silver') return LIKE_BADGE_ICONS.silver;
        if (level === 'gold') return LIKE_BADGE_ICONS.gold;
    }
    
    // ✅ برونزيات التفاعل
    if (type === 'interaction') {
        if (level === 'bronze') return INTERACTION_BADGE_ICONS.bronze;
    }
    
    // ✅ أيقونة افتراضية
    return '/assets/img/default-badge.png';
}

/**
 * حساب عدد المشاهدات الفريدة للمستخدم
 */
async function getUniqueViewsCount(userId) {
    const analytics = await ProfileAnalytics.findOne({ userId });
    if (!analytics || !analytics.profileViews) return 0;
    
    // ✅ عدد المشاهدين الفريدين (منع تكرار المشاهدات)
    const uniqueViewers = new Set();
    analytics.profileViews.forEach(view => {
        if (view.viewerId) {
            uniqueViewers.add(view.viewerId.toString());
        } else if (view.viewerIp) {
            uniqueViewers.add(view.viewerIp);
        }
    });
    
    return uniqueViewers.size;
}

/**
 * حساب عدد الإعجابات التي حصلت عليها منشورات المستخدم
 */
async function getTotalPostLikes(userId) {
    const posts = await Post.find({ userId }).select('likes').lean();
    let totalLikes = 0;
    posts.forEach(post => {
        totalLikes += post.likes?.length || 0;
    });
    return totalLikes;
}

/**
 * حساب عدد ردود المستخدم على تعليقات الآخرين
 * (تشمل ردود على تعليقات المنشورات + ردود على تعليقات المشاريع)
 */
async function getTotalUserReplies(userId) {
    let totalReplies = 0;
    
    try {
        // ✅ 1. ردود المستخدم على تعليقات الآخرين في المنشورات (Post.comments.replies)
        const posts = await Post.find({}).select('comments').lean();
        posts.forEach(post => {
            post.comments?.forEach(comment => {
                comment.replies?.forEach(reply => {
                    if (reply.userId && reply.userId.toString() === userId.toString()) {
                        totalReplies++;
                    }
                });
            });
        });
        
        // ✅ 2. ردود المستخدم على تعليقات الآخرين في المشاريع (Comment.replies)
        const projectComments = await Comment.find({}).select('replies').lean();
        projectComments.forEach(comment => {
            comment.replies?.forEach(reply => {
                if (reply.userId && reply.userId.toString() === userId.toString()) {
                    totalReplies++;
                }
            });
        });
        
    } catch (error) {
        console.error('Error calculating total user replies:', error);
    }
    
    return totalReplies;
}

/**
 * حساب جميع البرونزيات المستحقة
 */
function calculateAllBadges(viewCount, likeCount, replyCount) {
    const result = {
        views: { silver: false, gold: false, red: false, count: 0 },
        likes: { bronze: false, silver: false, gold: false, red: false, count: 0 },
        interaction: { bronze: false, count: 0 }
    };
    
    // ✅ برونزيات المشاهدات
    if (viewCount >= VIEW_BADGE_THRESHOLDS.RED) {
        result.views.red = true;
        result.views.gold = true;
        result.views.silver = true;
        result.views.count = 3;
    } else if (viewCount >= VIEW_BADGE_THRESHOLDS.GOLD) {
        result.views.gold = true;
        result.views.silver = true;
        result.views.count = 2;
    } else if (viewCount >= VIEW_BADGE_THRESHOLDS.SILVER) {
        result.views.silver = true;
        result.views.count = 1;
    }
    
    // ✅ برونزيات الإعجابات
    if (likeCount >= LIKE_BADGE_THRESHOLDS.GOLD) {
        result.likes.gold = true;
        result.likes.silver = true;
        result.likes.red = true;
        result.likes.bronze = true;
        result.likes.count = 4;
    } else if (likeCount >= LIKE_BADGE_THRESHOLDS.SILVER) {
        result.likes.silver = true;
        result.likes.red = true;
        result.likes.bronze = true;
        result.likes.count = 3;
    } else if (likeCount >= LIKE_BADGE_THRESHOLDS.RED) {
        result.likes.red = true;
        result.likes.bronze = true;
        result.likes.count = 2;
    } else if (likeCount >= LIKE_BADGE_THRESHOLDS.BRONZE) {
        result.likes.bronze = true;
        result.likes.count = 1;
    }
    
    // ✅ برونزيات التفاعل
    if (replyCount >= INTERACTION_BADGE_THRESHOLDS.BRONZE) {
        result.interaction.bronze = true;
        result.interaction.count = 1;
    }
    
    return result;
}

/**
 * تحديث البرونزيات للمستخدم
 */
async function updateUserBadges(userId) {
    try {
        console.log("========== updateUserBadges ==========");
        // ✅ جلب جميع البيانات
        const viewCount = await getUniqueViewsCount(userId);
        const likeCount = await getTotalPostLikes(userId);
        const replyCount = await getTotalUserReplies(userId);

        console.log({
            viewCount,
            likeCount,
            replyCount
        });
        
        const badges = calculateAllBadges(viewCount, likeCount, replyCount);

        console.log("Calculated badges:");
        console.log(badges);
        
        const user = await User.findById(userId);

        if (!user) return null;

        console.log("Before:");
        console.log(JSON.stringify(user.profile.badges, null, 2));

        // ✅ تهيئة البرونزيات
        if (!user.profile.badges) {
            user.profile.badges = {
                views: { silver: false, gold: false, red: false },
                likes: { bronze: false, silver: false, gold: false, red: false },
                interaction: { bronze: false },
                unlockedAt: null,
                updatedAt: Date.now()
            };
        }
        
        // ✅ تأكد من وجود الحقول الفرعية
        if (!user.profile.badges.views) {
            user.profile.badges.views = { silver: false, gold: false, red: false };
        }
        if (!user.profile.badges.likes) {
            user.profile.badges.likes = { bronze: false, silver: false, gold: false, red: false };
        }
        if (!user.profile.badges.interaction) {
            user.profile.badges.interaction = { bronze: false };
        }
        
        let newBadgeUnlocked = false;
        let unlockedBadges = [];
        let unlockedBadgeIcons = [];
        
        // ✅ تحقق من برونزيات المشاهدات - استخدم getBadgeIcon
        if (badges.views.silver && !user.profile.badges.views.silver) {
            user.profile.badges.views.silver = true;
            newBadgeUnlocked = true;
            unlockedBadges.push('Views Silver');
            unlockedBadgeIcons.push(getBadgeIcon('views', 'silver'));
        }

        console.log("After:");
        console.log(JSON.stringify(user.profile.badges, null, 2));


        if (badges.views.gold && !user.profile.badges.views.gold) {
            user.profile.badges.views.gold = true;
            newBadgeUnlocked = true;
            unlockedBadges.push('Views Gold');
            unlockedBadgeIcons.push(getBadgeIcon('views', 'gold'));
        }
        if (badges.views.red && !user.profile.badges.views.red) {
            user.profile.badges.views.red = true;
            newBadgeUnlocked = true;
            unlockedBadges.push('Views Red');
            unlockedBadgeIcons.push(getBadgeIcon('views', 'red'));
        }
        
        // ✅ تحقق من برونزيات الإعجابات - استخدم getBadgeIcon
        if (badges.likes.bronze && !user.profile.badges.likes.bronze) {
            user.profile.badges.likes.bronze = true;
            newBadgeUnlocked = true;
            unlockedBadges.push('Likes Bronze');
            unlockedBadgeIcons.push(getBadgeIcon('likes', 'bronze'));
        }
        if (badges.likes.red && !user.profile.badges.likes.red) {
            user.profile.badges.likes.red = true;
            newBadgeUnlocked = true;
            unlockedBadges.push('Likes Red');
            unlockedBadgeIcons.push(getBadgeIcon('likes', 'red'));
        }
        if (badges.likes.silver && !user.profile.badges.likes.silver) {
            user.profile.badges.likes.silver = true;
            newBadgeUnlocked = true;
            unlockedBadges.push('Likes Silver');
            unlockedBadgeIcons.push(getBadgeIcon('likes', 'silver'));
        }
        if (badges.likes.gold && !user.profile.badges.likes.gold) {
            user.profile.badges.likes.gold = true;
            newBadgeUnlocked = true;
            unlockedBadges.push('Likes Gold');
            unlockedBadgeIcons.push(getBadgeIcon('likes', 'gold'));
        }
        
        // ✅ تحقق من برونزيات التفاعل - استخدم getBadgeIcon
        if (badges.interaction.bronze && !user.profile.badges.interaction.bronze) {
            user.profile.badges.interaction.bronze = true;
            newBadgeUnlocked = true;
            unlockedBadges.push('Interaction Bronze');
            unlockedBadgeIcons.push(getBadgeIcon('interaction', 'bronze'));
        }
        
        user.profile.badges.updatedAt = Date.now();
        
        if (newBadgeUnlocked) {
            user.profile.badges.unlockedAt = Date.now();
            const badgeList = unlockedBadges.join(', ');
            
            // ✅ 1. إشعار في User.notifications (جوه الـ User)
            user.notifications = user.notifications || [];
            user.notifications.push({
                message: `🎉 Congratulations! You unlocked new badges: ${badgeList}! ${unlockedBadgeIcons.join(' ')}`,
                type: 'success',
                link: '/profile/me',
                read: false,
                createdAt: new Date(),
                metadata: {
                    badges: unlockedBadges,
                    badgeIcons: unlockedBadgeIcons,
                    viewCount,
                    likeCount,
                    replyCount
                }
            });
            
            // ✅ 2. إشعار في Notification model (منفصل)
            try {
                await Notification.create({
                    userId: userId,
                    type: 'system',
                    actorId: userId,
                    actorName: 'System',
                    content: `🎉 You unlocked ${unlockedBadges.length} new badge(s): ${badgeList}! ${unlockedBadgeIcons.join(' ')}`,
                    read: false,
                    createdAt: new Date(),
                    metadata: {
                        badges: unlockedBadges,
                        badgeIcons: unlockedBadgeIcons,
                        viewCount,
                        likeCount,
                        replyCount
                    }
                });
            } catch (notifError) {
                console.error('Error creating notification in Notification model:', notifError);
            }
            
            console.log(`🏆 Badges unlocked for user ${userId}: ${badgeList}`);
        }
        
        user.markModified("profile");

        console.log("Saving...");

        // ✅ حفظ المستخدم
        await user.save();
        
        // ✅ تأكد من الحفظ
        const savedUser = await User.findById(userId).select('profile.badges').lean();
        console.log(
            "Saved:",
            JSON.stringify(savedUser?.profile?.badges, null, 2)
        );
        
        return {
            badges: user.profile.badges,
            viewCount,
            likeCount,
            replyCount,
            newBadgeUnlocked,
            unlockedBadges,
            totalBadgeCount: badges.views.count + badges.likes.count + badges.interaction.count
        };
        
    } catch (error) {
        console.error('Error updating badges:', error);
        return null;
    }
}



/**
 * جلب حالة البرونزيات للمستخدم (المفتوحة فقط + الأيقونات)
 */
async function getUserBadges(userId) {
    try {
        const user = await User.findById(userId).select('profile.badges').lean();
        if (!user || !user.profile?.badges) {
            return {
                unlocked: [],
                totalCount: 0,
                views: { unlocked: [], count: 0 },
                likes: { unlocked: [], count: 0 },
                interaction: { unlocked: [], count: 0 }
            };
        }
        
        const badges = user.profile.badges;
        const result = {
            views: { unlocked: [], count: 0 },
            likes: { unlocked: [], count: 0 },
            interaction: { unlocked: [], count: 0 },
            unlocked: [],
            totalCount: 0
        };
        
        // ✅ برونزيات المشاهدات - استخدم getBadgeIcon
        if (badges.views?.silver) {
            result.views.unlocked.push({ 
                name: 'Views Silver', 
                icon: getBadgeIcon('views', 'silver'),
                key: 'silver',
                type: 'views'
            });
            result.views.count++;
        }
        if (badges.views?.gold) {
            result.views.unlocked.push({ 
                name: 'Views Gold', 
                icon: getBadgeIcon('views', 'gold'),
                key: 'gold',
                type: 'views'
            });
            result.views.count++;
        }
        if (badges.views?.red) {
            result.views.unlocked.push({ 
                name: 'Views Red', 
                icon: getBadgeIcon('views', 'red'),
                key: 'red',
                type: 'views'
            });
            result.views.count++;
        }
        
        // ✅ برونزيات الإعجابات - استخدم getBadgeIcon
        if (badges.likes?.bronze) {
            result.likes.unlocked.push({ 
                name: 'Likes Bronze', 
                icon: getBadgeIcon('likes', 'bronze'),
                key: 'bronze',
                type: 'likes'
            });
            result.likes.count++;
        }
        if (badges.likes?.red) {
            result.likes.unlocked.push({ 
                name: 'Likes Red', 
                icon: getBadgeIcon('likes', 'red'),
                key: 'red',
                type: 'likes'
            });
            result.likes.count++;
        }
        if (badges.likes?.silver) {
            result.likes.unlocked.push({ 
                name: 'Likes Silver', 
                icon: getBadgeIcon('likes', 'silver'),
                key: 'silver',
                type: 'likes'
            });
            result.likes.count++;
        }
        if (badges.likes?.gold) {
            result.likes.unlocked.push({ 
                name: 'Likes Gold', 
                icon: getBadgeIcon('likes', 'gold'),
                key: 'gold',
                type: 'likes'
            });
            result.likes.count++;
        }
        
        // ✅ برونزيات التفاعل - استخدم getBadgeIcon
        if (badges.interaction?.bronze) {
            result.interaction.unlocked.push({ 
                name: 'Interaction Bronze', 
                icon: getBadgeIcon('interaction', 'bronze'),
                key: 'bronze',
                type: 'interaction'
            });
            result.interaction.count++;
        }
        
        // ✅ تجميع الكل
        result.unlocked = [
            ...result.views.unlocked,
            ...result.likes.unlocked,
            ...result.interaction.unlocked
        ];
        result.totalCount = result.unlocked.length;
        
        return result;
        
    } catch (error) {
        console.error('Error getting badges:', error);
        return {
            unlocked: [],
            totalCount: 0,
            views: { unlocked: [], count: 0 },
            likes: { unlocked: [], count: 0 },
            interaction: { unlocked: [], count: 0 }
        };
    }
}


// ============================================
// ============================================
// 🤖 AI BOT HELPER FUNCTIONS
// ============================================
// ============================================

// 1. بناء سياق البروفايل (Profile Context)
function buildProfileContext(user) {
    const p = user.profile || {};
    
    // المهارات
    let skillsText = '';
    if (p.skills && p.skills.length > 0) {
        const skillsList = p.skills.map(s => `${s.name} (${s.percentage}%)`).join(', ');
        skillsText = `مهاراته: ${skillsList}. `;
    }
    
    // المشاريع (أول 5 مشاريع)
    let projectsText = '';
    if (p.projects && p.projects.length > 0) {
        const topProjects = p.projects.slice(0, 5);
        projectsText = topProjects.map(proj => 
            `"${proj.title}"${proj.description ? `: ${proj.description.substring(0, 100)}` : ''}`
        ).join('; ');
        projectsText = `أبرز مشاريعه: ${projectsText}. `;
    }
    
    // الخبرات
    let expText = '';
    if (p.experience && p.experience.length > 0) {
        expText = p.experience.map(exp => 
            `${exp.role} في ${exp.company} (${exp.duration})`
        ).join('; ');
        expText = `خبراته: ${expText}. `;
    }
    
    // التعليم
    let eduText = '';
    if (p.education && p.education.length > 0) {
        eduText = p.education.map(edu => 
            `${edu.degree} من ${edu.institution} (${edu.year})`
        ).join('; ');
        eduText = `تعليمه: ${eduText}. `;
    }
    
    // الشهادات
    let certText = '';
    if (p.certificates && p.certificates.length > 0) {
        certText = p.certificates.map(cert => 
            `${cert.name} من ${cert.issuer}`
        ).join('; ');
        certText = `شهاداته: ${certText}. `;
    }
    
    // الاهتمامات
    let interestsText = '';
    if (p.interests && p.interests.length > 0) {
        interestsText = `اهتماماته: ${p.interests.join(', ')}. `;
    }
    
    // السيرة الذاتية
    const bioText = p.bio ? `السيرة الذاتية: ${p.bio}. ` : '';
    
    // الصناعة
    const industryText = p.industry ? `يعمل في مجال ${p.industry}. ` : '';
    
    // الموقع
    const locationText = p.location ? `موقعه: ${p.location}. ` : '';
    
    // المسمى الوظيفي
    const jobTitleText = p.jobTitle ? `المسمى الوظيفي: ${p.jobTitle}. ` : '';
    
    // الحالة
    const statusText = p.status ? `حالته المهنية: ${p.status}. ` : '';
    
    // الروابط الاجتماعية
    let socialText = '';
    if (p.socialLinks) {
        const links = [];
        if (p.socialLinks.linkedin) links.push(`LinkedIn: ${p.socialLinks.linkedin}`);
        if (p.socialLinks.github) links.push(`GitHub: ${p.socialLinks.github}`);
        if (p.socialLinks.behance) links.push(`Behance: ${p.socialLinks.behance}`);
        if (links.length) socialText = `روابطه: ${links.join(', ')}. `;
    }
    
    // اسم المستخدم
    const displayName = p.nickname || user.username || 'هذا الشخص';
    
    return `
أنت مساعد ذكي خاص بـ ${displayName}.
مهمتك: الإجابة على الأسئلة عن هذا الشخص فقط، بناءً على البيانات المتوفرة.

⚠️ قواعد صارمة:
1. لا تقدم أي معلومات غير موجودة في البيانات أدناه.
2. إذا سألك عن شيء خارج بياناته، قل: "هذه المعلومات غير متوفرة في ملفه الشخصي."
3. تحدث بضمير الغائب (هو، هي، هو يعمل، هي تدرس). لا تستخدم "أنا" أو "نحن".
4. استخدم نفس لغة السؤال (عربي، إنجليزي، فرنسي).
5. كن مهذباً ومحترفاً، وأجب بإيجاز (حد أقصى 3-4 جمل).
6. لا تذكر أنك مساعد ذكي أو بوت.

📋 بيانات ${displayName}:
${bioText}
${industryText}
${locationText}
${statusText}
${jobTitleText}
${expText}
${eduText}
${certText}
${skillsText}
${projectsText}
${interestsText}
${socialText}

الآن، أجب على سؤال الزائر عن ${displayName} فقط، بضمير الغائب، وباختصار:
    `;
}

// 1. كشف اللغة تلقائياً
function detectLanguage(text) {
    const arabicPattern = /[\u0600-\u06FF]/;
    if (arabicPattern.test(text)) return 'ar';
    
    const englishPattern = /[a-zA-Z]/;
    if (englishPattern.test(text)) return 'en';
    
    const frenchPattern = /[éèêëàâçùûüïî]/i;
    if (frenchPattern.test(text)) return 'fr';
    
    const germanPattern = /[äöüß]/i;
    if (germanPattern.test(text)) return 'de';
    
    const spanishPattern = /[áéíóúñ]/i;
    if (spanishPattern.test(text)) return 'es';
    
    return 'ar';
}



// 1.6 بناء سياق للمالك (يتكلم مع نفسه بضمير المخاطب)
function buildProfileContextForOwner(user, language = 'ar') {
    const p = user.profile || {};
    const displayName = p.nickname || user.username || 'أنت';
    
    const translations = {
        ar: {
            assistant: `أنت ${displayName}. أنت تتحدث مع نفسك عن ملفك الشخصي.`,
            mission: 'أنت تنظر إلى ملفك الشخصي وتتحدث عنه.',
            rulesTitle: '⚠️ قواعد مهمة:',
            rule1: '1. تحدث دائماً بضمير المخاطب "أنت" (أنت تملك، أنت تعمل، مهاراتك، خبراتك).',
            rule2: '2. لا تقل "أنا" أو "عندي" أبداً - لأنك تتحدث مع نفسك.',
            rule3: '3. جاوب فقط بناءً على البيانات الموجودة في ملفك الشخصي أدناه.',
            rule4: '4. استخدم نفس لغة السؤال (عربي، إنجليزي، فرنسي).',
            rule5: '5. كن مختصراً ومباشراً (حد أقصى 3-4 جمل).',
            rule6: '6. إذا سألت عن شيء غير موجود، قل: "هذه المعلومات غير متوفرة في ملفي الشخصي."',
            dataTitle: `📋 ملفك الشخصي (${displayName}):`,
            skills: 'مهاراتك',
            projects: 'مشاريعك',
            experience: 'خبراتك العملية',
            education: 'تعليمك',
            certificates: 'شهاداتك',
            customSections: 'الأقسام المخصصة',  // للعربية

            interests: 'اهتماماتك',
            bio: 'سيرتك الذاتية',
            industry: 'مجالك',
            location: 'موقعك',
            jobTitle: 'مسماك الوظيفي',
            status: 'حالتك المهنية',
            socialLinks: 'روابطك الاجتماعية',
            prompt: 'الآن، أجب عن نفسك بضمير المخاطب "أنت" وباختصار:'
        },
        en: {
            assistant: `You are ${displayName}. You are talking to yourself about your profile.`,
            mission: 'You are reviewing your own profile and talking about it.',
            rulesTitle: '⚠️ Important Rules:',
            rule1: '1. Always use second person "you" (you have, you work, your skills, your experience).',
            rule2: '2. Never say "I" or "my" - because you are talking to yourself.',
            rule3: '3. Answer only based on your profile data below.',
            rule4: '4. Use the same language as the question (Arabic, English, French).',
            rule5: '5. Be concise and direct (max 3-4 sentences).',
            rule6: '6. If asked about something not in your data, say: "This information is not available in my profile."',
            dataTitle: `📋 Your Profile (${displayName}):`,
            skills: 'Your skills',
            projects: 'Your projects',
            experience: 'Your work experience',
            education: 'Your education',
            certificates: 'Your certificates',
            interests: 'Your interests',
            bio: 'Your bio',
            industry: 'Your industry',
            location: 'Your location',
            customSections: 'Custom Sections',  // للإنجليزية
            jobTitle: 'Your job title',
            status: 'Your professional status',
            socialLinks: 'Your social links',
            prompt: 'Now, answer about yourself using "you" briefly:'
        }
    };
    
    const t = translations[language] || translations.en;
    
    // بناء البيانات بشكل أنظف
    let dataText = '';
    const dataItems = [];
    
    if (p.bio) dataItems.push(`${t.bio}: ${p.bio.substring(0, 200)}`);
    if (p.jobTitle) dataItems.push(`${t.jobTitle}: ${p.jobTitle}`);
    if (p.industry) dataItems.push(`${t.industry}: ${p.industry}`);
    if (p.location) dataItems.push(`${t.location}: ${p.location}`);
    if (p.status) dataItems.push(`${t.status}: ${p.status}`);
    
    if (p.skills?.length > 0) {
        const skillsText = p.skills.slice(0, 10).map(s => `${s.name} (${s.percentage}%)`).join(', ');
        dataItems.push(`${t.skills}: ${skillsText}`);
    }
    
    if (p.experience?.length > 0) {
        const expText = p.experience.slice(0, 5).map(exp => `${exp.role} في ${exp.company} (${exp.duration})`).join('; ');
        dataItems.push(`${t.experience}: ${expText}`);
    }
    
    if (p.projects?.length > 0) {
        const projectsText = p.projects.slice(0, 5).map(proj => `"${proj.title}"`).join(', ');
        dataItems.push(`${t.projects}: ${projectsText}`);
    }
    
    if (p.education?.length > 0) {
        const eduText = p.education.slice(0, 3).map(edu => `${edu.degree} من ${edu.institution} (${edu.year})`).join('; ');
        dataItems.push(`${t.education}: ${eduText}`);
    }
    
    if (p.certificates?.length > 0) {
        const certText = p.certificates.slice(0, 3).map(cert => `${cert.name} من ${cert.issuer}`).join('; ');
        dataItems.push(`${t.certificates}: ${certText}`);
    }
    
    if (p.interests?.length > 0) {
        dataItems.push(`${t.interests}: ${p.interests.slice(0, 10).join(', ')}`);
    }
    
    if (p.socialLinks) {
        const links = [];
        if (p.socialLinks.linkedin) links.push(`LinkedIn: ${p.socialLinks.linkedin}`);
        if (p.socialLinks.github) links.push(`GitHub: ${p.socialLinks.github}`);
        if (links.length) dataItems.push(`${t.socialLinks}: ${links.join(', ')}`);
    }

    // ✅ الأقسام المخصصة (Custom Sections)
    if (p.customSections && p.customSections.length > 0) {
        const visibleSections = p.customSections.filter(s => s.isVisible !== false);
        if (visibleSections.length > 0) {
            const customSectionsText = visibleSections.map(section => {
                if (section.type === 'text') {
                    return `${section.name}: ${section.content?.text || ''}`;
                } else if (section.type === 'skills' && section.content?.skills) {
                    const skillsText = section.content.skills.map(s => `${s.name} (${s.percentage}%)`).join(', ');
                    return `${section.name}: ${skillsText}`;
                } else if (section.type === 'links' && section.content?.links) {
                    const linksText = section.content.links.map(l => `${l.title || l.url}`).join(', ');
                    return `${section.name}: ${linksText}`;
                }
                return null;
            }).filter(t => t);
            
            if (customSectionsText.length > 0) {
                dataItems.push(`📌 ${t.customSections}: ${customSectionsText.join('; ')}`);

            }
        }
    }
    
    dataText = dataItems.join('. ') + '.';
    
    return `
${t.assistant}
${t.mission}

${t.rulesTitle}
${t.rule1}
${t.rule2}
${t.rule3}
${t.rule4}
${t.rule5}
${t.rule6}

${t.dataTitle}
${dataText}

${t.prompt}
    `;
}



// 4.5 استدعاء AI للمالك (يتكلم بضمير المخاطب "أنت")
async function askOwnerAI(question, user, language) {
    const profileContext = buildProfileContextForOwner(user, language);
    
    const systemPrompt = `${profileContext}

✅ IMPORTANT: You are talking to YOURSELF about YOUR profile.
Always use second-person pronouns: "you", "your", "yours".
Never use "I" or "my" because you are talking to yourself.

📋 RULES:
1. Answer ONLY based on YOUR profile data provided above.
2. Be detailed and specific. Provide examples.
3. When listing strengths, mention the actual skill names and percentages.
4. When suggesting improvements, base them on actual lower-percentage skills.
5. Use the SAME language as the question.
6. Keep your answer informative (4-6 sentences).

Now answer your own question about yourself using "you":`;
    
    const aiConfig = user.profile?.aiBot || {};
    const useCustom = aiConfig.provider === 'custom' && aiConfig.customApiKey && aiConfig.customApiKey.trim() !== '';
    
    try {
        const startTime = Date.now();
        
        let response;
        if (useCustom) {
            response = await axios.post(
                'https://router.huggingface.co/v1/chat/completions',
                {
                    model: aiConfig.customModel || 'Qwen/Qwen2.5-7B-Instruct',
                    messages: [
                        { role: 'system', content: systemPrompt },
                        { role: 'user', content: question }
                    ],
                    max_tokens: aiConfig.maxTokens || 450,
                    temperature: aiConfig.temperature || 0.7
                },
                {
                    headers: {
                        'Authorization': `Bearer ${aiConfig.customApiKey}`,
                        'Content-Type': 'application/json'
                    },
                    timeout: 20000
                }
            );
        } else {
            response = await axios.post(
                'https://router.huggingface.co/v1/chat/completions',
                {
                    model: 'Qwen/Qwen2.5-7B-Instruct',
                    messages: [
                        { role: 'system', content: systemPrompt },
                        { role: 'user', content: question }
                    ],
                    max_tokens: 450,
                    temperature: 0.7
                },
                {
                    headers: {
                        'Authorization': `Bearer ${process.env.HUGGING_FACE_TOKEN}`,
                        'Content-Type': 'application/json'
                    },
                    timeout: 15000
                }
            );
        }
        
        const responseTime = Date.now() - startTime;
        let answer = response.data.choices[0]?.message?.content || 'عذراً، لم أستطع معالجة السؤال حالياً.';
        
        answer = cleanAIResponse(answer);
        
        // التأكد من عدم وجود "أنا" في الإجابة (للمالك)
        if (!useCustom) {
            const firstPersonPatterns = [
                /\bأنا\b/g, /\bI\b/g, /\bmy\b/gi, /\bme\b/gi, /\bmine\b/gi
            ];
            firstPersonPatterns.forEach(pattern => {
                if (pattern.test(answer)) {
                    answer = answer.replace(pattern, 'أنت');
                }
            });
        }
        
        return { answer, responseTime, provider: useCustom ? 'custom' : 'mgzon' };
        
    } catch (error) {
        console.error('Owner AI error:', error.message);
        
        if (error.code === 'ECONNABORTED') {
            return { answer: 'عذراً، الخادم بطيء حالياً. حاول مرة أخرى.', responseTime: 15000, provider: 'error' };
        }
        
        if (error.response?.status === 401) {
            return { answer: '⚠️ مفتاح API غير صالح. يرجى تحديثه في إعدادات البوت.', responseTime: 0, provider: 'error' };
        }
        
        if (error.response?.status === 429) {
            return { answer: '⚠️ تجاوزت حد الاستخدام اليومي. حاول غداً.', responseTime: 0, provider: 'error' };
        }
        
        return { answer: 'عذراً، حدث خطأ في البوت. حاول مرة أخرى.', responseTime: 0, provider: 'error' };
    }
}

// 3. تنظيف الإجابة (بدون تغيير الضمائر - كل حالة تتحكم بنفسها)
function cleanAIResponse(answer) {
    if (!answer) return '';
    
    // إزالة markdown blocks
    answer = answer.replace(/```[\s\S]*?```/g, '');
    answer = answer.replace(/\n### .*\n/g, '\n');
    answer = answer.replace(/\*\*(.*?)\*\*/g, '$1');
    answer = answer.replace(/__([^_]+)__/g, '$1');
    
    // إزالة "البوت" أو "الذكاء الاصطناعي" أو "AI"
    answer = answer.replace(/كمساعد ذكي|كbot|كـ AI|كـ بوت|as an AI|as a bot|AI assistant|bot/gi, '');
    
    // إزالة العبارات الافتتاحية المزعجة
    const openingPhrases = [
        /^(Based on the profile|According to the data|From the profile|حسب البيانات|من البيانات|وفقاً للملف)\s*[,:-]?\s*/gi,
        /^(I can see that|I notice that|I find that|أرى أن|ألاحظ أن|أجد أن|I see that|I believe that)\s*/gi,
        /^(Here is|Here are|This is|These are|هذه هي|هذا هو)\s*/gi
    ];
    openingPhrases.forEach(phrase => {
        answer = answer.replace(phrase, '');
    });
    
    // ✅ إزالة التكرارات (لو الجملة تكررت)
    const sentences = answer.split(/(?<=[.!?])\s+/);
    const uniqueSentences = [];
    for (const sentence of sentences) {
        if (!uniqueSentences.some(s => s.toLowerCase() === sentence.toLowerCase())) {
            uniqueSentences.push(sentence);
        }
    }
    answer = uniqueSentences.join(' ');
    
    // تنظيف المسافات الزائدة
    answer = answer.replace(/\s+/g, ' ').trim();
    
    // التأكد أن أول حرف كبير (للإنجليزية)
    if (answer.length > 0 && /[a-z]/.test(answer[0])) {
        answer = answer.charAt(0).toUpperCase() + answer.slice(1);
    }
    
    // إضافة نقطة في النهاية إذا لم تكن موجودة
    if (answer.length > 0 && !/[.!?]$/.test(answer)) {
        answer += '.';
    }
    
    return answer;
}

// 4. استدعاء MGZon AI الافتراضي (للزوار - يتكلم بضمير المتكلم "أنا")
async function askMGZonAI(question, context, language) {
    const systemPrompt = `${context}

✅ IMPORTANT: You are speaking AS the profile owner yourself.
Always use first-person pronouns: "I", "me", "my", "mine".
Speak as if you ARE the person the visitor is asking about.

📋 RULES:
1. Answer ONLY based on the profile data provided above.
2. If information is not in the data, say: "This information is not available in my profile."
3. Be detailed and specific. Provide examples when possible.
4. When listing skills, mention the proficiency percentages.
5. When suggesting improvements, base them on actual lower-percentage skills.
6. Use the SAME language as the question (Arabic, English, French, etc.).
7. Keep your answer informative (4-6 sentences).

Now answer the visitor's question naturally and informatively:`;
    
    try {
        const startTime = Date.now();
        
        const response = await axios.post(
            'https://router.huggingface.co/v1/chat/completions',
            {
                model: 'Qwen/Qwen2.5-7B-Instruct',
                messages: [
                    { role: 'system', content: systemPrompt },
                    { role: 'user', content: question }
                ],
                max_tokens: 450,  // ✅ زودنا من 200 لـ 450
                temperature: 0.7   // ✅ زودنا شوية
            },
            {
                headers: {
                    'Authorization': `Bearer ${process.env.HUGGING_FACE_TOKEN}`,
                    'Content-Type': 'application/json'
                },
                timeout: 15000
            }
        );
        
        const responseTime = Date.now() - startTime;
        let answer = response.data.choices[0]?.message?.content || 'Sorry, I could not process your question at this time.';
        
        answer = cleanAIResponse(answer);
        
        return { answer, responseTime };
        
    } catch (error) {
        console.error('MGZon AI error:', error.message);
        
        if (error.code === 'ECONNABORTED') {
            return { answer: 'Sorry, the server is slow right now. Please try again.', responseTime: 15000 };
        }
        
        if (error.response?.status === 401) {
            return { answer: '⚠️ Invalid API key. Please notify the profile owner.', responseTime: 0 };
        }
        
        return { answer: 'Sorry, the AI service is currently unavailable. Please try again later.', responseTime: 0 };
    }
}
// 5. استدعاء AI مخصص (للزوار - يتكلم بضمير المتكلم "أنا")
async function askCustomAI(question, context, aiConfig, language) {
    const systemPrompt = aiConfig.systemPrompt || `${context}

✅ IMPORTANT: You are speaking AS the profile owner yourself.
Use first-person pronouns: "I", "me", "my", "mine".
Speak as if you ARE the person the visitor is asking about.

📋 RULES:
1. Answer ONLY based on the profile data provided.
2. If information is not available, say: "This information is not available in my profile."
3. Be detailed and specific. Provide examples.
4. When listing skills, mention the proficiency percentages.
5. Use the SAME language as the question.
6. Keep your answer informative (4-6 sentences).

Now answer the visitor's question naturally and informatively:`;
    
    try {
        const startTime = Date.now();
        
        const response = await axios.post(
            'https://router.huggingface.co/v1/chat/completions',
            {
                model: aiConfig.customModel || 'Qwen/Qwen2.5-7B-Instruct',
                messages: [
                    { role: 'system', content: systemPrompt },
                    { role: 'user', content: question }
                ],
                max_tokens: aiConfig.maxTokens || 450,
                temperature: aiConfig.temperature || 0.7
            },
            {
                headers: {
                    'Authorization': `Bearer ${aiConfig.customApiKey}`,
                    'Content-Type': 'application/json'
                },
                timeout: 20000
            }
        );
        
        const responseTime = Date.now() - startTime;
        let answer = response.data.choices[0]?.message?.content || 'Sorry, I could not answer your question.';
        answer = cleanAIResponse(answer);
        
        return { answer, responseTime };
        
    } catch (error) {
        console.error('Custom AI error:', error.message);
        
        if (error.response?.status === 401) {
            return { answer: '⚠️ Invalid API key. Please update it in your AI Bot settings.', responseTime: 0 };
        }
        if (error.response?.status === 429) {
            return { answer: '⚠️ Daily usage limit exceeded. Please try again tomorrow.', responseTime: 0 };
        }
        if (error.code === 'ECONNABORTED') {
            return { answer: '⚠️ Request timed out. Please check your internet connection.', responseTime: 20000 };
        }
        
        return { answer: 'Sorry, an error occurred with your custom AI. Please check your API key and model settings.', responseTime: 0 };
    }
}

// 1.5 بناء سياق البروفايل متعدد اللغات
function buildProfileContextMultiLang(user, language = 'ar') {
    const p = user.profile || {};
    const displayName = p.nickname || user.username || (language === 'ar' ? 'هذا الشخص' : 'this person');
    
    // النصوص حسب اللغة
    const translations = {
        ar: {
            assistant: `أنت مساعد ذكي خاص بـ ${displayName}.`,
            mission: 'مهمتك: الإجابة على الأسئلة عن هذا الشخص فقط، بناءً على البيانات المتوفرة.',
            rulesTitle: '⚠️ قواعد صارمة:',
            rule1: '1. لا تقدم أي معلومات غير موجودة في البيانات أدناه.',
            rule2: '2. إذا سألك عن شيء خارج بياناته، قل: "هذه المعلومات غير متوفرة في ملفه الشخصي."',
            rule3: '3. تحدث بضمير الغائب (هو، هي، هو يعمل، هي تدرس). لا تستخدم "أنا" أو "نحن".',
            rule4: '4. استخدم نفس لغة السؤال (عربي، إنجليزي، فرنسي).',
            rule5: '5. كن مهذباً ومحترفاً، وأجب بإيجاز (حد أقصى 3-4 جمل).',
            rule6: '6. لا تذكر أنك مساعد ذكي أو بوت.',
            dataTitle: `📋 بيانات ${displayName}:`,
            skills: 'مهاراته',
            projects: 'أبرز مشاريعه',
            experience: 'خبراته',
            education: 'تعليمه',
            certificates: 'شهاداته',
            interests: 'اهتماماته',
            bio: 'السيرة الذاتية',
            industry: 'يعمل في مجال',
            customSections: 'الأقسام المخصصة',  // للعربية

            location: 'موقعه',
            jobTitle: 'المسمى الوظيفي',
            status: 'حالته المهنية',
            socialLinks: 'روابطه',
            prompt: 'الآن، أجب على سؤال الزائر بضمير الغائب، وباختصار:'
        },
        en: {
            assistant: `You are an AI assistant specifically for ${displayName}.`,
            mission: 'Your mission: Answer questions about this person only, based on the available data.',
            rulesTitle: '⚠️ Strict Rules:',
            rule1: '1. Do not provide any information not found in the data below.',
            rule2: '2. If asked about something outside their data, say: "This information is not available in their profile."',
            rule3: '3. Speak in the third person (he/she, he works, she studies). Never use "I" or "we".',
            rule4: '4. Use the same language as the question (Arabic, English, French, etc.).',
            rule5: '5. Be polite and professional, answer briefly (max 3-4 sentences).',
            rule6: '6. Do not mention being an AI assistant or bot.',
            dataTitle: `📋 ${displayName}'s Data:`,
            skills: 'Skills',
            projects: 'Top projects',
            experience: 'Experience',
            education: 'Education',
            certificates: 'Certificates',
            interests: 'Interests',
            bio: 'Bio',
            industry: 'Works in',
            location: 'Location',
            jobTitle: 'Job title',
            status: 'Professional status',
            socialLinks: 'Links',
            customSections: 'Custom Sections',  // للإنجليزية
            prompt: 'Now, answer the visitor\'s question in the third person, briefly:'
        },
        fr: {
            assistant: `Vous êtes un assistant IA spécialisé pour ${displayName}.`,
            mission: 'Votre mission : Répondez aux questions sur cette personne uniquement, sur la base des données disponibles.',
            rulesTitle: '⚠️ Règles strictes :',
            rule1: '1. Ne fournissez aucune information non présente dans les données ci-dessous.',
            rule2: '2. Si on vous demande quelque chose en dehors de ses données, dites : "Cette information n\'est pas disponible dans son profil."',
            rule3: '3. Parlez à la troisième personne (il/elle, il travaille, elle étudie). N\'utilisez jamais "je" ou "nous".',
            rule4: '4. Utilisez la même langue que la question (arabe, anglais, français).',
            rule5: '5. Soyez poli et professionnel, répondez brièvement (3-4 phrases maximum).',
            rule6: '6. Ne mentionnez pas que vous êtes un assistant IA.',
            dataTitle: `📋 Données de ${displayName} :`,
            skills: 'Compétences',
            projects: 'Projets principaux',
            experience: 'Expérience',
            education: 'Formation',
            certificates: 'Certificats',
            interests: 'Centres d\'intérêt',
            bio: 'Bio',
            customSections: 'Sections personnalisées',  // للفرنسية
            industry: 'Travaille dans',
            location: 'Localisation',
            jobTitle: 'Titre du poste',
            status: 'Statut professionnel',
            socialLinks: 'Liens',
            prompt: 'Maintenant, répondez à la question du visiteur à la troisième personne, brièvement :'
        }
    };
    
    const t = translations[language] || translations.en;
    
    // بناء البيانات
    let dataText = '';
    
    if (p.bio) dataText += `${t.bio}: ${p.bio}. `;
    if (p.industry) dataText += `${t.industry} ${p.industry}. `;
    if (p.location) dataText += `${t.location}: ${p.location}. `;
    if (p.status) dataText += `${t.status}: ${p.status}. `;
    if (p.jobTitle) dataText += `${t.jobTitle}: ${p.jobTitle}. `;
    
    if (p.experience?.length) {
        dataText += `${t.experience}: ${p.experience.map(exp => `${exp.role} at ${exp.company} (${exp.duration})`).join('; ')}. `;
    }
    
    if (p.education?.length) {
        dataText += `${t.education}: ${p.education.map(edu => `${edu.degree} from ${edu.institution} (${edu.year})`).join('; ')}. `;
    }
    
    if (p.certificates?.length) {
        dataText += `${t.certificates}: ${p.certificates.map(cert => `${cert.name} from ${cert.issuer}`).join('; ')}. `;
    }
    
    if (p.skills?.length) {
        dataText += `${t.skills}: ${p.skills.map(s => `${s.name} (${s.percentage}%)`).join(', ')}. `;
    }
    
    if (p.projects?.length) {
        const topProjects = p.projects.slice(0, 5);
        dataText += `${t.projects}: ${topProjects.map(proj => `"${proj.title}"`).join(', ')}. `;
    }
    
    if (p.interests?.length) {
        dataText += `${t.interests}: ${p.interests.join(', ')}. `;
    }
    
    if (p.socialLinks) {
        const links = [];
        if (p.socialLinks.linkedin) links.push(`LinkedIn: ${p.socialLinks.linkedin}`);
        if (p.socialLinks.github) links.push(`GitHub: ${p.socialLinks.github}`);
        if (p.socialLinks.behance) links.push(`Behance: ${p.socialLinks.behance}`);
        if (links.length) dataText += `${t.socialLinks}: ${links.join(', ')}. `;
    }


    // ✅ الأقسام المخصصة (Custom Sections)
    if (p.customSections && p.customSections.length > 0) {
        const visibleSections = p.customSections.filter(s => s.isVisible !== false);
        if (visibleSections.length > 0) {
            const customSectionsText = visibleSections.map(section => {
                if (section.type === 'text') {
                    return `${section.name}: ${section.content?.text || ''}`;
                } else if (section.type === 'skills' && section.content?.skills) {
                    const skillsText = section.content.skills.map(s => `${s.name} (${s.percentage}%)`).join(', ');
                    return `${section.name}: ${skillsText}`;
                } else if (section.type === 'links' && section.content?.links) {
                    const linksText = section.content.links.map(l => `${l.title || l.url}`).join(', ');
                    return `${section.name}: ${linksText}`;
                }
                return null;
            }).filter(t => t);
            
            if (customSectionsText.length > 0) {
                dataText += `${t.customSections}: ${customSectionsText.join('; ')}. `;
            }
        }
    }
    
    return `
${t.assistant}
${t.mission}

${t.rulesTitle}
${t.rule1}
${t.rule2}
${t.rule3}
${t.rule4}
${t.rule5}
${t.rule6}

${t.dataTitle}
${dataText}

${t.prompt}
    `;
}


// 6. حفظ المحادثة في قاعدة البيانات
async function saveAIConversation(userId, question, answer, provider, language, responseTime, visitorIp = '') {
    try {
        await AIConversation.create({
            userId,
            visitorIp: visitorIp || '',
            question: question.substring(0, 500),
            answer: answer.substring(0, 1000),
            provider,
            language,
            responseTime: responseTime || 0
        });
        
        // تحديث عدد الاستعلامات في user.profile
        await User.updateOne(
            { _id: userId },
            { 
                $inc: { 'profile.aiBot.totalQueries': 1 },
                $set: { 'profile.aiBot.lastQueryAt': new Date() }
            }
        );
        
    } catch (error) {
        console.error('Error saving AI conversation:', error);
    }
}




// ============================================
// 🤖 AI ASSISTANT FOR PROFILE OWNER
// ============================================

async function addSkill(userId, skillName, percentage, icon = null) {
    const user = await User.findById(userId);
    if (!user) return { success: false, message: 'User not found' };
    
    let skills = user.profile?.skills || [];
    if (!Array.isArray(skills)) skills = [];
    
    // التحقق من عدم التكرار
    const exists = skills.find(s => s.name?.toLowerCase() === skillName.toLowerCase());
    if (exists) {
        return { success: false, message: `⚠️ Skill "${skillName}" already exists with ${exists.percentage}%` };
    }
    
    // ✅ استخدام الدالة الموحدة مع exactMatch للمطابقة التامة
    const finalIcon = icon || getIconForSkill(skillName, { exactMatch: true });
    
    skills.push({
        name: skillName,
        percentage: Math.min(100, Math.max(0, percentage || 50)),
        icon: finalIcon
    });
    
    // ترتيب المهارات تنازلياً حسب النسبة
    skills.sort((a, b) => b.percentage - a.percentage);
    
    user.profile.skills = skills;
    await user.save();
    
    return { success: true, message: `✅ Added "${skillName}" with ${percentage || 50}%` };
}

// 2. تحديث مهارة
async function updateSkill(userId, skillName, newPercentage) {
    const user = await User.findById(userId);
    if (!user) return { success: false, message: 'User not found' };
    
    let skills = user.profile?.skills || [];
    const index = skills.findIndex(s => s.name?.toLowerCase() === skillName.toLowerCase());
    
    if (index === -1) {
        return { success: false, message: `⚠️ Skill "${skillName}" not found` };
    }
    
    const oldPercentage = skills[index].percentage;
    skills[index].percentage = Math.min(100, Math.max(0, newPercentage));
    
    // ✅ تحديث الأيقونة إذا كانت افتراضية أو غير موجودة
    if (!skills[index].icon || skills[index].icon === 'bx bx-code-alt') {
        skills[index].icon = getIconForSkill(skillName, { exactMatch: true });
    }
    
    skills.sort((a, b) => b.percentage - a.percentage);
    
    user.profile.skills = skills;
    await user.save();
    
    return { success: true, message: `✅ Updated "${skillName}" from ${oldPercentage}% to ${newPercentage}%` };
}


// 3. حذف مهارة
async function deleteSkill(userId, skillName) {
    const user = await User.findById(userId);
    let skills = user.profile?.skills || [];
    const filtered = skills.filter(s => s.name?.toLowerCase() !== skillName.toLowerCase());
    
    if (filtered.length === skills.length) {
        return { success: false, message: `⚠️ Skill "${skillName}" not found` };
    }
    
    user.profile.skills = filtered;
    await user.save();
    
    return { success: true, message: `🗑️ Removed "${skillName}" from your skills` };
}

// 4. تحديث البيو
async function updateBio(userId, newBio) {
    const user = await User.findById(userId);
    const oldBio = user.profile?.bio || '';
    user.profile.bio = newBio.substring(0, 500);
    await user.save();
    return { success: true, message: `✅ Bio updated successfully!\n\n**Old:** ${oldBio.substring(0, 100)}${oldBio.length > 100 ? '...' : ''}\n**New:** ${newBio.substring(0, 100)}${newBio.length > 100 ? '...' : ''}` };
}

// 5. إضافة خبرة
async function addExperience(userId, company, role, duration) {
    const user = await User.findById(userId);
    let experiences = user.profile?.experience || [];
    experiences.push({ company, role, duration });
    user.profile.experience = experiences;
    await user.save();
    return { success: true, message: `✅ Added experience at **${company}** as **${role}** (${duration})` };
}

// 6. حذف خبرة
async function deleteExperience(userId, company) {
    const user = await User.findById(userId);
    let experiences = user.profile?.experience || [];
    const filtered = experiences.filter(e => e.company?.toLowerCase() !== company.toLowerCase());
    
    if (filtered.length === experiences.length) {
        return { success: false, message: `⚠️ Experience at "${company}" not found` };
    }
    
    user.profile.experience = filtered;
    await user.save();
    return { success: true, message: `🗑️ Removed experience from **${company}**` };
}

// 7. إضافة مشروع
async function addProject(userId, title, description, imageUrl = null) {
    const user = await User.findById(userId);
    let projects = user.profile?.projects || [];
    
    const newProject = {
        _id: new mongoose.Types.ObjectId(),
        title: title,
        description: description || '',
        image: imageUrl || '/assets/img/default-project.png',
        rating: '',
        stars: 0,
        links: [],
        createdAt: Date.now(),
        isPublic: true
    };
    
    projects.push(newProject);
    user.profile.projects = projects;
    await user.save();
    
    // حفظ في Project collection
    const projectDoc = new Project({
        _id: newProject._id,
        title: title,
        description: description || '',
        image: imageUrl || '/assets/img/default-project.png',
        userId: user._id,
        isPublic: true,
        createdAt: Date.now()
    });
    await projectDoc.save();
    
    return { success: true, message: `✅ Added project: **${title}**` };
}

// 8. تحديث المسمى الوظيفي
async function updateJobTitle(userId, newTitle) {
    const user = await User.findById(userId);
    const oldTitle = user.profile?.jobTitle || 'Not set';
    user.profile.jobTitle = newTitle;
    await user.save();
    return { success: true, message: `✅ Updated job title from "${oldTitle}" to "${newTitle}"` };
}

// 9. تحديث الحالة المهنية
async function updateStatus(userId, newStatus) {
    const validStatuses = ['Available', 'Busy', 'Open to Work'];
    if (!validStatuses.includes(newStatus)) {
        return { success: false, message: `⚠️ Invalid status. Choose: ${validStatuses.join(', ')}` };
    }
    const user = await User.findById(userId);
    const oldStatus = user.profile?.status || 'Available';
    user.profile.status = newStatus;
    await user.save();
    return { success: true, message: `✅ Updated status from "${oldStatus}" to "${newStatus}"` };
}

// 10. تحليل البروفايل بالكامل
async function analyzeProfile(userId) {
    const user = await User.findById(userId);
    const profile = user.profile || {};
    
    let analysis = {
        strengths: [],
        weaknesses: [],
        suggestions: [],
        missingInfo: [],
        completeness: 0
    };
    
    // تحليل المهارات
    const skills = profile.skills || [];
    const highSkills = skills.filter(s => s.percentage >= 80);
    const lowSkills = skills.filter(s => s.percentage < 60);
    const mediumSkills = skills.filter(s => s.percentage >= 60 && s.percentage < 80);
    
    analysis.strengths = highSkills.map(s => `${s.name} (${s.percentage}%)`);
    analysis.weaknesses = lowSkills.map(s => `${s.name} (${s.percentage}%)`);
    
    // اقتراحات
    if (lowSkills.length > 0) {
        analysis.suggestions.push(`🎯 Improve ${lowSkills.map(s => s.name).join(', ')} by taking advanced courses or building projects`);
    }
    if (highSkills.length < 3) {
        analysis.suggestions.push(`📚 Focus on developing more high-proficiency skills (80%+) to stand out`);
    }
    if (mediumSkills.length > 0 && highSkills.length < 5) {
        analysis.suggestions.push(`💪 Push your ${mediumSkills.map(s => s.name).slice(0, 2).join(', ')} skills from ${mediumSkills.map(s => s.percentage).join(', ')}% to 80%+`);
    }
    
    // التحقق من المعلومات الناقصة
    if (!profile.bio) analysis.missingInfo.push('📝 Add a bio/about section');
    if (!profile.jobTitle) analysis.missingInfo.push('💼 Add your job title');
    if (!profile.location) analysis.missingInfo.push('📍 Add your location');
    if (!profile.industry) analysis.missingInfo.push('🏭 Add your industry');
    
    if ((profile.experience || []).length === 0) analysis.missingInfo.push('👔 Add work experience');
    if ((profile.projects || []).length === 0) analysis.missingInfo.push('🚀 Add projects to showcase your work');
    if ((profile.education || []).length === 0) analysis.missingInfo.push('🎓 Add your education');
    if ((profile.certificates || []).length < 2) analysis.missingInfo.push('📜 Add more certificates');
    
    // حساب نسبة اكتمال البروفايل
    let totalFields = 0;
    let filledFields = 0;
    
    if (profile.bio) filledFields++; totalFields++;
    if (profile.jobTitle) filledFields++; totalFields++;
    if (profile.location) filledFields++; totalFields++;
   if (profile.industry) filledFields++; totalFields++;
    if (profile.skills?.length >= 3) filledFields++; totalFields++;
    if (profile.experience?.length >= 1) filledFields++; totalFields++;
    if (profile.projects?.length >= 1) filledFields++; totalFields++;
    if (profile.education?.length >= 1) filledFields++; totalFields++;
    if (profile.certificates?.length >= 1) filledFields++; totalFields++;
    
    analysis.completeness = Math.round((filledFields / totalFields) * 100);
    

    // ✅ تحليل الأقسام المخصصة
    if (profile.customSections && profile.customSections.length > 0) {
        const visibleCustomSections = profile.customSections.filter(s => s.isVisible !== false);
        if (visibleCustomSections.length > 0) {
            analysis.suggestions.push(`📌 You have ${visibleCustomSections.length} custom section(s): ${visibleCustomSections.map(s => s.name).join(', ')}`);
        }
    }
    // إضافة اقتراحات ذكية بناءً على المجال
    if (profile.industry === 'Technology' || profile.industry === 'Software Development') {
        if (!profile.socialLinks?.github) {
            analysis.suggestions.push(`🐙 Add your GitHub link to showcase your code`);
        }
        if (!profile.projects?.length) {
            analysis.suggestions.push(`💻 Add your best projects - employers love seeing real work`);
        }
    }
    
    return analysis;
}

// ============================================
// 11. معالج الأوامر الرئيسي (محدث بالكامل)
// ============================================
async function processOwnerCommand(question, user) {
    const lowerQuestion = question.toLowerCase();
    const userId = user._id;
    
    // ============ 1. تحليل البروفايل ============
    if (lowerQuestion.includes('حلل') || lowerQuestion.includes('analyze') || 
        lowerQuestion.includes('review') || lowerQuestion.includes('قيم') ||
        lowerQuestion.includes('profile analysis') || lowerQuestion.includes('تحليل')) {
        const analysis = await analyzeProfile(userId);
        return formatAnalysisResponse(analysis, user);
    }
    
    // ============ 2. إضافة مهارة ============
    const addSkillMatch = lowerQuestion.match(/(?:add|اضف|أضف)\s+(?:skill|مهارة)\s+(\w+(?:\s*\w+)?)(?:\s+(\d+))?/i);
    if (addSkillMatch) {
        let skillName = addSkillMatch[1];
        let percentage = parseInt(addSkillMatch[2]) || 50;
        percentage = Math.min(100, Math.max(0, percentage));
        // ✅ addSkill تستخدم getIconForSkill داخلياً
        const result = await addSkill(userId, skillName, percentage);
        return result.message;
    }
    
    // ============ 3. تحديث مهارة ============
    const updateSkillMatch = lowerQuestion.match(/(?:update|عدل|غير|حدث)\s+(\w+(?:\s*\w+)?)\s+(?:to|لـ|ل|الى)\s*(\d+)/i);
    if (updateSkillMatch) {
        const skillName = updateSkillMatch[1];
        const newPercentage = parseInt(updateSkillMatch[2]);
        if (newPercentage >= 0 && newPercentage <= 100) {
            // ✅ updateSkill تستخدم getIconForSkill داخلياً
            const result = await updateSkill(userId, skillName, newPercentage);
            return result.message;
        }
        return "⚠️ النسبة المئوية يجب أن تكون بين 0 و 100";
    }
    
    // ============ 4. حذف مهارة ============
    const deleteSkillMatch = lowerQuestion.match(/(?:delete|remove|احذف|ازيل|امسح)\s+(?:skill|مهارة)\s+(\w+(?:\s*\w+)?)/i);
    if (deleteSkillMatch) {
        const skillName = deleteSkillMatch[1];
        const result = await deleteSkill(userId, skillName);
        return result.message;
    }
    
    // ============ 5. تحديث البيو ============
    if (lowerQuestion.includes('bio') || lowerQuestion.includes('about') || 
        lowerQuestion.includes('سيرة') || lowerQuestion.includes('نبذة')) {
        let newBio = question.replace(/^(update|change|set|edit|set my|update my|عدل|غير|ضبط|حدث)\s+(?:my\s+)?(?:bio|about|سيرة|نبذة)\s+(?:to|لـ|:|\s*-\s*)/i, '');
        newBio = newBio.trim();
        if (newBio && newBio.length > 10) {
            const result = await updateBio(userId, newBio);
            return result.message;
        }
        return "❓ Example: 'Update my bio to: Senior Full Stack Developer with 5 years experience'";
    }
    
    // ============ 6. تحديث المسمى الوظيفي ============
    if (lowerQuestion.includes('job title') || lowerQuestion.includes('title') || 
        lowerQuestion.includes('مسمى') || lowerQuestion.includes('وظيفي')) {
        let newTitle = question.replace(/^(update|change|set|عدل|غير|ضبط|حدث)\s+(?:my\s+)?(?:job title|title|مسمى وظيفي|الوظيفة)\s+(?:to|لـ|:|\s*-\s*)/i, '');
        newTitle = newTitle.trim();
        if (newTitle && newTitle.length > 3) {
            const result = await updateJobTitle(userId, newTitle);
            return result.message;
        }
        return "❓ Example: 'Update my job title to: Senior Full Stack Developer'";
    }
    
    // ============ 7. تحديث الحالة ============
    if (lowerQuestion.includes('status') || lowerQuestion.includes('available') || 
        lowerQuestion.includes('حالة') || lowerQuestion.includes('متاح')) {
        let newStatus = 'Available';
        if (lowerQuestion.includes('open to work')) newStatus = 'Open to Work';
        else if (lowerQuestion.includes('busy')) newStatus = 'Busy';
        else if (lowerQuestion.includes('available')) newStatus = 'Available';
        
        const result = await updateStatus(userId, newStatus);
        return result.message;
    }
    
    // ============ 8. إضافة خبرة ============
    const addExpMatch = lowerQuestion.match(/(?:add|اضف|أضف)\s+(?:experience|خبرة)\s+(?:at|في)\s+([^as]+?)\s+(?:as|كـ|منصب)\s+([^(]+?)(?:\s*\(?for\s*([^)]+))?/i);
    if (addExpMatch || (lowerQuestion.includes('experience') && lowerQuestion.includes('at'))) {
        let company = '', role = '', duration = 'Present';
        
        if (addExpMatch) {
            company = addExpMatch[1].trim();
            role = addExpMatch[2].trim();
            duration = addExpMatch[3]?.trim() || 'Present';
        } else {
            const companyMatch = lowerQuestion.match(/at\s+([^\s]+)/i);
            const roleMatch = lowerQuestion.match(/as\s+([^\s]+)/i);
            if (companyMatch) company = companyMatch[1];
            if (roleMatch) role = roleMatch[1];
            if (!company || !role) {
                return "❓ Example: 'Add experience at Microsoft as Software Engineer'";
            }
        }
        
        const result = await addExperience(userId, company, role, duration);
        return result.message;
    }
    
    // ============ 9. حذف خبرة ============
    if (lowerQuestion.includes('delete experience') || lowerQuestion.includes('حذف خبرة')) {
        const companyMatch = lowerQuestion.match(/(?:from|من|at|في)\s+(\w+(?:\s+\w+)?)/i);
        if (companyMatch) {
            const result = await deleteExperience(userId, companyMatch[1]);
            return result.message;
        }
        return "❓ Example: 'Delete experience from Google'";
    }
    
    // ============ 10. إضافة مشروع ============
    if (lowerQuestion.includes('add project') || lowerQuestion.includes('اضف مشروع') || 
        lowerQuestion.includes('new project') || lowerQuestion.includes('مشروع جديد')) {
        let title = '', description = '';
        const titleMatch = question.match(/(?:project|مشروع)\s+(?:called|اسمه|named|بعنوان)\s+["']?([^"']+)["']?/i);
        if (titleMatch) {
            title = titleMatch[1];
        } else {
            const words = question.split(' ');
            for (let i = 0; i < words.length; i++) {
                if (words[i].toLowerCase() === 'project' || words[i].toLowerCase() === 'مشروع') {
                    title = words[i + 1] || 'New Project';
                    break;
                }
            }
        }
        
        const descMatch = question.match(/(?:description|about|وصف|عن)\s*:?\s*["']?([^"']+)["']?/i);
        if (descMatch) description = descMatch[1];
        
        if (title) {
            const result = await addProject(userId, title, description);
            return result.message;
        }
        return "❓ Example: 'Add project called E-commerce Platform'";
    }
    
    // ============ 11. عرض الإحصائيات ============
    if (lowerQuestion.includes('stats') || lowerQuestion.includes('إحصائيات') || 
        lowerQuestion.includes('statistics') || lowerQuestion.includes('أرقام') ||
        lowerQuestion.includes('summary') || lowerQuestion.includes('ملخص')) {
        const analysis = await analyzeProfile(userId);
        return `📊 **Profile Statistics**\n\n` +
               `📈 **Completion:** ${analysis.completeness}%\n` +
               `⭐ **Skills:** ${user.profile?.skills?.length || 0}\n` +
               `🚀 **Projects:** ${user.profile?.projects?.length || 0}\n` +
               `👔 **Experience:** ${user.profile?.experience?.length || 0}\n` +
               `🎓 **Education:** ${user.profile?.education?.length || 0}\n` +
               `📜 **Certificates:** ${user.profile?.certificates?.length || 0}\n\n` +
               `${analysis.missingInfo.length > 0 ? `⚠️ **Missing:** ${analysis.missingInfo.slice(0, 3).join(', ')}` : '✅ **Complete profile!**'}`;
    }
    
    // ============ 12. اقتراحات للتحسين ============
    if (lowerQuestion.includes('suggest') || lowerQuestion.includes('اقترح') || 
        lowerQuestion.includes('improve') || lowerQuestion.includes('طور') ||
        lowerQuestion.includes('recommend') || lowerQuestion.includes('نصيحة')) {
        const analysis = await analyzeProfile(userId);
        let response = "💡 **Suggestions to improve your profile**\n\n";
        
        if (analysis.suggestions.length > 0) {
            response += analysis.suggestions.map((s, i) => `${i + 1}. ${s}`).join('\n');
        } else {
            response += "🎉 Your profile looks great! Keep maintaining it and adding new achievements.";
        }
        
        if (analysis.missingInfo.length > 0) {
            response += `\n\n📝 **Missing information to add:**\n${analysis.missingInfo.map((m, i) => `${i + 1}. ${m}`).join('\n')}`;
        }
        
        return response;
    }
    
    // ============ 13. إضافة تعليم (Education) ============
    if (lowerQuestion.includes('add education') || lowerQuestion.includes('add study') || 
        lowerQuestion.includes('اضف تعليم') || lowerQuestion.includes('اضف دراسة') ||
        lowerQuestion.includes('bachelor') || lowerQuestion.includes('degree') ||
        (lowerQuestion.includes('university') && !lowerQuestion.includes('experience'))) {
        
        let institution = '', degree = '', year = '', grade = '';
        
        const uniMatch = question.match(/(?:from|at|of|في|من)\s+([A-Za-z\u0600-\u06FF\s]+?)(?:\s*\(|$|,|\s+in\s+|\s+degree)/i);
        if (uniMatch) institution = uniMatch[1].trim();
        
        const degreeMatch = question.match(/(?:Bachelor|Master|Diploma|BSc|MSc|BA|BIS|Information Systems|Computer Science|Software Engineering)[\s]*of[\s]*([A-Za-z\u0600-\u06FF\s]+)/i);
        if (degreeMatch) degree = degreeMatch[1].trim();
        else if (lowerQuestion.includes('bachelor')) degree = 'Bachelor';
        else if (lowerQuestion.includes('master')) degree = 'Master';
        
        const yearMatch = question.match(/\b(20\d{2}|202[0-9])\b/);
        if (yearMatch) year = yearMatch[1];
        
        const gradeMatch = question.match(/(?:Grade|تقدير|GPA)[:\s]+([A-Za-z\u0600-\u06FF\s]+)/i);
        if (gradeMatch) grade = gradeMatch[1].trim();
        
        if (!institution && !degree) {
            const parts = question.split(/•|\||,|\./);
            for (const part of parts) {
                if (part.includes('University') || part.includes('College')) {
                    institution = part.trim();
                }
                if (part.includes('Bachelor') || part.includes('Master') || part.includes('Diploma')) {
                    degree = part.trim();
                }
            }
        }
        
        if (institution || degree) {
            const result = await addEducation(userId, institution || 'Unknown University', degree || 'Degree', year || '2024', grade);
            return result.message;
        }
        return "❓ Example: 'Add education: Bachelor of Computer Science from Cairo University 2024'";
    }
    
    // ============ 14. إضافة شهادة ============
    if (lowerQuestion.includes('add certificate') || lowerQuestion.includes('اضف شهادة') ||
        lowerQuestion.includes('certified') || lowerQuestion.includes('certification')) {
        
        let certName = '', issuer = '', year = '';
        
        const certMatch = question.match(/(?:certificate|certified|شهادة)[:\s]+([A-Za-z\u0600-\u06FF\s]+?)(?:\s+from|\s+issued|\s+by|$)/i);
        if (certMatch) certName = certMatch[1].trim();
        
        const issuerMatch = question.match(/(?:from|by|issued by|من|بواسطة)\s+([A-Za-z\u0600-\u06FF\s]+?)(?:\s+\(|$|,|\s+in\s+)/i);
        if (issuerMatch) issuer = issuerMatch[1].trim();
        
        const yearMatch = question.match(/\b(20\d{2})\b/);
        if (yearMatch) year = yearMatch[1];
        
        if (certName) {
            const result = await addCertificate(userId, certName, issuer || 'Unknown', year || new Date().getFullYear());
            return result.message;
        }
        return "❓ Example: 'Add certificate: React Masterclass from Meta 2024'";
    }
    
    // ============ 15. تحديث الموقع ============
    if (lowerQuestion.includes('update location') || lowerQuestion.includes('change location') ||
        lowerQuestion.includes('set location') || lowerQuestion.includes('عدل الموقع') ||
        lowerQuestion.includes('غير الموقع')) {
        
        let newLocation = question.replace(/^(update|change|set|عدل|غير|ضبط)\s+(?:my\s+)?(?:location|الموقع)\s+(?:to|لـ|:|\s*-\s*)/i, '');
        newLocation = newLocation.trim();
        
        if (newLocation && newLocation.length > 2) {
            const result = await updateLocation(userId, newLocation);
            return result.message;
        }
        return "❓ Example: 'Update location to Cairo, Egypt'";
    }
    
    // ============ 16. تحديث الصناعة ============
    if (lowerQuestion.includes('update industry') || lowerQuestion.includes('change industry') ||
        lowerQuestion.includes('set industry') || lowerQuestion.includes('عدل المجال') ||
        lowerQuestion.includes('غير المجال')) {
        
        let newIndustry = question.replace(/^(update|change|set|عدل|غير|ضبط)\s+(?:my\s+)?(?:industry|مجال|field)\s+(?:to|لـ|:|\s*-\s*)/i, '');
        newIndustry = newIndustry.trim();
        
        if (newIndustry && newIndustry.length > 2) {
            const result = await updateIndustry(userId, newIndustry);
            return result.message;
        }
        return "❓ Example: 'Update industry to Software Development'";
    }
    
    // ============ 17. عرض جميع المهارات ============
    if (lowerQuestion.includes('list skills') || lowerQuestion.includes('show all skills') ||
        lowerQuestion.includes('عرض المهارات') || lowerQuestion.includes('كل المهارات')) {
        const userData = await User.findById(userId);
        const skills = userData.profile?.skills || [];
        if (skills.length === 0) return "📭 لا توجد مهارات بعد. استخدم 'Add skill React 85%' لإضافة مهارة.";
        
        let response = "📊 **مهاراتك:**\n\n";
        skills.forEach((s, i) => {
            const barLength = 10;
            const filled = Math.round((s.percentage / 100) * barLength);
            const bar = '█'.repeat(filled) + '░'.repeat(barLength - filled);
            response += `${i + 1}. **${s.name}** - ${s.percentage}% ${bar}\n`;
        });
        return response;
    }
    
    // ============ 18. عرض جميع المشاريع ============
    if (lowerQuestion.includes('list projects') || lowerQuestion.includes('show all projects') ||
        lowerQuestion.includes('عرض المشاريع') || lowerQuestion.includes('كل المشاريع')) {
        const userData = await User.findById(userId);
        const projects = userData.profile?.projects || [];
        if (projects.length === 0) return "📭 لا توجد مشاريع بعد. استخدم 'Add project called [name]' لإضافة مشروع.";
        
        let response = "🚀 **مشاريعك:**\n\n";
        projects.slice(0, 10).forEach((p, i) => {
            response += `${i + 1}. **${p.title}**\n`;
            if (p.description) response += `   📝 ${p.description.substring(0, 100)}${p.description.length > 100 ? '...' : ''}\n`;
        });
        if (projects.length > 10) response += `\n... و ${projects.length - 10} مشاريع أخرى.`;
        return response;
    }
    
    // ============================================
    // ✅ الأوامر الجديدة للأقسام المخصصة
    // ============================================
    
    // ============ 19. عرض الأقسام المخصصة ============
    if (lowerQuestion.includes('custom section') || lowerQuestion.includes('الأقسام المخصصة') || 
        lowerQuestion.includes('show sections') || lowerQuestion.includes('عرض الأقسام')) {
        const userData = await User.findById(userId);
        const sections = userData.profile?.customSections || [];
        if (sections.length === 0) {
            return "📭 **لا توجد أقسام مخصصة بعد.**\n\nاستخدم:\n• 'Add custom section called Achievements with text: Won Hackathon 2024'\n• 'Add custom section called Languages with skills: English 90%, Arabic 100%'";
        }
        
        let response = "📌 **الأقسام المخصصة لديك:**\n\n";
        sections.forEach((s, i) => {
            response += `${i + 1}. **${s.name}** (${s.type === 'text' ? 'نص' : s.type === 'skills' ? 'مهارات' : 'روابط'}) - ${s.isVisible ? '👁️ ظاهر' : '🙈 مخفي'}\n`;
            if (s.type === 'text' && s.content?.text) {
                response += `   📝 "${s.content.text.substring(0, 80)}${s.content.text.length > 80 ? '...' : ''}"\n`;
            } else if (s.type === 'skills' && s.content?.skills) {
                const skillNames = s.content.skills.slice(0, 3).map(sk => `${sk.name} (${sk.percentage}%)`).join(', ');
                response += `   ⭐ ${skillNames}${s.content.skills.length > 3 ? ` +${s.content.skills.length - 3} more` : ''}\n`;
            } else if (s.type === 'links' && s.content?.links) {
                const linkNames = s.content.links.slice(0, 3).map(l => l.title || l.url).join(', ');
                response += `   🔗 ${linkNames}${s.content.links.length > 3 ? ` +${s.content.links.length - 3} more` : ''}\n`;
            }
            response += `\n`;
        });
        response += `\n💡 **الأوامر المتاحة:**\n• 'Add custom section called [name] with text: [content]'\n• 'Add custom section called [name] with skills: Skill1 90%, Skill2 80%'\n• 'Delete custom section [name]'\n• 'Hide custom section [name]' / 'Show custom section [name]'\n• 'Update custom section [name] to: [new content]'`;
        return response;
    }
    
    // ============ 20. إضافة قسم مخصص (نص) ============
    const addTextSectionMatch = lowerQuestion.match(/(?:add|اضف|أضف)\s+(?:custom\s+)?section\s+(?:called|اسمه|named|بعنوان)\s+["']?([^"']+?)["']?\s+(?:with|and|text|content|نص)\s*:?\s*["']?(.+?)["']?$/i);
    if (addTextSectionMatch || (lowerQuestion.includes('custom section') && lowerQuestion.includes('text:'))) {
        let sectionName = '', sectionContent = '';
        
        if (addTextSectionMatch) {
            sectionName = addTextSectionMatch[1].trim();
            sectionContent = addTextSectionMatch[2].trim();
        } else {
            const nameMatch = lowerQuestion.match(/called\s+["']?([^"']+)["']?/i);
            const contentMatch = lowerQuestion.match(/text:\s*["']?(.+?)["']?$/i);
            if (nameMatch) sectionName = nameMatch[1].trim();
            if (contentMatch) sectionContent = contentMatch[1].trim();
        }
        
        if (sectionName && sectionContent) {
            // ✅ addCustomSection تستخدم getIconForSkill داخلياً
            const result = await addCustomSection(userId, sectionName, 'text', { text: sectionContent });
            if (result.success) return result.message;
            return `⚠️ ${result.message}`;
        }
        return "❓ Example: 'Add custom section called Achievements with text: Won Hackathon 2024, Published 5 articles'";
    }
    
    // ============ 21. إضافة قسم مخصص (مهارات) ============
    const addSkillsSectionMatch = lowerQuestion.match(/(?:add|اضف|أضف)\s+(?:custom\s+)?section\s+(?:called|اسمه|named|بعنوان)\s+["']?([^"']+?)["']?\s+(?:with|and|skills|مهارات)\s*:?\s*["']?(.+?)["']?$/i);
    if (addSkillsSectionMatch || (lowerQuestion.includes('custom section') && lowerQuestion.includes('skills:'))) {
        let sectionName = '', skillsText = '';
        
        if (addSkillsSectionMatch) {
            sectionName = addSkillsSectionMatch[1].trim();
            skillsText = addSkillsSectionMatch[2].trim();
        } else {
            const nameMatch = lowerQuestion.match(/called\s+["']?([^"']+)["']?/i);
            const skillsMatch = lowerQuestion.match(/skills:\s*["']?(.+?)["']?$/i);
            if (nameMatch) sectionName = nameMatch[1].trim();
            if (skillsMatch) skillsText = skillsMatch[1].trim();
        }
        
        if (sectionName && skillsText) {
            const skillPairs = skillsText.split(',').map(pair => {
                const match = pair.trim().match(/^(.+?)\s*(\d+)%?$/);
                if (match) {
                    return { 
                        name: match[1].trim(), 
                        percentage: Math.min(100, parseInt(match[2])),
                        // ✅ استخدام الدالة الموحدة
                        icon: getIconForSkill(match[1], { exactMatch: true })
                    };
                }
                return null;
            }).filter(s => s);
            
            if (skillPairs.length === 0) {
                return "⚠️ Example: 'Add custom section called Languages with skills: English 90%, Arabic 100%, French 75%'";
            }
            
            // ✅ addCustomSection تستخدم getIconForSkill داخلياً
            const result = await addCustomSection(userId, sectionName, 'skills', { skills: skillPairs });
            if (result.success) return result.message;
            return `⚠️ ${result.message}`;
        }
        return "❓ Example: 'Add custom section called Programming Skills with skills: React 90%, Node.js 85%, Python 75%'";
    }
    
    // ============ 22. إضافة قسم مخصص (روابط) ============
    const addLinksSectionMatch = lowerQuestion.match(/(?:add|اضف|أضف)\s+(?:custom\s+)?section\s+(?:called|اسمه|named|بعنوان)\s+["']?([^"']+?)["']?\s+(?:with|and|links|روابط)\s*:?\s*["']?(.+?)["']?$/i);
    if (addLinksSectionMatch || (lowerQuestion.includes('custom section') && lowerQuestion.includes('links:'))) {
        let sectionName = '', linksText = '';
        
        if (addLinksSectionMatch) {
            sectionName = addLinksSectionMatch[1].trim();
            linksText = addLinksSectionMatch[2].trim();
        } else {
            const nameMatch = lowerQuestion.match(/called\s+["']?([^"']+)["']?/i);
            const linksMatch = lowerQuestion.match(/links:\s*["']?(.+?)["']?$/i);
            if (nameMatch) sectionName = nameMatch[1].trim();
            if (linksMatch) linksText = linksMatch[1].trim();
        }
        
        if (sectionName && linksText) {
            const linkPairs = linksText.split(',').map(pair => {
                const match = pair.trim().match(/^(.+?):\s*(https?:\/\/[^\s]+)$/);
                if (match) {
                    return { title: match[1].trim(), url: match[2].trim() };
                }
                return null;
            }).filter(l => l);
            
            if (linkPairs.length === 0) {
                return "⚠️ Example: 'Add custom section called Social with links: GitHub: https://github.com/username, LinkedIn: https://linkedin.com/in/username'";
            }
            
            const result = await addCustomSection(userId, sectionName, 'links', { links: linkPairs });
            if (result.success) return result.message;
            return `⚠️ ${result.message}`;
        }
        return "❓ Example: 'Add custom section called Important Links with links: Portfolio: https://myportfolio.com, GitHub: https://github.com/username'";
    }
    
    // ============ 23. حذف قسم مخصص ============
    const deleteSectionMatch = lowerQuestion.match(/(?:delete|remove|احذف|ازيل|امسح)\s+(?:custom\s+)?section\s+["']?([^"']+)["']?/i);
    if (deleteSectionMatch || (lowerQuestion.includes('delete custom section'))) {
        let sectionName = deleteSectionMatch ? deleteSectionMatch[1].trim() : '';
        if (!sectionName) {
            const nameMatch = lowerQuestion.match(/section\s+["']?([^"']+)["']?/i);
            if (nameMatch) sectionName = nameMatch[1].trim();
        }
        
        if (sectionName) {
            const result = await deleteCustomSectionByName(userId, sectionName);
            if (result.success) return result.message;
            return `⚠️ ${result.message}`;
        }
        return "❓ Example: 'Delete custom section Achievements'";
    }
    
    // ============ 24. إظهار/إخفاء قسم مخصص ============
    const toggleVisibilityMatch = lowerQuestion.match(/(?:hide|show|اخفي|اظهر|أظهر|أخفي)\s+(?:custom\s+)?section\s+["']?([^"']+)["']?/i);
    if (toggleVisibilityMatch) {
        const action = toggleVisibilityMatch[0].toLowerCase();
        let sectionName = toggleVisibilityMatch[1].trim();
        const isVisible = action.includes('show') || action.includes('اظهر') || action.includes('أظهر');
        
        if (sectionName) {
            const result = await toggleCustomSectionVisibility(userId, sectionName, isVisible);
            if (result.success) return result.message;
            return `⚠️ ${result.message}`;
        }
        return "❓ Example: 'Hide custom section Achievements' or 'Show custom section Achievements'";
    }
    
    // ============ 25. تحديث محتوى قسم مخصص ============
    const updateSectionMatch = lowerQuestion.match(/(?:update|عدل|غير|حدث)\s+(?:custom\s+)?section\s+["']?([^"']+)["']?\s+(?:to|لـ|with|بـ)\s*:?\s*["']?(.+?)["']?$/i);
    if (updateSectionMatch || (lowerQuestion.includes('update custom section'))) {
        let sectionName = '', newContent = '';
        
        if (updateSectionMatch) {
            sectionName = updateSectionMatch[1].trim();
            newContent = updateSectionMatch[2].trim();
        } else {
            const nameMatch = lowerQuestion.match(/section\s+["']?([^"']+)["']?/i);
            const contentMatch = lowerQuestion.match(/(?:to|with|بـ)\s*["']?(.+?)["']?$/i);
            if (nameMatch) sectionName = nameMatch[1].trim();
            if (contentMatch) newContent = contentMatch[1].trim();
        }
        
        if (sectionName && newContent) {
            // ✅ updateCustomSectionContent تستخدم getIconForSkill داخلياً
            const result = await updateCustomSectionContent(userId, sectionName, newContent);
            if (result.success) return result.message;
            return `⚠️ ${result.message}`;
        }
        return "❓ Example: 'Update custom section Achievements to: Published 10 articles on AI'";
    }
    
    // ============ 26. أمر غير معروف - إجابة ذكية ============
    if (lowerQuestion.match(/^(what|how|why|when|where|who|tell me|explain|help|what is|how to)/i) || 
        lowerQuestion.includes('?') || lowerQuestion.includes('؟')) {
        return "🤔 **أنا هنا لمساعدتك في إدارة ملفك الشخصي!**\n\n" +
               "📌 **الأوامر المتاحة:**\n" +
               "• **المهارات:** 'Add skill React 85%', 'Update React to 90%', 'Delete React'\n" +
               "• **المشاريع:** 'Add project called E-commerce', 'List my projects'\n" +
               "• **الخبرات:** 'Add experience at Google as Engineer', 'Delete experience from Google'\n" +
               "• **التعليم:** 'Add education: Bachelor from Cairo University 2024'\n" +
               "• **الشهادات:** 'Add certificate: React Masterclass from Meta 2024'\n" +
               "• **الأقسام المخصصة:** 'Add custom section called Achievements with text: Won Hackathon'\n" +
               "• **المعلومات الشخصية:** 'Update my bio to: ...', 'Update location to Cairo'\n" +
               "• **التحليل:** 'Analyze my profile', 'Suggest improvements', 'Show stats'\n" +
               "• **العرض:** 'List all skills', 'Show custom sections', 'List projects'\n\n" +
               "💡 **جرب تكتب الأمر بالعربي أو الإنجليزي، أنا هفهمك!**";
    }
    
    return "🤖 **أنا آسف، لم أفهم طلبك.**\n\n" +
           "💡 **جرب أحد هذه الأوامر:**\n" +
           "• 'Add skill React 85%'\n" +
           "• 'Add project called AI Chatbot'\n" +
           "• 'Add experience at Microsoft as Engineer'\n" +
           "• 'Add education: Bachelor from Cairo University 2024'\n" +
           "• 'Add certificate: AWS Certified from Amazon 2024'\n" +
           "• 'Add custom section called Achievements with text: Won Hackathon'\n" +
           "• 'Analyze my profile'\n" +
           "• 'Show my stats'\n" +
           "• 'Suggest improvements'\n\n" +
           "📝 **يمكنك الكتابة بالعربي أو الإنجليزي، وسأفهمك!**";
}

// 11. إضافة تعليم
async function addEducation(userId, institution, degree, year, grade = '') {
    const user = await User.findById(userId);
    let education = user.profile?.education || [];
    
    education.push({
        institution: institution,
        degree: degree,
        year: year,
        grade: grade
    });
    
    user.profile.education = education;
    await user.save();
    
    return { success: true, message: `✅ Added education: **${degree}** from **${institution}** (${year})${grade ? ` - Grade: ${grade}` : ''}` };
}

// 12. إضافة شهادة
async function addCertificate(userId, name, issuer, year) {
    const user = await User.findById(userId);
    let certificates = user.profile?.certificates || [];
    
    certificates.push({
        name: name,
        issuer: issuer,
        year: year
    });
    
    user.profile.certificates = certificates;
    await user.save();
    
    return { success: true, message: `✅ Added certificate: **${name}** from **${issuer}** (${year})` };
}

// 13. تحديث الموقع
async function updateLocation(userId, newLocation) {
    const user = await User.findById(userId);
    const oldLocation = user.profile?.location || 'Not set';
    user.profile.location = newLocation;
    await user.save();
    return { success: true, message: `✅ Updated location from "${oldLocation}" to "${newLocation}"` };
}

// 14. تحديث الصناعة
async function updateIndustry(userId, newIndustry) {
    const user = await User.findById(userId);
    const oldIndustry = user.profile?.industry || 'Not set';
    user.profile.industry = newIndustry;
    await user.save();
    return { success: true, message: `✅ Updated industry from "${oldIndustry}" to "${newIndustry}"` };
}



// 15. إضافة قسم مخصص جديد
async function addCustomSection(userId, name, type, content) {
    const user = await User.findById(userId);
    if (!user) return { success: false, message: 'User not found' };
    
    let sections = user.profile?.customSections || [];
    
    // التحقق من عدم التكرار
    const exists = sections.find(s => s.name?.toLowerCase() === name.toLowerCase());
    if (exists) {
        return { success: false, message: `⚠️ Section "${name}" already exists` };
    }
    
    // ✅ إذا كان النوع skills، تأكد من وجود أيقونات
    if (type === 'skills' && content?.skills) {
        content.skills = content.skills.map(skill => ({
            ...skill,
            icon: skill.icon || getIconForSkill(skill.name, { exactMatch: true })
        }));
    }
    
    const newSection = {
        _id: new mongoose.Types.ObjectId(),
        name: name,
        type: type,
        content: content || {},
        isVisible: true,
        createdAt: new Date(),
        updatedAt: new Date()
    };
    
    sections.push(newSection);
    user.profile.customSections = sections;
    
    // إضافة إلى sectionOrder
    if (!user.profile.sectionOrder) user.profile.sectionOrder = [];
    user.profile.sectionOrder.push({
        id: `custom_${newSection._id}`,
        column: 'main'
    });
    
    await user.save();
    
    let typeText = '';
    if (type === 'text') typeText = 'نص';
    else if (type === 'skills') typeText = 'مهارات';
    else if (type === 'links') typeText = 'روابط';
    
    return { success: true, message: `✅ Added custom section: **${name}** (${typeText})` };
}

// 16. حذف قسم مخصص بالاسم
async function deleteCustomSectionByName(userId, sectionName) {
    const user = await User.findById(userId);
    if (!user) return { success: false, message: 'User not found' };
    
    const sections = user.profile?.customSections || [];
    const section = sections.find(s => s.name?.toLowerCase() === sectionName.toLowerCase());
    
    if (!section) {
        return { success: false, message: `⚠️ Section "${sectionName}" not found` };
    }
    
    // حذف من customSections
    user.profile.customSections = sections.filter(s => s._id.toString() !== section._id.toString());
    
    // حذف من sectionOrder
    if (user.profile.sectionOrder) {
        user.profile.sectionOrder = user.profile.sectionOrder.filter(item => item.id !== `custom_${section._id}`);
    }
    
    await user.save();
    
    return { success: true, message: `🗑️ Removed custom section: **${section.name}**` };
}

// 17. إظهار/إخفاء قسم مخصص
async function toggleCustomSectionVisibility(userId, sectionName, isVisible) {
    const user = await User.findById(userId);
    if (!user) return { success: false, message: 'User not found' };
    
    const sections = user.profile?.customSections || [];
    const sectionIndex = sections.findIndex(s => s.name?.toLowerCase() === sectionName.toLowerCase());
    
    if (sectionIndex === -1) {
        return { success: false, message: `⚠️ Section "${sectionName}" not found` };
    }
    
    sections[sectionIndex].isVisible = isVisible;
    sections[sectionIndex].updatedAt = new Date();
    user.profile.customSections = sections;
    await user.save();
    
    const action = isVisible ? 'shown' : 'hidden';
    const actionAr = isVisible ? 'ظاهر' : 'مخفي';
    return { success: true, message: `✅ Custom section "${sectionName}" is now ${action} (${actionAr})` };
}

// 18. تحديث محتوى قسم مخصص
async function updateCustomSectionContent(userId, sectionName, newContent) {
    const user = await User.findById(userId);
    if (!user) return { success: false, message: 'User not found' };
    
    const sections = user.profile?.customSections || [];
    const sectionIndex = sections.findIndex(s => s.name?.toLowerCase() === sectionName.toLowerCase());
    
    if (sectionIndex === -1) {
        return { success: false, message: `⚠️ Section "${sectionName}" not found` };
    }
    
    const section = sections[sectionIndex];
    
    if (section.type === 'text') {
        section.content = { text: newContent };
    } 
    else if (section.type === 'skills') {
        // محاولة استخراج مهارات من النص الجديد (مثال: "React 90%, Node.js 85%, Python 75%")
        const skillPairs = newContent.split(',').map(pair => {
            const match = pair.trim().match(/^(.+?)\s*(\d+)%?$/);
            if (match) {
                return { 
                    name: match[1].trim(), 
                    percentage: Math.min(100, parseInt(match[2])),
                    // ✅ استخدام الدالة الموحدة مع exactMatch
                    icon: getIconForSkill(match[1], { exactMatch: true })
                };
            }
            return null;
        }).filter(s => s);
        
        if (skillPairs.length === 0) {
            return { success: false, message: `⚠️ Could not parse skills. Example: 'React 90%, Node.js 85%, Python 75%'` };
        }
        section.content = { skills: skillPairs };
    } 
    else if (section.type === 'links') {
        // محاولة استخراج روابط من النص الجديد (مثال: "GitHub: https://github.com/user, LinkedIn: https://linkedin.com/in/user")
        const linkPairs = newContent.split(',').map(pair => {
            const match = pair.trim().match(/^(.+?):\s*(https?:\/\/[^\s]+)$/);
            if (match) {
                return { title: match[1].trim(), url: match[2].trim() };
            }
            return null;
        }).filter(l => l);
        
        if (linkPairs.length === 0) {
            return { success: false, message: `⚠️ Could not parse links. Example: 'GitHub: https://github.com/username, LinkedIn: https://linkedin.com/in/username'` };
        }
        section.content = { links: linkPairs };
    }
    else {
        return { success: false, message: `⚠️ Unknown section type: ${section.type}` };
    }
    
    section.updatedAt = new Date();
    user.profile.customSections = sections;
    await user.save();
    
    return { success: true, message: `✅ Updated custom section: **${section.name}**` };
}
// تنسيق الرد التحليلي
function formatAnalysisResponse(analysis, user) {
    let response = `🤖 **Profile Analysis**\n\n`;
    
    const barLength = 20;
    const filled = Math.round((analysis.completeness / 100) * barLength);
    const empty = barLength - filled;
    const bar = '█'.repeat(filled) + '░'.repeat(empty);
    
    response += `**Completion:** ${analysis.completeness}% ${bar}\n\n`;
    
    if (analysis.strengths.length > 0) {
        response += `✅ **Strengths (Top ${Math.min(3, analysis.strengths.length)}):**\n`;
        analysis.strengths.slice(0, 3).forEach(s => {
            response += `• ${s}\n`;
        });
        response += `\n`;
    }
    
    if (analysis.weaknesses.length > 0) {
        response += `⚠️ **Skills to improve:**\n`;
        analysis.weaknesses.forEach(w => {
            response += `• ${w}\n`;
        });
        response += `\n`;
    }
    
    if (analysis.suggestions.length > 0) {
        response += `💡 **Suggestions:**\n`;
        analysis.suggestions.slice(0, 4).forEach(s => {
            response += `• ${s}\n`;
        });
        response += `\n`;
    }
    
    if (analysis.missingInfo.length > 0) {
        response += `📝 **Missing info to add:**\n`;
        analysis.missingInfo.slice(0, 5).forEach(m => {
            response += `• ${m}\n`;
        });
    }
    
    return response;
}

// ============================================
// ============================================
// 🤖 AI BOT API ENDPOINTS
// ============================================
// ============================================

// GET /api/profile/:nickname/ai-status - جلب حالة البوت
app.get('/api/profile/:nickname/ai-status', async (req, res) => {
    try {
        const { nickname } = req.params;
        
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${nickname}$`, $options: 'i' } },
                { username: { $regex: `^${nickname}$`, $options: 'i' } }
            ]
        }).select('profile.aiBot');
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        const enabled = user.profile?.aiBot?.enabled || false;
        res.json({ enabled });
        
    } catch (error) {
        console.error('Error getting AI status:', error.message);
        res.status(500).json({ error: 'Failed to get AI status' });
    }
});

// POST /api/profile/:nickname/ask - السؤال عن بروفايل المستخدم
app.post('/api/profile/:nickname/ask', async (req, res) => {
    const startTime = Date.now();
    
    try {
        const { nickname } = req.params;
        const { question, language: requestedLanguage } = req.body;
        
        // 1. التحقق من صحة السؤال
        if (!question || question.trim().length < 2) {
            return res.status(400).json({ 
                error: 'Question is too short (minimum 2 characters)' 
            });
        }
        
        if (question.trim().length > 1000) {
            return res.status(400).json({ 
                error: 'Question is too long (maximum 1000 characters)' 
            });
        }
        
        // 2. جلب بيانات المستخدم
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${nickname}$`, $options: 'i' } },
                { username: { $regex: `^${nickname}$`, $options: 'i' } }
            ]
        });
        
        if (!user) {
            return res.status(404).json({ 
                error: `User not found: ${nickname}` 
            });
        }
        
        // 3. التحقق من تفعيل البوت
        const aiConfig = user.profile?.aiBot || { enabled: false };
        if (!aiConfig.enabled) {
            return res.status(403).json({ 
                error: 'AI Bot is not enabled for this profile' 
            });
        }
        
        // 4. التحقق إذا كان السائل هو صاحب البروفايل
        const isOwner = req.user && req.user.userId === user._id;
        
        // 5. تحديد اللغة
        const targetLanguage = requestedLanguage || detectLanguage(question);
        
        // ✅ 6. إذا كان المالك
        if (isOwner) {
            // محاولة معالجة الأمر
            const commandResult = await processOwnerCommand(question, user);
            
            if (commandResult) {
                await User.updateOne(
                    { _id: user._id },
                    { 
                        $inc: { 'profile.aiBot.totalQueries': 1 },
                        $set: { 'profile.aiBot.lastQueryAt': new Date() }
                    }
                );
                
                return res.json({
                    success: true,
                    answer: commandResult,
                    language: targetLanguage,
                    provider: 'assistant',
                    responseTime: Date.now() - startTime,
                    isCommand: true
                });
            }
            
            // استخدام Owner AI (بضمير المخاطب "أنت")
            const result = await askOwnerAI(question, user, targetLanguage);
            
            await User.updateOne(
                { _id: user._id },
                { 
                    $inc: { 'profile.aiBot.totalQueries': 1 },
                    $set: { 'profile.aiBot.lastQueryAt': new Date() }
                }
            );
            
            return res.json({
                success: true,
                answer: result.answer,
                language: targetLanguage,
                provider: result.provider,
                responseTime: Date.now() - startTime,
                isCommand: false
            });
        }
        
        // ✅ 7. للزوار العاديين
        const profileContext = buildProfileContextMultiLang(user, targetLanguage);
        
        let result;
        if (aiConfig.provider === 'custom' && aiConfig.customApiKey && aiConfig.customApiKey.trim() !== '') {
            result = await askCustomAI(question, profileContext, aiConfig, targetLanguage);
        } else {
            result = await askMGZonAI(question, profileContext, targetLanguage);
        }
        
        // حفظ المحادثة للزوار فقط
        const visitorIp = req.ip || req.headers['x-forwarded-for'] || req.connection.remoteAddress || '';
        await saveAIConversation(
            user._id,
            question,
            result.answer,
            aiConfig.provider === 'custom' ? 'custom' : 'mgzon',
            targetLanguage,
            result.responseTime,
            visitorIp
        );
        
        res.json({
            success: true,
            answer: result.answer,
            language: targetLanguage,
            provider: aiConfig.provider === 'custom' ? 'custom' : 'mgzon',
            responseTime: Date.now() - startTime
        });
        
    } catch (error) {
        console.error('Error in AI bot:', error.message);
        res.status(500).json({ 
            error: 'Sorry, an error occurred. Please try again.' 
        });
    }
});

// GET /api/ai/conversations - عرض محادثات البوت (للمالك فقط)
app.get('/api/ai/conversations', authenticateToken, async (req, res) => {
    try {
        const { limit = 50, page = 1 } = req.query;
        
        const conversations = await AIConversation.find({ userId: req.user.userId })
            .sort({ timestamp: -1 })
            .limit(parseInt(limit))
            .skip((parseInt(page) - 1) * parseInt(limit));
        
        const total = await AIConversation.countDocuments({ userId: req.user.userId });
        
        res.json({
            success: true,
            data: conversations,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / parseInt(limit))
            }
        });
        
    } catch (error) {
        console.error('Error fetching AI conversations:', error.message);
        res.status(500).json({ error: 'Failed to fetch conversations' });
    }
});

// GET /api/ai/stats - إحصائيات استخدام البوت
app.get('/api/ai/stats', authenticateToken, async (req, res) => {
    try {
        const total = await AIConversation.countDocuments({ userId: req.user.userId });
        
        const last7Days = await AIConversation.aggregate([
            { $match: { userId: req.user.userId, timestamp: { $gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) } } },
            { $group: { _id: { $dateToString: { format: '%Y-%m-%d', date: '$timestamp' } }, count: { $sum: 1 } } },
            { $sort: { _id: 1 } }
        ]);
        
        const providerStats = await AIConversation.aggregate([
            { $match: { userId: req.user.userId } },
            { $group: { _id: '$provider', count: { $sum: 1 } } }
        ]);
        
        const avgResponseTime = await AIConversation.aggregate([
            { $match: { userId: req.user.userId, responseTime: { $gt: 0 } } },
            { $group: { _id: null, avg: { $avg: '$responseTime' } } }
        ]);
        
        // جلب إعدادات البوت الحالية
        const user = await User.findById(req.user.userId).select('profile.aiBot');
        const aiConfig = user?.profile?.aiBot || {};
        
        res.json({
            success: true,
            stats: {
                total,
                last7Days,
                providerStats,
                avgResponseTime: Math.round(avgResponseTime[0]?.avg || 0),
                enabled: aiConfig.enabled || false,
                provider: aiConfig.provider || 'mgzon',
                totalQueries: aiConfig.totalQueries || 0,
                lastQueryAt: aiConfig.lastQueryAt || null
            }
        });
        
    } catch (error) {
        console.error('Error fetching AI stats:', error.message);
        res.status(500).json({ error: 'Failed to fetch stats' });
    }
});




// ============================================
// 🛒 STORE API ENDPOINTS
// ============================================


// ============================================
// GET /api/store/me - جلب متجر المستخدم الحالي (للـ dashboard والـ settings)
// ============================================
app.get('/api/store/me', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;

        // جلب إعدادات المتجر
        let storeSettings = await StoreSettings.findOne({ userId });
        if (!storeSettings) {
            storeSettings = new StoreSettings({
                userId,
                primaryColor: '#3b82f6',
                secondaryColor: '#8b5cf6',
                fontFamily: 'Inter, sans-serif',
                borderRadius: 16,
                shadowType: 'md',
                animationType: 'lift',
                glassEffect: false,
                backgroundType: 'default',
                backgroundValue: '',
                customCss: '',
                productViewType: 'modal',
                pagesOrder: { products: 1, about: 2, contact: 3 }
            });
            await storeSettings.save();
        }

        // جلب القالب
        const theme = await StoreTheme.findOne({ userId });

        // جلب المنتجات
        const products = await Product.find({ userId, isActive: true })
            .select('title price type images salesCount averageRating')
            .sort({ createdAt: -1 })
            .limit(12);

        // جلب الطلبات الأخيرة
        const recentOrders = await Order.find({ sellerId: userId })
            .populate('buyerId', 'username profile.nickname profile.avatar')
            .sort({ createdAt: -1 })
            .limit(10);

        // إحصائيات
        const totalProducts = await Product.countDocuments({ userId, isActive: true });
        const totalOrders = await Order.countDocuments({ sellerId: userId });
        const completedOrders = await Order.find({ sellerId: userId, status: 'completed' });
        const totalEarnings = completedOrders.reduce((sum, order) => sum + order.totalAmount, 0);
        const followersCount = await StoreFollow.countDocuments({ storeId: userId });

        // بيانات المستخدم
        const user = await User.findById(userId).select('username profile.nickname profile.avatar');

        // جلب الصفحات المخصصة
        const pages = await Page.find({ storeId: userId, isEnabled: true })
            .sort({ order: 1 })
            .select('slug title type order stats content');

        const totalPageViews = pages.reduce((sum, p) => sum + (p.stats?.views || 0), 0);

        // جلب عدد الـ Shortcodes النشطة
        const shortcodesCount = await StoreShortcode.countDocuments({ userId, isActive: true });

        // معالجة Shortcodes لكل صفحة
        const userToken = req.headers.authorization?.split(' ')[1];
        const processedPages = await Promise.all(
            pages.map(async (p) => {
                let processedContent = p.content || '';
                try {
                    processedContent = await ShortcodeService.parseShortcodes(
                        processedContent,
                        userId,
                        { userToken }
                    );
                } catch (err) {
                    console.error(`Shortcode error for page ${p.slug}:`, err);
                }
                return {
                    _id: p._id,
                    slug: p.slug,
                    title: p.title,
                    type: p.type,
                    order: p.order,
                    views: p.stats?.views || 0,
                    content: processedContent
                };
            })
        );

        res.json({
            success: true,
            store: {
                id: userId,
                username: user.username,
                nickname: user.profile?.nickname,
                avatar: user.profile?.avatar,
                storeName: storeSettings.storeName || user.profile?.nickname || user.username,
                storeLogo: storeSettings.storeLogo,
                storeBanner: storeSettings.storeBanner,
                storeDescription: storeSettings.storeDescription,
                contactEmail: storeSettings.contactEmail || user.email,
                currency: storeSettings.currency,
                currencySymbol: storeSettings.currencySymbol,
                enabled: storeSettings.enabled,
                productViewType: storeSettings.productViewType || 'modal',
                productsCount: totalProducts,
                followersCount,
                totalEarnings,
                totalOrders,
                pagesOrder: storeSettings.pagesOrder || { products: 1, about: 2, contact: 3 }
            },
            settings: {
                primaryColor: theme?.colors?.primary || storeSettings.primaryColor,
                secondaryColor: theme?.colors?.secondary || storeSettings.secondaryColor,
                fontFamily: theme?.typography?.fontFamily || storeSettings.fontFamily,
                borderRadius: storeSettings.borderRadius,
                shadowType: storeSettings.shadowType,
                animationType: storeSettings.animationType,
                glassEffect: storeSettings.glassEffect,
                backgroundType: storeSettings.backgroundType,
                backgroundValue: storeSettings.backgroundValue,
                customCss: storeSettings.customCss,
                paymentMethods: storeSettings.paymentMethods || [],
                socialLinks: storeSettings.socialLinks || {},
                pageBuilder: storeSettings.pageBuilder || { sections: [] },
                theme: theme ? {
                    colors: theme.colors,
                    typography: theme.typography,
                    layout: theme.layout,
                    hasCustomTemplate: !!theme.customTemplates?.header || !!theme.uploadedTheme?.fileUrl
                } : null
            },
            products,
            recentOrders: recentOrders.map(order => ({
                _id: order._id,
                orderNumber: order.orderNumber,
                totalAmount: order.totalAmount,
                status: order.status,
                buyerName: order.buyerId?.profile?.nickname || order.buyerId?.username,
                createdAt: order.createdAt
            })),
            pages: processedPages,
            stats: {
                totalProducts,
                totalOrders,
                totalEarnings,
                followersCount,
                totalPageViews,
                shortcodesCount,
                storeUrl: `/shop/${user.profile?.nickname || user.username}`
            }
        });

    } catch (error) {
        console.error('Error fetching my store:', error);
        res.status(500).json({ error: 'Failed to load store data' });
    }
});


// ============================================
// 🎨 THEME ROUTES
// ============================================

/**
 * GET /api/store/theme
 * جلب قالب المتجر الحالي
 */
app.get('/api/store/theme', authenticateToken, async (req, res) => {
    try {
        const theme = await StoreTheme.getActiveTheme(req.user.userId);
        res.json({ success: true, theme });
    } catch (error) {
        console.error('Error fetching theme:', error);
        res.status(500).json({ error: 'Failed to fetch theme' });
    }
});



app.post('/api/store/theme/upload', authenticateToken, uploadTheme.single('file'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ error: 'No file uploaded' });
        }

        const file = req.file;
        const zip = new AdmZip(file.buffer);
        const zipEntries = zip.getEntries();

        // ============================================
        // 1. تصنيف الملفات داخل الـ ZIP
        // ============================================
        let indexHtml = '';
        let headerHtml = '';
        let footerHtml = '';
        let sidebarHtml = '';
        let productCardHtml = '';
        let categoryCardHtml = '';
        let cssContent = '';
        let jsContent = '';
        const images = [];
        const otherFiles = [];

        for (const entry of zipEntries) {
            if (entry.isDirectory) continue;

            const fileName = entry.entryName.toLowerCase();
            const content = entry.getData();
            
            // HTML files
            if (fileName.endsWith('.html') || fileName.endsWith('.htm')) {
                const htmlContent = content.toString('utf8');
                
                if (fileName === 'index.html' || fileName === 'index.htm') {
                    indexHtml = htmlContent;
                }
                
                // استخراج الـ header
                const headerMatch = htmlContent.match(/<header[^>]*>([\s\S]*?)<\/header>/i);
                if (headerMatch && !headerHtml) headerHtml = headerMatch[0];
                
                // استخراج الـ footer
                const footerMatch = htmlContent.match(/<footer[^>]*>([\s\S]*?)<\/footer>/i);
                if (footerMatch && !footerHtml) footerHtml = footerMatch[0];
                
                // استخراج الـ sidebar
                const sidebarMatch = htmlContent.match(/<aside[^>]*>([\s\S]*?)<\/aside>/i);
                if (sidebarMatch && !sidebarHtml) sidebarHtml = sidebarMatch[0];
                
                // استخراج قالب المنتج
                if (fileName.includes('product') && !productCardHtml) {
                    productCardHtml = htmlContent;
                }
                
                // استخراج قالب القسم
                if (fileName.includes('category') && !categoryCardHtml) {
                    categoryCardHtml = htmlContent;
                }
            }
            
            // CSS files
            else if (fileName.endsWith('.css')) {
                cssContent += content.toString('utf8') + '\n';
            }
            
            // JS files
            else if (fileName.endsWith('.js')) {
                jsContent += content.toString('utf8') + '\n';
            }
            
            // Images
            else if (/\.(jpg|jpeg|png|gif|svg|webp|ico)$/i.test(fileName)) {
                images.push({
                    name: entry.entryName,
                    size: content.length,
                    data: content
                });
            }
            
            // Other files
            else {
                otherFiles.push({
                    name: entry.entryName,
                    size: content.length,
                    type: path.extname(fileName)
                });
            }
        }

        // ============================================
        // 2. إذا لم يتم العثور على Header/Footer، حاول استخراجهم من index.html
        // ============================================
        if (indexHtml && (!headerHtml || !footerHtml)) {
            // محاولة استخراج الهيدر والفوتر من index.html بطريقة أذكى
            const bodyMatch = indexHtml.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
            if (bodyMatch) {
                const bodyContent = bodyMatch[1];
                
                // البحث عن أول div كبير قد يكون الهيدر
                const firstDivMatch = bodyContent.match(/<(header|div)[^>]*class=["'][^"']*(?:header|navbar|top)[^"']*["'][^>]*>([\s\S]*?)<\/(header|div)>/i);
                if (firstDivMatch && !headerHtml) {
                    headerHtml = firstDivMatch[0];
                }
                
                // البحث عن آخر div كبير قد يكون الفوتر
                const lastDivMatch = bodyContent.match(/<(footer|div)[^>]*class=["'][^"']*(?:footer|bottom)[^"']*["'][^>]*>([\s\S]*?)<\/(footer|div)>/i);
                if (lastDivMatch && !footerHtml) {
                    footerHtml = lastDivMatch[0];
                }
            }
        }

        // ============================================
        // 3. رفع الصور إلى Cloudinary (إذا كان متاحاً)
        // ============================================
        const uploadedImages = [];
        
        if (typeof cloudinary !== 'undefined' && cloudinary.uploader) {
            for (const img of images) {
                try {
                    const b64 = img.data.toString('base64');
                    const dataURI = `data:image/${path.extname(img.name).slice(1)};base64,${b64}`;
                    
                    const result = await cloudinary.uploader.upload(dataURI, {
                        folder: `StoreThemes/${req.user.userId}/images`,
                        public_id: img.name.replace(/[^a-z0-9.-]/gi, '-'),
                        resource_type: 'image'
                    });
                    
                    uploadedImages.push({
                        originalName: img.name,
                        url: result.secure_url,
                        publicId: result.public_id
                    });
                } catch (err) {
                    console.error(`Image upload failed for ${img.name}:`, err);
                }
            }
        }

        // ============================================
        // 4. حفظ القالب في قاعدة البيانات
        // ============================================
        
        // جلب القالب الحالي أو إنشاء جديد
        let theme = await StoreTheme.findOne({ userId: req.user.userId });
        
        if (!theme) {
            theme = new StoreTheme({ userId: req.user.userId });
        }
        
        // توليد hash فريد للملف
        const fileHash = crypto.createHash('md5').update(file.buffer).digest('hex');
        
        // تحديث بيانات القالب
        theme.name = file.originalname.replace('.zip', '').replace(/[^a-z0-9]/gi, ' ');
        theme.uploadedTheme = {
            filename: file.originalname,
            originalName: file.originalname,
            fileSize: file.size,
            fileHash: fileHash,
            mimeType: file.mimetype,
            uploadedAt: new Date(),
            extractedFiles: {
                htmlFiles: [{ name: 'index.html', size: indexHtml.length }],
                cssFiles: cssContent ? [{ name: 'theme.css', size: cssContent.length }] : [],
                jsFiles: jsContent ? [{ name: 'theme.js', size: jsContent.length }] : [],
                imageFiles: uploadedImages.map(img => ({ name: img.originalName, size: 0, url: img.url }))
            }
        };
        
        // حفظ القوالب المخصصة
        theme.customTemplates = {
            header: headerHtml || theme.customTemplates?.header || '',
            footer: footerHtml || theme.customTemplates?.footer || '',
            sidebar: sidebarHtml || theme.customTemplates?.sidebar || '',
            productCard: productCardHtml || theme.customTemplates?.productCard || '',
            categoryCard: categoryCardHtml || theme.customTemplates?.categoryCard || ''
        };
        
        // حفظ CSS/JS المخصص
        theme.customAssets = {
            css: cssContent || theme.customAssets?.css || '',
            js: jsContent || theme.customAssets?.js || ''
        };
        
        // تفعيل القالب تلقائياً
        theme.isActive = true;
        theme.version = '2.0.0';
        theme.updatedAt = Date.now();
        
        await theme.save();
        
        // ============================================
        // 5. تحديث إعدادات المتجر لربط القالب
        // ============================================
        await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { 
                activeThemeId: theme._id,
                customCss: cssContent || '',
                updatedAt: Date.now()
            },
            { upsert: true }
        );

        // ============================================
        // 6. إرسال الرد مع تفاصيل القالب
        // ============================================
        res.json({
            success: true,
            message: 'Theme uploaded successfully!',
            theme: {
                _id: theme._id,
                name: theme.name,
                hasHeader: !!theme.customTemplates.header,
                hasFooter: !!theme.customTemplates.footer,
                hasCustomCSS: !!theme.customAssets.css,
                hasCustomJS: !!theme.customAssets.js,
                imagesCount: uploadedImages.length,
                totalFiles: zipEntries.length,
                extractedFiles: {
                    html: !!indexHtml,
                    css: !!cssContent,
                    js: !!jsContent,
                    images: uploadedImages.length
                }
            },
            preview: {
                headerPreview: headerHtml ? headerHtml.substring(0, 200) + (headerHtml.length > 200 ? '...' : '') : null,
                cssPreview: cssContent ? cssContent.substring(0, 200) + (cssContent.length > 200 ? '...' : '') : null
            }
        });
        
        console.log(`✅ Theme uploaded for user ${req.user.userId}: ${file.originalname}`);
        
    } catch (error) {
        console.error('Error uploading theme:', error);
        res.status(500).json({ 
            error: 'Failed to upload theme', 
            details: error.message,
            stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
        });
    }
});



// ============================================
// 🖼️ COMPLETE BACKGROUNDS API ROUTES
// ============================================

// ============================================
// GET /api/backgrounds - جلب جميع الخلفيات
// ============================================
app.get('/api/backgrounds', async (req, res) => {
    try {
        let userId = null;
        
        // جلب userId من التوكن إن وجد
        if (req.headers.authorization) {
            try {
                const token = req.headers.authorization.split(' ')[1];
                const decoded = jwt.verify(token, process.env.JWT_SECRET);
                userId = decoded.userId;
            } catch(e) {}
        }
        
        const backgrounds = await getAvailableBackgrounds(userId);
        
        res.json({
            success: true,
            backgrounds: backgrounds,
            total: backgrounds.length,
            currentBackground: userId ? await getCurrentBackground(userId) : null
        });
        
    } catch (error) {
        console.error('Error fetching backgrounds:', error);
        res.status(500).json({ error: 'Failed to fetch backgrounds' });
    }
});

// ============================================
// GET /api/backgrounds/categories - جلب التصنيفات
// ============================================
app.get('/api/backgrounds/categories', async (req, res) => {
    try {
        const backgrounds = await getAvailableBackgrounds(null);
        const categories = [...new Set(backgrounds.map(b => b.category))].filter(Boolean);
        
        res.json({
            success: true,
            categories: categories.map(c => ({
                name: c,
                count: backgrounds.filter(b => b.category === c).length,
                icon: getCategoryIcon(c)
            }))
        });
        
    } catch (error) {
        console.error('Error fetching categories:', error);
        res.status(500).json({ error: 'Failed to fetch categories' });
    }
});

function getCategoryIcon(category) {
    const icons = {
        'abstract': '🌀',
        'space': '🚀',
        'gradient': '🌈',
        'tech': '💻',
        'nature': '🌿',
        'custom': '🎨'
    };
    return icons[category] || '🖼️';
}

// ============================================
// دالة مساعدة لجلب الخلفية الحالية للمستخدم
// ============================================
async function getCurrentBackground(userId) {
    try {
        const settings = await StoreSettings.findOne({ userId });
        
        if (!settings) {
            return null;
        }
        
        const currentBg = settings.currentBackground || {
            url: settings.backgroundValue || '',
            type: settings.backgroundType || 'default',
            name: ''
        };
        
        // جلب الخلفية من القائمة العامة إذا كانت موجودة
        if (currentBg.url) {
            const allBg = await getAvailableBackgrounds(userId);
            const fullBg = allBg.find(b => b.url === currentBg.url);
            if (fullBg) {
                currentBg.name = fullBg.name;
                currentBg.category = fullBg.category;
            }
        }
        
        return currentBg;
    } catch (error) {
        console.error('Error getting current background:', error);
        return null;
    }
}

// ============================================
// GET /api/backgrounds/:id - جلب خلفية معينة
// ============================================
app.get('/api/backgrounds/:id', async (req, res) => {
    try {
        const backgrounds = await getAvailableBackgrounds(null);
        const background = backgrounds.find(b => b.id === req.params.id);
        
        if (!background) {
            return res.status(404).json({ error: 'Background not found' });
        }
        
        res.json({ success: true, background });
        
    } catch (error) {
        console.error('Error fetching background:', error);
        res.status(500).json({ error: 'Failed to fetch background' });
    }
});

// ============================================
// POST /api/store/background - تطبيق خلفية
// ============================================
app.post('/api/store/background', authenticateToken, async (req, res) => {
    try {
        const { backgroundId, backgroundUrl, backgroundName, backgroundType } = req.body;
        
        let background;
        
        // لو جاي بالـ ID، نجيب الخلفية من القائمة
        if (backgroundId) {
            const backgrounds = await getAvailableBackgrounds(req.user.userId);
            background = backgrounds.find(b => b.id === backgroundId);
            if (!background) {
                return res.status(404).json({ error: 'Background not found' });
            }
        } 
        // لو جاي بالـ URL مباشرة
        else if (backgroundUrl) {
            background = {
                id: `custom_${Date.now()}`,
                url: backgroundUrl,
                name: backgroundName || 'Custom Background',
                type: backgroundType || 'image'
            };
        } 
        else {
            return res.status(400).json({ error: 'Background ID or URL is required' });
        }
        
        // تطبيق الخلفية
        const settings = await applyBackgroundToStore(req.user.userId, background);
        
        console.log(`✅ Background applied for user ${req.user.userId}: ${background.name}`);
        
        res.json({
            success: true,
            message: `Background "${background.name}" applied successfully!`,
            background: background,
            settings: settings
        });
        
    } catch (error) {
        console.error('Error applying background:', error);
        res.status(500).json({ error: 'Failed to apply background' });
    }
});

// ============================================
// POST /api/store/backgrounds/upload - رفع خلفية مخصصة
// ============================================
app.post('/api/store/backgrounds/upload', authenticateToken, upload.single('background'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ error: 'No file uploaded' });
        }
        
        const fileUrl = req.file.path || req.file.url;
        const backgroundName = req.body.name || 'Custom Background';
        const backgroundCategory = req.body.category || 'custom';
        
        const newBackground = {
            id: `custom_${Date.now()}`,
            name: backgroundName,
            url: fileUrl,
            category: backgroundCategory,
            type: req.file.mimetype?.startsWith('image/gif') ? 'gif' : 'image',
            uploadedAt: new Date(),
            userId: req.user.userId,
            isActive: true
        };
        
        const settings = await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            {
                $push: { customBackgrounds: newBackground },
                $set: { updatedAt: Date.now() }
            },
            { upsert: true, new: true }
        );
        
        res.json({
            success: true,
            background: newBackground,
            message: 'Background uploaded successfully'
        });
        
    } catch (error) {
        console.error('Error uploading background:', error);
        res.status(500).json({ error: 'Failed to upload background' });
    }
});

// ============================================
// DELETE /api/store/backgrounds/:id - حذف خلفية مخصصة
// ============================================
app.delete('/api/store/backgrounds/:id', authenticateToken, async (req, res) => {
    try {
        const backgroundId = req.params.id;
        
        const settings = await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            {
                $pull: { customBackgrounds: { id: backgroundId } },
                $set: { updatedAt: Date.now() }
            },
            { new: true }
        );
        
        if (!settings) {
            return res.status(404).json({ error: 'Settings not found' });
        }
        
        res.json({
            success: true,
            message: 'Background deleted successfully'
        });
        
    } catch (error) {
        console.error('Error deleting background:', error);
        res.status(500).json({ error: 'Failed to delete background' });
    }
});

// ============================================
// GET /api/store/background/current - جلب الخلفية الحالية
// ============================================
app.get('/api/store/background/current', authenticateToken, async (req, res) => {
    try {
        const settings = await StoreSettings.findOne({ userId: req.user.userId });
        
        if (!settings) {
            return res.json({ currentBackground: null });
        }
        
        const currentBg = settings.currentBackground || {
            url: settings.backgroundValue || '',
            type: settings.backgroundType || 'default'
        };
        
        // جلب الخلفية من القائمة العامة إذا كانت موجودة
        if (currentBg.url) {
            const allBg = await getAvailableBackgrounds(req.user.userId);
            const fullBg = allBg.find(b => b.url === currentBg.url);
            if (fullBg) {
                currentBg.name = fullBg.name;
                currentBg.category = fullBg.category;
            }
        }
        
        res.json({
            success: true,
            currentBackground: currentBg
        });
        
    } catch (error) {
        console.error('Error fetching current background:', error);
        res.status(500).json({ error: 'Failed to fetch current background' });
    }
});

// ============================================
// GET /api/store/background/history - جلب سجل الخلفيات
// ============================================
app.get('/api/store/background/history', authenticateToken, async (req, res) => {
    try {
        const settings = await StoreSettings.findOne({ userId: req.user.userId });
        
        if (!settings) {
            return res.json({ history: [] });
        }
        
        res.json({
            success: true,
            history: settings.backgroundHistory || []
        });
        
    } catch (error) {
        console.error('Error fetching background history:', error);
        res.status(500).json({ error: 'Failed to fetch history' });
    }
});


// ============================================
// GET /api/store/theme/preview - معاينة القالب المرفوع
// ============================================
app.get('/api/store/theme/preview', authenticateToken, async (req, res) => {
    try {
        const theme = await StoreTheme.findOne({ 
            userId: req.user.userId, 
            isActive: true 
        });
        
        if (!theme || !theme.uploadedTheme?.fileHash) {
            return res.json({
                success: true,
                hasCustomTheme: false,
                message: 'No custom theme uploaded'
            });
        }
        
        res.json({
            success: true,
            hasCustomTheme: true,
            theme: {
                name: theme.name,
                uploadedAt: theme.uploadedTheme.uploadedAt,
                fileSize: theme.uploadedTheme.fileSize,
                hasHeader: !!theme.customTemplates.header,
                hasFooter: !!theme.customTemplates.footer,
                hasCustomCSS: !!theme.customAssets.css,
                hasCustomJS: !!theme.customAssets.js,
                imagesCount: theme.uploadedTheme.extractedFiles?.imageFiles?.length || 0
            },
            preview: {
                header: theme.customTemplates.header ? theme.customTemplates.header.substring(0, 500) : null,
                css: theme.customAssets.css ? theme.customAssets.css.substring(0, 500) : null
            }
        });
        
    } catch (error) {
        console.error('Error previewing theme:', error);
        res.status(500).json({ error: 'Failed to preview theme' });
    }
});
/**
 * PUT /api/store/theme
 * حفظ قالب المتجر
 */
app.put('/api/store/theme', authenticateToken, async (req, res) => {
    try {
        const { customTemplates, settings, colors, typography, customAssets, seo } = req.body;
        
        let theme = await StoreTheme.findOne({ userId: req.user.userId });
        if (!theme) {
            theme = new StoreTheme({ userId: req.user.userId });
        }
        
        if (customTemplates) theme.customTemplates = { ...theme.customTemplates, ...customTemplates };
        if (settings) theme.settings = { ...theme.settings, ...settings };
        if (colors) theme.colors = { ...theme.colors, ...colors };
        if (typography) theme.typography = { ...theme.typography, ...typography };
        if (customAssets) theme.customAssets = { ...theme.customAssets, ...customAssets };
        if (seo) theme.seo = { ...theme.seo, ...seo };
        
        await theme.recordChange();
        await theme.save();
        
        res.json({ success: true, theme });
    } catch (error) {
        console.error('Error saving theme:', error);
        res.status(500).json({ error: 'Failed to save theme' });
    }
});

/**
 * POST /api/store/theme/reset
 * إعادة تعيين القالب إلى الإعدادات الافتراضية
 */
app.post('/api/store/theme/reset', authenticateToken, async (req, res) => {
    try {
        const theme = await StoreTheme.resetToDefault(req.user.userId);
        res.json({ success: true, theme });
    } catch (error) {
        console.error('Error resetting theme:', error);
        res.status(500).json({ error: 'Failed to reset theme' });
    }
});

// ============================================
// 📝 SHORTCODE ROUTES
// ============================================

/**
 * POST /api/store/shortcodes/parse
 * معالجة الـ Shortcodes في المحتوى
 */
app.post('/api/store/shortcodes/parse', async (req, res) => {
    try {
        const { content, storeId, userToken } = req.body;
        
        if (!content) {
            return res.json({ success: true, parsedContent: '' });
        }
        
        const parsedContent = await ShortcodeService.parseShortcodes(content, storeId, { userToken });
        res.json({ success: true, parsedContent });
    } catch (error) {
        console.error('Error parsing shortcodes:', error);
        res.json({ success: true, parsedContent: req.body.content || '' });
    }
});

/**
 * GET /api/store/shortcodes
 * جلب قائمة الـ Shortcodes المتاحة
 */
app.get('/api/store/shortcodes', authenticateToken, async (req, res) => {
    try {
        const shortcodes = await ShortcodeService.getAllShortcodes(req.user.userId);
        res.json({ success: true, shortcodes });
    } catch (error) {
        console.error('Error fetching shortcodes:', error);
        res.status(500).json({ error: 'Failed to fetch shortcodes' });
    }
});

/**
 * POST /api/store/shortcodes
 * إنشاء Shortcode مخصص جديد
 */
app.post('/api/store/shortcodes', authenticateToken, async (req, res) => {
    try {
        const shortcode = await ShortcodeService.createCustomShortcode(req.user.userId, req.body);
        res.status(201).json({ success: true, shortcode });
    } catch (error) {
        console.error('Error creating shortcode:', error);
        res.status(400).json({ error: error.message });
    }
});

/**
 * PUT /api/store/shortcodes/:id
 * تحديث Shortcode مخصص
 */
app.put('/api/store/shortcodes/:id', authenticateToken, async (req, res) => {
    try {
        const shortcode = await ShortcodeService.updateCustomShortcode(req.params.id, req.user.userId, req.body);
        res.json({ success: true, shortcode });
    } catch (error) {
        console.error('Error updating shortcode:', error);
        res.status(400).json({ error: error.message });
    }
});

/**
 * DELETE /api/store/shortcodes/:id
 * حذف Shortcode مخصص
 */
app.delete('/api/store/shortcodes/:id', authenticateToken, async (req, res) => {
    try {
        const deleted = await ShortcodeService.deleteCustomShortcode(req.params.id, req.user.userId);
        if (deleted) {
            res.json({ success: true });
        } else {
            res.status(404).json({ error: 'Shortcode not found' });
        }
    } catch (error) {
        console.error('Error deleting shortcode:', error);
        res.status(500).json({ error: 'Failed to delete shortcode' });
    }
});

/**
 * POST /api/store/shortcodes/preview
 * معاينة Shortcode
 */
app.post('/api/store/shortcodes/preview', authenticateToken, async (req, res) => {
    try {
        const html = await ShortcodeService.previewShortcode(req.body, {
            storeId: req.user.userId,
            userToken: req.headers.authorization
        });
        res.json({ success: true, html });
    } catch (error) {
        console.error('Error previewing shortcode:', error);
        res.status(400).json({ error: error.message });
    }
});

// ========== 1. إعدادات المتجر ==========

// ============================================
// 🛒 STORE API ENDPOINTS (UPDATED)
// ============================================

// ============================================
// GET /api/store/settings - جلب إعدادات المتجر (محدث بالكامل)
// ============================================
app.get('/api/store/settings', authenticateToken, async (req, res) => {
    try {
        let settings = await StoreSettings.findOne({ userId: req.user.userId });
        
        if (!settings) {
            settings = new StoreSettings({ 
                userId: req.user.userId,
                primaryColor: '#3b82f6',
                secondaryColor: '#8b5cf6',
                fontFamily: 'Inter, sans-serif',
                borderRadius: 16,
                shadowType: 'md',
                animationType: 'lift',
                glassEffect: false,
                backgroundType: 'default',
                backgroundValue: '',
                customCss: '',
                productViewType: 'modal',
                pagesOrder: {
                    products: 1,
                    about: 2,
                    contact: 3
                },
                layoutSettings: {
                    headerLayout: 'default',
                    footerLayout: 'default',
                    productsPerRowDesktop: 4,
                    enableQuickView: true,
                    enableProductReviews: true
                }
            });
            await settings.save();
        }
        
        // ✅ جلب القالب أيضاً
        let theme = await StoreTheme.findOne({ userId: req.user.userId });
        if (!theme) {
            theme = new StoreTheme({ userId: req.user.userId });
            await theme.save();
        }
        

        const customBackgrounds = settings.customBackgrounds || [];
        const currentBackground = settings.currentBackground || {
            url: settings.backgroundValue || '',
            type: settings.backgroundType || 'default',
            name: ''
        };
        const backgroundHistory = settings.backgroundHistory || [];

        // ✅ إرجاع كل الحقول مع القالب والقالب المطبق
        res.json({ 
            success: true, 
            settings: {
                ...settings.toObject(),
                appliedTemplate: settings.appliedTemplate || null,  // ✅ يحتوي على templateUrl

                customBackgrounds: customBackgrounds,
                currentBackground: currentBackground,
                backgroundHistory: backgroundHistory

            },
            theme: {
                colors: theme.colors,
                typography: theme.typography,
                settings: theme.settings,
                customTemplates: theme.customTemplates,
                layout: theme.layout,
                uploadedTheme: theme.uploadedTheme || null
            }
        });
    } catch (error) {
        console.error('Error fetching store settings:', error);
        res.status(500).json({ error: 'Failed to fetch store settings' });
    }
});

// ============================================
// PUT /api/store/settings - حفظ إعدادات المتجر (محدث بالكامل)
// ============================================
app.put('/api/store/settings', authenticateToken, async (req, res) => {
    try {
        const { 
            storeName, 
            storeLogo, 
            storeBanner, 
            storeDescription, 
            currency, 
            paymentMethods, 
            pageBuilder, 
            socialLinks,
            primaryColor,
            secondaryColor,
            fontFamily,
            borderRadius,
            shadowType,
            animationType,
            glassEffect,
            backgroundType,
            backgroundValue,
            customCss,
            productViewType,
            pagesOrder,
            layoutSettings,
            colorPalette,
            appliedTemplate,
            theme,
            customBackgrounds,
            currentBackground
        } = req.body;
        
        const getCurrencySymbol = (curr) => {
            const symbols = {
                'USD': '$', 'EUR': '€', 'GBP': '£', 'EGP': 'ج.م',
                'SAR': '﷼', 'AED': 'د.إ', 'CAD': 'C$', 'AUD': 'A$',
                'JPY': '¥', 'CNY': '¥', 'INR': '₹', 'BRL': 'R$'
            };
            return symbols[curr] || '$';
        };
        
        const updateData = {
            storeName: storeName || '',
            storeLogo: storeLogo || '',
            storeBanner: storeBanner || '',
            storeDescription: storeDescription || '',
            currency: currency || 'USD',
            currencySymbol: getCurrencySymbol(currency || 'USD'),
            paymentMethods: paymentMethods || [],
            pageBuilder: pageBuilder || { sections: [] },
            productViewType: productViewType || 'modal',
            socialLinks: socialLinks || {},
            primaryColor: primaryColor || '#3b82f6',
            secondaryColor: secondaryColor || '#8b5cf6',
            fontFamily: fontFamily || 'Inter, sans-serif',
            borderRadius: borderRadius || 16,
            shadowType: shadowType || 'md',
            animationType: animationType || 'lift',
            glassEffect: glassEffect || false,
            backgroundType: backgroundType || 'default',
            backgroundValue: backgroundValue || '',
            customCss: customCss || '',
            pagesOrder: pagesOrder || {
                products: 1,
                about: 2,
                contact: 3
            },
            // ✅ إعدادات التخطيط المتقدمة
            layoutSettings: layoutSettings || {
                headerLayout: 'default',
                footerLayout: 'default',
                productsPerRowDesktop: 4,
                enableQuickView: true,
                enableProductReviews: true
            },
            // ✅ ألوان إضافية
            colorPalette: colorPalette || {
                primaryHover: '#2563eb',
                secondaryHover: '#7c3aed',
                headingColor: '#1f2937'
            },
            updatedAt: Date.now()
        };

        if (customBackgrounds !== undefined) {
            updateData.customBackgrounds = customBackgrounds;
        }
        if (currentBackground !== undefined) {
            updateData.currentBackground = currentBackground;
        }

        
        // ✅ حفظ مسار القالب المطبق إذا وجد
        if (appliedTemplate) {
            updateData.appliedTemplate = appliedTemplate;
        }
        
        const settings = await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            updateData,
            { upsert: true, new: true }
        );
        
        // ✅ حفظ إعدادات القالب إذا وجدت
        if (theme) {
            await StoreTheme.findOneAndUpdate(
                { userId: req.user.userId },
                {
                    colors: theme.colors || {
                        primary: primaryColor || '#3b82f6',
                        secondary: secondaryColor || '#8b5cf6'
                    },
                    typography: theme.typography || {
                        fontFamily: fontFamily || 'Inter, sans-serif'
                    },
                    customTemplates: theme.customTemplates || {},
                    settings: theme.settings || {},
                    layout: theme.layout || 'full-width',
                    uploadedTheme: theme.uploadedTheme || null,
                    updatedAt: Date.now()
                },
                { upsert: true }
            );
        } else if (primaryColor || secondaryColor || fontFamily) {
            // تحديث الألوان والخطوط في القالب
            await StoreTheme.findOneAndUpdate(
                { userId: req.user.userId },
                {
                    colors: {
                        primary: primaryColor || '#3b82f6',
                        secondary: secondaryColor || '#8b5cf6'
                    },
                    typography: {
                        fontFamily: fontFamily || 'Inter, sans-serif'
                    },
                    updatedAt: Date.now()
                },
                { upsert: true }
            );
        }
        
        await User.findByIdAndUpdate(req.user.userId, {
            'profile.storeEnabled': true
        });
        
        console.log('✅ Store settings saved for user:', req.user.userId);
        
        res.json({ 
            success: true, 
            settings,
            message: 'Store settings saved successfully'
        });
        
    } catch (error) {
        console.error('Error saving store settings:', error);
        res.status(500).json({ error: 'Failed to save store settings: ' + error.message });
    }
});


// ============================================
// 🎨 COMPLETE LAYOUT & DESIGN API - VERSION 2.0 (FIXED)
// ============================================

// ============================================
// GET /api/store/layout-templates - جلب قوالب التخطيط مع تفاصيل كاملة
// ============================================
app.get('/api/store/layout-templates', authenticateToken, async (req, res) => {
    try {
        const templates = [
            {
                id: 'default',
                name: 'Default Layout',
                description: 'Standard grid with 4 columns',
                previewImage: '/assets/layouts/default.svg',
                features: ['4 column grid', 'Full header', 'Standard footer', 'Products first'],
                structure: {
                    headerPosition: 'top',
                    sidebarPosition: 'none',
                    footerPosition: 'bottom',
                    productsPerRow: 4,
                    showCategories: true,
                    showHero: true
                },
                cssClasses: ['layout-default'],
                order: 1
            },
            {
                id: 'sidebar-left',
                name: 'Sidebar Left',
                description: 'Categories menu on the left side',
                previewImage: '/assets/layouts/sidebar-left.svg',
                features: ['Left sidebar', '3 column grid', 'Categories visible', 'Compact design'],
                structure: {
                    headerPosition: 'top',
                    sidebarPosition: 'left',
                    footerPosition: 'bottom',
                    productsPerRow: 3,
                    showCategories: true,
                    showHero: true
                },
                cssClasses: ['layout-sidebar-left', 'flex-row-reverse'],
                order: 2
            },
            {
                id: 'sidebar-right',
                name: 'Sidebar Right',
                description: 'Categories menu on the right side',
                previewImage: '/assets/layouts/sidebar-right.svg',
                features: ['Right sidebar', '3 column grid', 'Categories visible', 'Modern layout'],
                structure: {
                    headerPosition: 'top',
                    sidebarPosition: 'right',
                    footerPosition: 'bottom',
                    productsPerRow: 3,
                    showCategories: true,
                    showHero: true
                },
                cssClasses: ['layout-sidebar-right'],
                order: 3
            },
            {
                id: 'product-focused',
                name: 'Product Focused',
                description: 'Large product cards in list view',
                previewImage: '/assets/layouts/product-focused.svg',
                features: ['List view layout', 'Large product images', 'Detailed descriptions', '2 column grid'],
                structure: {
                    headerPosition: 'top',
                    sidebarPosition: 'none',
                    footerPosition: 'bottom',
                    productsPerRow: 2,
                    productViewType: 'list',
                    showCategories: false,
                    showHero: true
                },
                cssClasses: ['layout-product-focused', 'list-view'],
                order: 4
            },
            {
                id: 'minimal',
                name: 'Minimal Store',
                description: 'Clean and simple design',
                previewImage: '/assets/layouts/minimal.svg',
                features: ['2 column grid', 'Simple header', 'Minimal footer', 'Fast loading'],
                structure: {
                    headerPosition: 'top',
                    headerStyle: 'minimal',
                    sidebarPosition: 'none',
                    footerStyle: 'minimal',
                    productsPerRow: 2,
                    showCategories: false,
                    showHero: false,
                    showStats: false,
                    showAnalytics: false
                },
                cssClasses: ['layout-minimal', 'hide-stats', 'hide-analytics', 'minimal-header'],
                order: 5
            },
            {
                id: 'magazine',
                name: 'Magazine Style',
                description: 'Editorial style with featured sections',
                previewImage: '/assets/layouts/magazine.svg',
                features: ['Hero section', 'Featured content', 'Blog style', '4 column grid'],
                structure: {
                    headerPosition: 'top',
                    sidebarPosition: 'none',
                    footerPosition: 'bottom',
                    productsPerRow: 4,
                    showCategories: true,
                    showHero: true,
                    heroStyle: 'large',
                    showFeatured: true
                },
                cssClasses: ['layout-magazine', 'hero-large'],
                order: 6
            },
            {
                id: 'compact',
                name: 'Compact Store',
                description: 'Dense grid for many products',
                previewImage: '/assets/layouts/compact.svg',
                features: ['6 column grid', 'Compact cards', 'Fast browsing', 'High density'],
                structure: {
                    headerPosition: 'top',
                    sidebarPosition: 'none',
                    footerPosition: 'bottom',
                    productsPerRow: 6,
                    cardStyle: 'compact',
                    showCategories: false,
                    showHero: false
                },
                cssClasses: ['layout-compact', 'compact-cards'],
                order: 7
            },
            {
                id: 'dark-store',
                name: 'Dark Store',
                description: 'Dark theme optimized for night browsing',
                previewImage: '/assets/layouts/dark-store.svg',
                features: ['Dark theme', 'Neon accents', 'Modern design', 'Eye friendly'],
                structure: {
                    headerPosition: 'top',
                    sidebarPosition: 'none',
                    footerPosition: 'bottom',
                    productsPerRow: 4,
                    theme: 'dark',
                    glassEffect: true
                },
                cssClasses: ['layout-dark-store', 'dark-theme'],
                order: 8
            }
        ];
        
        const settings = await StoreSettings.findOne({ userId: req.user.userId });
        const currentLayout = settings?.layoutSettings?.layoutTemplate || 'default';
        
        const designSettings = {
            primaryColor: settings?.primaryColor || '#3b82f6',
            secondaryColor: settings?.secondaryColor || '#8b5cf6',
            fontFamily: settings?.fontFamily || 'Inter, sans-serif',
            borderRadius: settings?.borderRadius || 16,
            shadowType: settings?.shadowType || 'md',
            animationType: settings?.animationType || 'lift',
            glassEffect: settings?.glassEffect || false,
            backgroundType: settings?.backgroundType || 'default',
            backgroundValue: settings?.backgroundValue || '',
            customCss: settings?.customCss || ''
        };
        
        res.json({
            success: true,
            templates: templates,
            currentLayout: currentLayout,
            designSettings: designSettings,
            layoutSettings: settings?.layoutSettings || {}
        });
        
    } catch (error) {
        console.error('Error fetching layout templates:', error);
        res.status(500).json({ error: 'Failed to fetch layout templates' });
    }
});

// ============================================
// PUT /api/store/layout-template - حفظ قالب التخطيط مع كامل الإعدادات (مصحح)
// ============================================
app.put('/api/store/layout-template', authenticateToken, async (req, res) => {
    try {
        const { 
            layoutTemplate,
            // إعدادات إضافية ممكن يبعتهم الفرونت
            headerLayout,
            footerLayout,
            sidebarPosition,
            productsPerRowDesktop,
            enableStickyAddToCart,
            enableQuickView,
            enableCompareProducts,
            enableWishlist,
            enableRecentlyViewed,
            enableProductReviews
        } = req.body;
        
        const validLayouts = ['default', 'sidebar-left', 'sidebar-right', 'product-focused', 'minimal', 'magazine', 'compact', 'dark-store'];
        
        if (!validLayouts.includes(layoutTemplate)) {
            return res.status(400).json({ error: 'Invalid layout template' });
        }
        
        // الحصول على هيكل القالب المحدد
        const templateStructure = getLayoutStructure(layoutTemplate);
        
        // بناء كائن التحديث
        const updateData = {
            'layoutSettings.layoutTemplate': layoutTemplate,
            'layoutSettings.sidebarPosition': sidebarPosition || templateStructure.sidebarPosition || 'none',
            'layoutSettings.productsPerRowDesktop': productsPerRowDesktop || templateStructure.productsPerRow || 4,
            'layoutSettings.headerLayout': headerLayout || templateStructure.headerStyle || templateStructure.headerPosition || 'default',
            'layoutSettings.footerLayout': footerLayout || templateStructure.footerStyle || 'default',
            updatedAt: Date.now()
        };
        
        // إضافة إعدادات التبديلات (toggles) إذا وجدت
        if (enableStickyAddToCart !== undefined) {
            updateData['layoutSettings.enableStickyAddToCart'] = enableStickyAddToCart;
        }
        if (enableQuickView !== undefined) {
            updateData['layoutSettings.enableQuickView'] = enableQuickView;
        }
        if (enableCompareProducts !== undefined) {
            updateData['layoutSettings.enableCompareProducts'] = enableCompareProducts;
        }
        if (enableWishlist !== undefined) {
            updateData['layoutSettings.enableWishlist'] = enableWishlist;
        }
        if (enableRecentlyViewed !== undefined) {
            updateData['layoutSettings.enableRecentlyViewed'] = enableRecentlyViewed;
        }
        if (enableProductReviews !== undefined) {
            updateData['layoutSettings.enableProductReviews'] = enableProductReviews;
        }
        
        // ✅ تطبيق إعدادات خاصة بكل قالب
        switch(layoutTemplate) {
            case 'minimal':
                updateData['layoutSettings.enableStickyAddToCart'] = false;
                updateData['layoutSettings.enableQuickView'] = false;
                updateData['layoutSettings.enableProductReviews'] = false;
                updateData['layoutSettings.headerLayout'] = 'minimal';
                updateData['layoutSettings.footerLayout'] = 'minimal';
                break;
                
            case 'product-focused':
                updateData.productViewType = 'list';
                updateData['layoutSettings.enableQuickView'] = true;
                updateData['layoutSettings.enableProductReviews'] = true;
                updateData['layoutSettings.sidebarPosition'] = 'none';
                break;
                
            case 'magazine':
                updateData['layoutSettings.enableQuickView'] = true;
                updateData['layoutSettings.enableStickyAddToCart'] = true;
                updateData['layoutSettings.enableRecentlyViewed'] = true;
                updateData['layoutSettings.headerLayout'] = 'centered';
                break;
                
            case 'compact':
                updateData['layoutSettings.productsPerRowDesktop'] = 6;
                updateData['layoutSettings.productsPerRowTablet'] = 3;
                updateData['layoutSettings.productsPerRowMobile'] = 2;
                updateData['layoutSettings.enableQuickView'] = false;
                updateData['layoutSettings.cardStyle'] = 'compact';
                break;
                
            case 'dark-store':
                updateData.primaryColor = '#8b5cf6';
                updateData.secondaryColor = '#a78bfa';
                updateData.glassEffect = true;
                updateData.backgroundType = 'color';  // ✅ مصحح
                updateData.backgroundValue = '#0f0f0f';  // ✅ مصحح
                updateData['layoutSettings.glassEffect'] = true;
                break;
        }
        
        const settings = await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { $set: updateData },
            { upsert: true, new: true }
        );
        
        console.log(`✅ Layout template saved: ${layoutTemplate} for user ${req.user.userId}`);
        
        res.json({ 
            success: true, 
            layoutTemplate: layoutTemplate,
            appliedSettings: updateData,
            message: 'Layout template saved successfully'
        });
        
    } catch (error) {
        console.error('Error saving layout template:', error);
        res.status(500).json({ error: 'Failed to save layout template: ' + error.message });
    }
});

// ============================================
// دالة مساعدة لجلب هيكل القالب (محدثة)
// ============================================
function getLayoutStructure(layoutId) {
    const structures = {
        'default': { sidebarPosition: 'none', productsPerRow: 4, headerPosition: 'top' },
        'sidebar-left': { sidebarPosition: 'left', productsPerRow: 3, headerPosition: 'top' },
        'sidebar-right': { sidebarPosition: 'right', productsPerRow: 3, headerPosition: 'top' },
        'product-focused': { sidebarPosition: 'none', productsPerRow: 2, headerPosition: 'top', productViewType: 'list' },
        'minimal': { sidebarPosition: 'none', productsPerRow: 2, headerStyle: 'minimal', footerStyle: 'minimal' },
        'magazine': { sidebarPosition: 'none', productsPerRow: 4, headerPosition: 'top', heroStyle: 'large' },
        'compact': { sidebarPosition: 'none', productsPerRow: 6, headerPosition: 'top', cardStyle: 'compact' },
        'dark-store': { sidebarPosition: 'none', productsPerRow: 4, theme: 'dark', glassEffect: true }
    };
    return structures[layoutId] || structures['default'];
}

// ============================================
// POST /api/store/layout-template/reset - إعادة تعيين قالب التخطيط (محدث)
// ============================================
app.post('/api/store/layout-template/reset', authenticateToken, async (req, res) => {
    try {
        const defaultSettings = {
            'layoutSettings.layoutTemplate': 'default',
            'layoutSettings.sidebarPosition': 'none',
            'layoutSettings.productsPerRowDesktop': 4,
            'layoutSettings.productsPerRowTablet': 3,
            'layoutSettings.productsPerRowMobile': 2,
            'layoutSettings.headerLayout': 'default',
            'layoutSettings.footerLayout': 'default',
            'layoutSettings.enableStickyAddToCart': true,
            'layoutSettings.enableQuickView': true,
            'layoutSettings.enableCompareProducts': false,
            'layoutSettings.enableWishlist': false,
            'layoutSettings.enableRecentlyViewed': true,
            'layoutSettings.enableProductReviews': true,
            productViewType: 'modal',
            primaryColor: '#3b82f6',
            secondaryColor: '#8b5cf6',
            fontFamily: 'Inter, sans-serif',
            borderRadius: 16,
            shadowType: 'md',
            animationType: 'lift',
            glassEffect: false,
            backgroundType: 'default',
            backgroundValue: '',
            updatedAt: Date.now()
        };
        
        const settings = await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { $set: defaultSettings },
            { upsert: true, new: true }
        );
        
        console.log(`✅ Layout template reset to default for user ${req.user.userId}`);
        
        res.json({ 
            success: true, 
            layoutTemplate: 'default',
            defaultSettings: defaultSettings,
            message: 'Layout template reset to default'
        });
        
    } catch (error) {
        console.error('Error resetting layout template:', error);
        res.status(500).json({ error: 'Failed to reset layout template' });
    }
});

// ============================================
// GET /api/store/apply-layout/:userId - تطبيق القالب على متجر معين (للزوار)
// ============================================
app.get('/api/store/apply-layout/:userId', async (req, res) => {
    try {
        const settings = await StoreSettings.findOne({ userId: req.params.userId });
        
        if (!settings) {
            return res.json({ layout: 'default', design: {} });
        }
        
        const layoutTemplate = settings.layoutSettings?.layoutTemplate || 'default';
        const structure = getLayoutStructure(layoutTemplate);
        
        res.json({
            success: true,
            layout: layoutTemplate,
            structure: structure,
            design: {
                primaryColor: settings.primaryColor,
                secondaryColor: settings.secondaryColor,
                fontFamily: settings.fontFamily,
                borderRadius: settings.borderRadius,
                shadowType: settings.shadowType,
                animationType: settings.animationType,
                glassEffect: settings.glassEffect,
                backgroundType: settings.backgroundType,
                backgroundValue: settings.backgroundValue,
                customCss: settings.customCss
            },
            layoutSettings: settings.layoutSettings
        });
        
    } catch (error) {
        console.error('Error applying layout:', error);
        res.status(500).json({ error: 'Failed to apply layout' });
    }
});
// ============================================
// POST /api/store/contact - إرسال رسالة لصاحب المتجر (محدث)
// ============================================
app.post('/api/store/contact', async (req, res) => {
    try {
        const { sellerId, name, email, message } = req.body;
        
        // ✅ التحقق من صحة البيانات
        if (!sellerId) {
            return res.status(400).json({ error: 'Store ID is required' });
        }
        if (!name || name.trim().length === 0) {
            return res.status(400).json({ error: 'Name is required' });
        }
        if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
            return res.status(400).json({ error: 'Valid email is required' });
        }
        if (!message || message.trim().length === 0) {
            return res.status(400).json({ error: 'Message is required' });
        }
        
        // ✅ منع الرسائل القصيرة جداً أو الطويلة جداً
        if (message.length < 10) {
            return res.status(400).json({ error: 'Message must be at least 10 characters' });
        }
        if (message.length > 5000) {
            return res.status(400).json({ error: 'Message cannot exceed 5000 characters' });
        }
        
        // ✅ جلب بيانات البائع (صاحب المتجر)
        const seller = await User.findById(sellerId);
        if (!seller) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        // ✅ جلب إعدادات المتجر
        const storeSettings = await StoreSettings.findOne({ userId: sellerId });
        if (!storeSettings || !storeSettings.enabled) {
            return res.status(403).json({ error: 'Store is not active' });
        }
        
        // ✅ استخدام contactEmail من الإعدادات إذا وجد
        const storeContactEmail = storeSettings.contactEmail || seller.email;
        
        // ✅ منع الإرسال المتكرر (نفس الـ IP خلال 5 دقائق)
        const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
        const recentMessage = await Notification.findOne({
            type: 'contact_message',
            'metadata.ip': ip,
            createdAt: { $gte: new Date(Date.now() - 5 * 60 * 1000) }
        });
        
        if (recentMessage) {
            return res.status(429).json({ error: 'Please wait 5 minutes before sending another message' });
        }
        
        // ✅ تنظيف النصوص من HTML
        const cleanName = escapeHtml(name.trim());
        const cleanEmail = escapeHtml(email.trim());
        const cleanMessage = escapeHtml(message.trim());
        
        // ============================================
        // 📧 1. إنشاء إشعار في قاعدة البيانات للبائع
        // ============================================
        const notification = new Notification({
            userId: sellerId,
            type: 'contact_message',
            actorId: null,
            actorName: cleanName,
            actorAvatar: null,
            content: `📬 New contact message from ${cleanName}: "${cleanMessage.substring(0, 80)}${cleanMessage.length > 80 ? '...' : ''}"`,
            targetId: `/shop/${seller.profile?.nickname || seller.username}`,
            targetType: 'store',
            read: false,
            metadata: {
                email: cleanEmail,
                message: cleanMessage,
                name: cleanName,
                ip: ip,
                userAgent: req.headers['user-agent']
            }
        });
        await notification.save();
        
        // ============================================
        // 📧 2. إرسال إيميل للبائع (إلى contactEmail المخصص أو الإيميل الأساسي)
        // ============================================
        const emailHtml = `
            <!DOCTYPE html>
            <html dir="ltr">
            <head>
                <meta charset="UTF-8">
                <style>
                    body { font-family: 'Segoe UI', Arial, sans-serif; line-height: 1.6; color: #333; }
                    .container { max-width: 600px; margin: 0 auto; padding: 20px; }
                    .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; text-align: center; border-radius: 10px 10px 0 0; }
                    .content { background: #f9fafb; padding: 30px; border-radius: 0 0 10px 10px; }
                    .message-box { background: white; padding: 20px; border-radius: 10px; margin: 20px 0; border-left: 4px solid #667eea; }
                    .button { display: inline-block; background: #667eea; color: white; padding: 12px 24px; text-decoration: none; border-radius: 8px; margin-top: 20px; }
                    .footer { text-align: center; padding: 20px; font-size: 12px; color: #6b7280; }
                </style>
            </head>
            <body>
                <div class="container">
                    <div class="header">
                        <h1>📬 New Contact Message</h1>
                        <p>From ${cleanName}</p>
                    </div>
                    <div class="content">
                        <h2>Hello ${escapeHtml(seller.profile?.nickname || seller.username)}!</h2>
                        <p>You have received a new message from a visitor to your store.</p>
                        
                        <div class="message-box">
                            <p><strong>👤 Name:</strong> ${cleanName}</p>
                            <p><strong>📧 Email:</strong> <a href="mailto:${cleanEmail}">${cleanEmail}</a></p>
                            <p><strong>💬 Message:</strong></p>
                            <p style="background: #f3f4f6; padding: 12px; border-radius: 8px; margin-top: 8px;">${cleanMessage.replace(/\n/g, '<br>')}</p>
                        </div>
                        
                        <div style="margin-top: 20px;">
                            <a href="${FRONTEND_URL}/messages" class="button">📩 Reply via MGZon</a>
                            <a href="mailto:${cleanEmail}" class="button" style="background: #10b981;">📧 Reply via Email</a>
                        </div>
                        
                        <p style="margin-top: 20px; font-size: 14px; color: #6b7280;">
                            You can also view this message in your notifications panel.
                        </p>
                    </div>
                    <div class="footer">
                        <p>© ${new Date().getFullYear()} MGZon. All rights reserved.</p>
                        <p>This message was sent from your store page.</p>
                    </div>
                </div>
            </body>
            </html>
        `;
        
        // إرسال الإيميل (إذا كان البائع مفعّل الإشعارات البريدية)
        const userSettings = await User.findById(sellerId).select('profile.notifications');
        if (userSettings?.profile?.notifications?.email !== false) {
            await sendStoreEmailWithBrevo(
                storeContactEmail, // ✅ استخدم contactEmail بدل الإيميل الأساسي
                `📬 New Contact Message from ${cleanName}`,
                emailHtml,
                `You have a new message from ${cleanName}: ${cleanMessage.substring(0, 100)}`
            );
        }
        
        // ============================================
        // 📱 3. إرسال إشعار عبر Socket.IO (إذا كان متصلاً)
        // ============================================
        const io = req.app.get('io');
        if (io) {
            io.to(`user_${sellerId}`).emit('new_contact_message', {
                from: cleanName,
                email: cleanEmail,
                message: cleanMessage.substring(0, 100),
                timestamp: new Date()
            });
        }
        
        // ============================================
        // ✅ 4. إرسال رد للمستخدم
        // ============================================
        res.json({
            success: true,
            message: 'Your message has been sent successfully! The store owner will get back to you soon.'
        });
        
    } catch (error) {
        console.error('Error sending contact message:', error);
        res.status(500).json({ error: 'Failed to send message. Please try again later.' });
    }
});


// ============================================
// POST /api/analytics/track-store-view - تتبع مشاهدة المتجر (محدث)
// ============================================
app.post('/api/analytics/track-store-view', async (req, res) => {
    try {
        const { storeId } = req.body;
        
        // ✅ التحقق من صحة البيانات
        if (!storeId) {
            return res.status(400).json({ error: 'Store ID is required' });
        }
        
        if (!mongoose.Types.ObjectId.isValid(storeId)) {
            return res.status(400).json({ error: 'Invalid store ID' });
        }
        
        // ✅ جلب بيانات المتجر للتأكد من وجوده
        const store = await User.findById(storeId);
        if (!store) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        // ✅ الحصول على معلومات الزائر
        const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
        const userAgent = req.headers['user-agent'];
        const referer = req.headers['referer'] || '';
        
        // ✅ جلب userId إذا كان المستخدم مسجل الدخول
        let userId = null;
        let isLoggedIn = false;
        if (req.user && req.user.userId) {
            userId = req.user.userId;
            isLoggedIn = true;
        }
        
        // ✅ منع تسجيل المشاهدات المتكررة من نفس المستخدم/IP خلال ساعة
        const recentView = await ProfileAnalytics.findOne({
            userId: storeId,
            'profileViews.ip': ip,
            'profileViews.timestamp': { $gte: new Date(Date.now() - 60 * 60 * 1000) }
        });
        
        // إذا كان نفس المستخدم/IP شاهد المتجر خلال آخر ساعة، لا نسجل مرة أخرى
        if (recentView && !isLoggedIn) {
            return res.json({ success: true, cached: true });
        }
        
        const today = new Date().toISOString().split('T')[0];
        const currentMonth = new Date().toISOString().slice(0, 7);
        
        // ============================================
        // 📊 1. تحديث تحليلات المتجر
        // ============================================
        await ProfileAnalytics.findOneAndUpdate(
            { userId: storeId },
            {
                $push: {
                    profileViews: {
                        viewerId: userId,
                        viewerName: userId ? (currentUser?.username || null) : null,
                        ip: ip,
                        userAgent: userAgent,
                        referer: referer,
                        timestamp: new Date(),
                        isLoggedIn: isLoggedIn,
                        deviceType: getDeviceType(userAgent),
                        browser: getBrowserName(userAgent),
                        os: getOSName(userAgent)
                    }
                },
                $inc: {
                    totalViews: 1,
                    uniqueViews: isLoggedIn ? 0 : 1,
                    [`dailyStats.${today}.views`]: 1,
                    [`monthlyStats.${currentMonth}.views`]: 1
                },
                $set: {
                    lastViewAt: new Date(),
                    lastViewerId: userId,
                    lastViewerIp: ip
                }
            },
            { upsert: true }
        );
        
        // ============================================
        // 📊 2. تحديث إحصائيات المتجر في StoreSettings
        // ============================================
        await StoreSettings.findOneAndUpdate(
            { userId: storeId },
            {
                $inc: { totalViews: 1 },
                $set: { lastViewAt: new Date() }
            }
        );
        
        // ============================================
        // 📊 3. تتبع مصادر الزوار (Referral Sources)
        // ============================================
        if (referer && referer !== '') {
            let source = 'direct';
            if (referer.includes('google')) source = 'google';
            else if (referer.includes('facebook')) source = 'facebook';
            else if (referer.includes('twitter')) source = 'twitter';
            else if (referer.includes('linkedin')) source = 'linkedin';
            else if (referer.includes('instagram')) source = 'instagram';
            else if (referer.includes('github')) source = 'github';
            else if (referer.includes('mgzon')) source = 'mgzon';
            else if (referer.includes('search')) source = 'search';
            else source = 'other';
            
            await ProfileAnalytics.findOneAndUpdate(
                { userId: storeId },
                { $inc: { [`referralSources.${source}`]: 1 } }
            );
        }
        
        // ============================================
        // ✅ 4. إرسال الرد
        // ============================================
        res.json({
            success: true,
            data: {
                timestamp: new Date(),
                message: 'View tracked successfully'
            }
        });
        
    } catch (error) {
        console.error('Error tracking store view:', error);
        // لا نعيد error للمستخدم عشان لا يؤثر على تجربته
        res.json({ success: true, cached: true });
    }
});
// ============================================
// دوال مساعدة لتحليل User-Agent
// ============================================

function getDeviceType(userAgent) {
    if (!userAgent) return 'unknown';
    const ua = userAgent.toLowerCase();
    if (/(mobile|android|iphone|ipad|ipod|blackberry|windows phone)/i.test(ua)) {
        if (/(tablet|ipad)/i.test(ua)) return 'tablet';
        return 'mobile';
    }
    return 'desktop';
}

function getBrowserName(userAgent) {
    if (!userAgent) return 'unknown';
    const ua = userAgent.toLowerCase();
    if (ua.includes('chrome')) return 'Chrome';
    if (ua.includes('firefox')) return 'Firefox';
    if (ua.includes('safari') && !ua.includes('chrome')) return 'Safari';
    if (ua.includes('edge')) return 'Edge';
    if (ua.includes('opera')) return 'Opera';
    if (ua.includes('ie')) return 'Internet Explorer';
    return 'other';
}

function getOSName(userAgent) {
    if (!userAgent) return 'unknown';
    const ua = userAgent.toLowerCase();
    if (ua.includes('windows')) return 'Windows';
    if (ua.includes('mac')) return 'macOS';
    if (ua.includes('linux')) return 'Linux';
    if (ua.includes('android')) return 'Android';
    if (ua.includes('ios') || ua.includes('iphone') || ua.includes('ipad')) return 'iOS';
    return 'other';
}


// PUT /api/store/sections/order - حفظ ترتيب الأقسام
app.put('/api/store/sections/order', authenticateToken, async (req, res) => {
    try {
        const { sections } = req.body;
        
        if (!sections || !Array.isArray(sections)) {
            return res.status(400).json({ error: 'Invalid sections data' });
        }
        
        // جلب الإعدادات الحالية
        const storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        if (!storeSettings) {
            return res.status(404).json({ error: 'Store settings not found' });
        }
        
        // تحديث ترتيب الأقسام
        const currentSections = storeSettings.pageBuilder?.sections || [];
        
        // إنشاء map للترتيب الجديد
        const orderMap = new Map();
        sections.forEach(s => {
            orderMap.set(s.id, s.order);
        });
        
        console.log('SECTIONS FROM CLIENT:', sections);
        console.log('CURRENT SECTIONS:', currentSections);
        // تحديث الأقسام بالترتيب الجديد
        const updatedSections = currentSections.map(section => {
            // ✅ التحقق من وجود toObject (إذا كان Document)
            const sectionObj = (section && typeof section.toObject === 'function') 
                ? section.toObject() 
                : section;
            
            return {
                ...sectionObj,
                order: orderMap.get(section.id) || section.order || 0
            };
        });
        
        // حفظ التغييرات
        storeSettings.pageBuilder.sections = updatedSections;
        storeSettings.updatedAt = Date.now();
        await storeSettings.save();
        
        res.json({ success: true, sections: updatedSections });
        
    } catch (error) {
        console.error('Error saving sections order:', error);
        res.status(500).json({ error: 'Failed to save sections order' });
    }
});
// ============================================
// POST /api/store/enable - تفعيل/تعطيل المتجر (مع التحقق من الاشتراك)
// ============================================
app.post('/api/store/enable', authenticateToken, async (req, res) => {
    try {
        const { enabled } = req.body;
        const isEnabled = enabled === true || enabled === 'true';
        
        // ✅ إذا كان المستخدم يحاول تفعيل المتجر (enabled = true)
        if (isEnabled) {
            
            // ============================================
            // 1. التحقق من وجود اشتراك نشط
            // ============================================
            const activeSubscription = await UserSubscription.findOne({
                userId: req.user.userId,
                status: 'active'
            }).populate('planId');
            
            if (!activeSubscription) {
                return res.status(403).json({ 
                    success: false,
                    error: 'You need an active subscription to create a store. Please subscribe first.',
                    redirect: '/subscription.html',
                    code: 'NO_SUBSCRIPTION'
                });
            }
            
            // ============================================
            // 2. التحقق من أن الخطة تدعم إنشاء متجر
            // ============================================
            const plan = activeSubscription.planId;
            if (!plan || !plan.features || !plan.features.storeEnabled) {
                // جلب الخطة الحالية للمستخدم
                const currentPlan = await SubscriptionPlan.findById(activeSubscription.planId);
                const planName = currentPlan?.name || 'your current plan';
                
                // البحث عن خطة تدعم المتجر
                const storePlans = await SubscriptionPlan.find({
                    'features.storeEnabled': true,
                    isActive: true
                }).sort({ price: 1 }).limit(3);
                
                const upgradeOptions = storePlans.map(p => ({
                    name: p.name,
                    price: p.price,
                    currency: p.currencySymbol || '$'
                }));
                
                return res.status(403).json({ 
                    success: false,
                    error: `Your current plan "${planName}" does not include store functionality. Please upgrade your plan to start selling.`,
                    redirect: '/subscription.html',
                    code: 'STORE_NOT_IN_PLAN',
                    currentPlan: {
                        name: planName,
                        features: plan.features
                    },
                    upgradeOptions: upgradeOptions
                });
            }
            
            // ============================================
            // 3. التحقق من حدود المنتجات (إذا كانت الخطة لها حدود)
            // ============================================
            const existingProductsCount = await Product.countDocuments({ 
                userId: req.user.userId, 
                isActive: true 
            });
            
            const maxProducts = plan.features.maxProducts || 0;
            if (maxProducts > 0 && existingProductsCount >= maxProducts) {
                return res.status(403).json({ 
                    success: false,
                    error: `Your plan allows up to ${maxProducts} products. You currently have ${existingProductsCount} products. Please upgrade your plan to add more products.`,
                    redirect: '/subscription.html',
                    code: 'PRODUCT_LIMIT_REACHED',
                    currentLimit: maxProducts,
                    currentCount: existingProductsCount
                });
            }
            
            // ============================================
            // 4. التحقق من صلاحية الاشتراك (لم تنتهي صلاحيته)
            // ============================================
            const now = new Date();
            if (activeSubscription.endDate && new Date(activeSubscription.endDate) < now) {
                // الاشتراك منتهي الصلاحية
                activeSubscription.status = 'expired';
                await activeSubscription.save();
                
                return res.status(403).json({ 
                    success: false,
                    error: 'Your subscription has expired. Please renew to continue using store features.',
                    redirect: '/subscription.html',
                    code: 'SUBSCRIPTION_EXPIRED'
                });
            }
            
            // ============================================
            // 5. التحقق من التجربة المجانية (إذا كانت منتهية)
            // ============================================
            if (activeSubscription.isTrial && activeSubscription.trialEndDate) {
                if (new Date(activeSubscription.trialEndDate) < now) {
                    // انتهت التجربة المجانية
                    return res.status(403).json({ 
                        success: false,
                        error: 'Your free trial has ended. Please subscribe to continue using store features.',
                        redirect: '/subscription.html',
                        code: 'TRIAL_EXPIRED'
                    });
                }
                
                // عرض عدد الأيام المتبقية في التجربة
                const daysLeft = Math.ceil((new Date(activeSubscription.trialEndDate) - now) / (1000 * 60 * 60 * 24));
                res.setHeader('X-Trial-Days-Left', daysLeft);
            }
        }
        
        // ============================================
        // 6. تفعيل أو تعطيل المتجر
        // ============================================
        await User.findByIdAndUpdate(req.user.userId, {
            'profile.storeEnabled': isEnabled
        });
        
        if (isEnabled) {
            // ✅ تحديث أو إنشاء الإعدادات مع الحفاظ على القيم الموجودة
            const existingSettings = await StoreSettings.findOne({ userId: req.user.userId });
            
            if (!existingSettings) {
                // إنشاء إعدادات جديدة بالكامل
                await StoreSettings.create({
                    userId: req.user.userId,
                    enabled: true,
                    currency: 'USD',
                    currencySymbol: '$',
                    paymentMethods: [],
                    primaryColor: '#3b82f6',
                    secondaryColor: '#8b5cf6',
                    fontFamily: 'Inter, sans-serif',
                    borderRadius: 16,
                    shadowType: 'md',
                    animationType: 'lift',
                    glassEffect: false,
                    backgroundType: 'default',
                    backgroundValue: '',
                    customCss: '',
                    pageBuilder: {
                        sections: [
                            { id: 'hero', type: 'hero', enabled: true, order: 1, content: { title: 'Welcome to my store', subtitle: '', buttonText: 'Shop Now', buttonLink: '#products' } },
                            { id: 'products', type: 'products', enabled: true, order: 2, title: 'All Products', layout: 'grid' }
                        ]
                    }
                });
            } else {
                // تحديث فقط حقل enabled
                await StoreSettings.findOneAndUpdate(
                    { userId: req.user.userId },
                    { enabled: true, updatedAt: Date.now() }
                );
            }
        } else {
            await StoreSettings.findOneAndUpdate(
                { userId: req.user.userId },
                { enabled: false, updatedAt: Date.now() }
            );
        }
        
        // ============================================
        // 7. تسجيل النشاط في التحليلات
        // ============================================
        try {
            await ProfileAnalytics.findOneAndUpdate(
                { userId: req.user.userId },
                { 
                    $push: { 
                        activities: {
                            type: 'store_toggle',
                            action: isEnabled ? 'enabled' : 'disabled',
                            timestamp: new Date()
                        }
                    },
                    $inc: { storeToggles: 1 }
                },
                { upsert: true }
            );
        } catch (analyticsError) {
            console.error('Analytics error:', analyticsError);
            // لا نوقف التنفيذ
        }
        
        // ============================================
        // 8. إرسال الرد مع معلومات الاشتراك
        // ============================================
        const responseData = { 
            success: true, 
            enabled: isEnabled
        };
        
        // إضافة معلومات الاشتراك في الرد إذا كان المتجر مفعلاً
        if (isEnabled) {
            const subscription = await UserSubscription.findOne({
                userId: req.user.userId,
                status: 'active'
            }).populate('planId');
            
            if (subscription) {
                responseData.subscription = {
                    planName: subscription.planId?.name,
                    planFeatures: subscription.planId?.features,
                    endDate: subscription.endDate,
                    isTrial: subscription.isTrial,
                    trialEndDate: subscription.trialEndDate
                };
            }
        }
        
        res.json(responseData);
        
    } catch (error) {
        console.error('Error toggling store:', error);
        res.status(500).json({ 
            success: false,
            error: 'Failed to toggle store. Please try again later.',
            code: 'SERVER_ERROR'
        });
    }
});

// ========== 2. المنتجات ==========

// GET /api/store/products - جلب منتجات المتجر الحالي
app.get('/api/store/products', authenticateToken, async (req, res) => {
    try {
        const products = await Product.find({ userId: req.user.userId, isActive: true })
            .sort({ createdAt: -1 });
        res.json({ success: true, products });
    } catch (error) {
        console.error('Error fetching products:', error);
        res.status(500).json({ error: 'Failed to fetch products' });
    }
});


// POST /api/store/products - إضافة منتج جديد
app.post('/api/store/products', authenticateToken, upload.single('file'), async (req, res) => {
    try {
        const { type, title, description, price, currency, deliveryTime, tags, images } = req.body;
        
        // ============================================
        // ✅ أضف هذا الكود هنا - قبل إنشاء المنتج
        // ============================================
        
        // 1. التحقق من وجود اشتراك نشط
        const activeSubscription = await UserSubscription.findOne({
            userId: req.user.userId,
            status: 'active'
        }).populate('planId');
        
        if (!activeSubscription) {
            return res.status(403).json({ 
                success: false,
                error: 'You need an active subscription to add products. Please subscribe first.',
                redirect: '/subscription.html',
                code: 'NO_SUBSCRIPTION'
            });
        }
        
        // 2. التحقق من أن الخطة تدعم إنشاء منتجات
        const plan = activeSubscription.planId;
        if (!plan || !plan.features || !plan.features.storeEnabled) {
            return res.status(403).json({ 
                success: false,
                error: 'Your current plan does not allow adding products. Please upgrade your plan.',
                redirect: '/subscription.html',
                code: 'STORE_NOT_IN_PLAN'
            });
        }
        
        // 3. التحقق من حدود المنتجات حسب النوع
        const currentProductsCount = await Product.countDocuments({ 
            userId: req.user.userId, 
            isActive: true 
        });
        
        const maxProducts = plan.features.maxProducts || 0;
        if (maxProducts > 0 && currentProductsCount >= maxProducts) {
            return res.status(403).json({ 
                success: false,
                error: `Your plan allows up to ${maxProducts} products. You currently have ${currentProductsCount}. Please upgrade to add more products.`,
                redirect: '/subscription.html',
                code: 'PRODUCT_LIMIT_REACHED',
                currentLimit: maxProducts,
                currentCount: currentProductsCount
            });
        }
        
        // 4. التحقق من حدود المنتجات حسب النوع (Digital/Project/Service)
        if (type === 'digital') {
            const maxDigital = plan.features.maxDigitalProducts || 0;
            const currentDigital = await Product.countDocuments({ 
                userId: req.user.userId, 
                type: 'digital',
                isActive: true 
            });
            if (maxDigital > 0 && currentDigital >= maxDigital) {
                return res.status(403).json({ 
                    error: `Your plan allows up to ${maxDigital} digital products. Please upgrade to add more.`,
                    redirect: '/subscription.html'
                });
            }
        } else if (type === 'project') {
            const maxProjects = plan.features.maxProjects || 0;
            const currentProjects = await Product.countDocuments({ 
                userId: req.user.userId, 
                type: 'project',
                isActive: true 
            });
            if (maxProjects > 0 && currentProjects >= maxProjects) {
                return res.status(403).json({ 
                    error: `Your plan allows up to ${maxProjects} projects. Please upgrade to add more.`,
                    redirect: '/subscription.html'
                });
            }
        } else if (type === 'service') {
            const maxServices = plan.features.maxServices || 0;
            const currentServices = await Product.countDocuments({ 
                userId: req.user.userId, 
                type: 'service',
                isActive: true 
            });
            if (maxServices > 0 && currentServices >= maxServices) {
                return res.status(403).json({ 
                    error: `Your plan allows up to ${maxServices} services. Please upgrade to add more.`,
                    redirect: '/subscription.html'
                });
            }
        }
        
        // 5. التحقق من صلاحية الاشتراك (لم تنتهي)
        const now = new Date();
        if (activeSubscription.endDate && new Date(activeSubscription.endDate) < now) {
            activeSubscription.status = 'expired';
            await activeSubscription.save();
            return res.status(403).json({ 
                error: 'Your subscription has expired. Please renew to add products.',
                redirect: '/subscription.html',
                code: 'SUBSCRIPTION_EXPIRED'
            });
        }
        
        // ============================================
        // ✅ استمر في إنشاء المنتج (الكود الموجود)
        // ============================================
        
        let fileUrl = null;
        let fileSize = null;
        
        if (req.file && type === 'digital') {
            fileUrl = req.file.path;
            fileSize = req.file.size;
        }
        
        const product = new Product({
            userId: req.user.userId,
            type,
            title,
            description,
            price: parseFloat(price),
            currency: currency || 'USD',
            fileUrl,
            fileSize,
            deliveryTime: deliveryTime || null,
            tags: tags ? (Array.isArray(tags) ? tags : JSON.parse(tags)) : [],
            images: images ? (Array.isArray(images) ? images : JSON.parse(images)) : []
        });
        
        await product.save();

        await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { $inc: { productsCount: 1 }, updatedAt: Date.now() }
        );

        
        res.status(201).json({ success: true, product });
        
    } catch (error) {
        console.error('Error creating product:', error);
        res.status(500).json({ error: 'Failed to create product' });
    }
});


// ============================================
// GET /api/users/:userId/subscription-status - جلب حالة الاشتراك لمستخدم معين
// ============================================
app.get('/api/users/:userId/subscription-status', async (req, res) => {
    try {
        const userId = req.params.userId;
        
        // التحقق من صحة الـ ObjectId
        if (!mongoose.Types.ObjectId.isValid(userId)) {
            return res.status(400).json({ error: 'Invalid user ID' });
        }
        
        // جلب المستخدم
        const user = await User.findById(userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        // التحقق من وجود اشتراك نشط
        const subscription = await UserSubscription.findOne({
            userId: userId,
            status: 'active'
        }).populate('planId');
        
        if (!subscription) {
            return res.json({ 
                hasActiveSubscription: false,
                message: 'No active subscription'
            });
        }
        
        // التحقق من صلاحية الاشتراك (لم ينتهي)
        const now = new Date();
        if (subscription.endDate && new Date(subscription.endDate) < now) {
            subscription.status = 'expired';
            await subscription.save();
            return res.json({ 
                hasActiveSubscription: false,
                message: 'Subscription expired'
            });
        }
        
        const plan = subscription.planId;
        const daysLeft = subscription.endDate 
            ? Math.ceil((new Date(subscription.endDate) - now) / (1000 * 60 * 60 * 24))
            : 0;
        
        res.json({
            hasActiveSubscription: true,
            isTrial: subscription.isTrial || false,
            planId: plan?._id,
            planName: plan?.name || 'Pro',
            planFeatures: plan?.features || {},
            endDate: subscription.endDate,
            daysLeft: daysLeft > 0 ? daysLeft : 0
        });
        
    } catch (error) {
        console.error('Error fetching subscription status:', error);
        res.status(500).json({ error: 'Failed to fetch subscription status' });
    }
});

// ========== 3. الطلبات ==========
// ============================================
// 8. POST /api/checkout/:storeId - إنشاء طلب لمتجر واحد (نسخة كاملة)
// ============================================
app.post('/api/checkout/:storeId', authenticateToken, async (req, res) => {
    try {
        const { storeId } = req.params;
        const { buyerNotes, selectedPaymentMethod } = req.body;
        
        // ============================================
        // 1. جلب السلة والتحقق
        // ============================================
        const cart = await Cart.findOne({ userId: req.user.userId });
        if (!cart) {
            return res.status(400).json({ error: 'Cart is empty' });
        }
        
        const storeCart = cart.stores.get(storeId);
        if (!storeCart || storeCart.items.length === 0) {
            return res.status(400).json({ error: 'Store cart is empty' });
        }
        
        // ============================================
        // 2. جلب بيانات المتجر والمستخدمين
        // ============================================
        const storeSettings = await StoreSettings.findOne({ userId: storeId });
        if (!storeSettings || !storeSettings.enabled) {
            return res.status(403).json({ error: 'Store is not active' });
        }
        
        // جلب طريقة الدفع المختارة
        let paymentMethodData = null;
        if (selectedPaymentMethod) {
            paymentMethodData = storeSettings.paymentMethods.find(
                m => m.type === selectedPaymentMethod
            );
        } else if (storeSettings.paymentMethods && storeSettings.paymentMethods.length > 0) {
            paymentMethodData = storeSettings.paymentMethods[0];
        }
        
        if (!paymentMethodData) {
            return res.status(400).json({ error: 'No payment method selected or available' });
        }
        
        // جلب بيانات المشتري والبائع
        const buyer = await User.findById(req.user.userId);
        const seller = await User.findById(storeId);
        
        if (!buyer || !seller) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        // ============================================
        // 3. التحقق من توفر المنتجات
        // ============================================
        for (const item of storeCart.items) {
            const product = await Product.findById(item.productId);
            if (!product || !product.isActive) {
                return res.status(400).json({ 
                    error: `Product "${item.title}" is no longer available` 
                });
            }
        }
        
        // ============================================
        // 4. إنشاء الطلب
        // ============================================
        const order = new Order({
            orderNumber: `ORD-${Date.now()}-${Math.floor(Math.random() * 10000)}`,
            buyerId: req.user.userId,
            sellerId: storeId,
            items: storeCart.items.map(item => ({
                productId: item.productId,
                productType: item.productType,
                title: item.title,
                price: item.price,
                quantity: item.quantity
            })),
            subtotal: storeCart.subtotal,
            totalAmount: storeCart.subtotal,
            currency: storeSettings.currency || 'USD',
            status: 'pending',
            paymentMethod: paymentMethodData.type,
            paymentDetails: paymentMethodData.details || {},
            buyerNotes: buyerNotes || '',
            createdAt: new Date()
        });
        
        await order.save();
        
        // ============================================
        // 5. تحديث إحصائيات المنتجات (زيادة المبيعات)
        // ============================================
        for (const item of storeCart.items) {
            await Product.findByIdAndUpdate(item.productId, {
                $inc: { salesCount: item.quantity }
            });
        }
        
        // ============================================
        // 6. مسح سلة هذا المتجر فقط
        // ============================================
        cart.stores.delete(storeId);
        await cart.calculateTotals();
        
        cart.markModified('stores');

        await cart.save();
        
        // ============================================
        // 7. 📧 إرسال إيميل تأكيد للمشتري
        // ============================================
        const buyerEmailHtml = `
            <!DOCTYPE html>
            <html dir="ltr">
            <head>
                <meta charset="UTF-8">
                <meta name="viewport" content="width=device-width, initial-scale=1.0">
                <title>Order Confirmation</title>
                <style>
                    body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; line-height: 1.6; color: #333; margin: 0; padding: 0; background: #f4f4f4; }
                    .container { max-width: 600px; margin: 0 auto; padding: 20px; }
                    .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; text-align: center; border-radius: 10px 10px 0 0; }
                    .content { background: white; padding: 30px; border-radius: 0 0 10px 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
                    .order-details { background: #f9fafb; padding: 20px; border-radius: 10px; margin: 20px 0; border: 1px solid #e5e7eb; }
                    .product-item { padding: 10px 0; border-bottom: 1px solid #e5e7eb; display: flex; justify-content: space-between; }
                    .total { font-size: 18px; font-weight: bold; margin-top: 20px; padding-top: 20px; border-top: 2px solid #e5e7eb; }
                    .button { display: inline-block; background: #667eea; color: white; padding: 12px 24px; text-decoration: none; border-radius: 8px; margin-top: 20px; }
                    .footer { text-align: center; padding: 20px; font-size: 12px; color: #6b7280; }
                    .status-badge { display: inline-block; background: #f59e0b; color: white; padding: 4px 12px; border-radius: 20px; font-size: 12px; }
                </style>
            </head>
            <body>
                <div class="container">
                    <div class="header">
                        <h1>🛒 Order Confirmed!</h1>
                        <p>Order #${order.orderNumber}</p>
                    </div>
                    <div class="content">
                        <h2>Thank you for your order, ${buyer.profile?.nickname || buyer.username}! 🎉</h2>
                        <p>Your order has been received and is now being processed by <strong>${storeSettings.storeName || seller.profile?.nickname || seller.username}</strong>.</p>
                        
                        <div class="order-details">
                            <h3>📋 Order Details</h3>
                            <p><strong>Order Number:</strong> <span style="font-family: monospace;">${order.orderNumber}</span></p>
                            <p><strong>Date:</strong> ${new Date().toLocaleString()}</p>
                            <p><strong>Status:</strong> <span class="status-badge">Pending Payment</span></p>
                            <p><strong>Payment Method:</strong> ${paymentMethodData.type === 'vodafone' ? '📱 Vodafone Cash' : paymentMethodData.type === 'instapay' ? '🏦 InstaPay' : paymentMethodData.type === 'paypal' ? '💰 PayPal' : paymentMethodData.type === 'bank' ? '🏛️ Bank Transfer' : paymentMethodData.type}</p>
                            
                            <h3 style="margin-top: 20px;">🛍️ Items Ordered</h3>
                            ${storeCart.items.map(item => `
                                <div class="product-item">
                                    <span>${item.title} × ${item.quantity}</span>
                                    <span><strong>${storeSettings.currencySymbol || '$'}${(item.price * item.quantity).toFixed(2)}</strong></span>
                                </div>
                            `).join('')}
                            
                            <div class="product-item" style="font-weight: bold;">
                                <span>Subtotal</span>
                                <span>${storeSettings.currencySymbol || '$'}${storeCart.subtotal.toFixed(2)}</span>
                            </div>
                            <div class="total">
                                <span style="font-size: 20px;">Total Amount</span>
                                <span style="font-size: 28px; color: #667eea; font-weight: bold;">${storeSettings.currencySymbol || '$'}${storeCart.subtotal.toFixed(2)}</span>
                            </div>
                        </div>
                        
                        <div class="payment-info">
                            <h3>💰 Payment Instructions</h3>
                            ${paymentMethodData.type === 'vodafone' ? `
                                <div style="background: #e0f2fe; padding: 15px; border-radius: 10px;">
                                    <p style="margin: 0 0 10px 0;">📱 Send the amount to this <strong>Vodafone Cash</strong> number:</p>
                                    <p style="font-size: 28px; font-weight: bold; text-align: center; background: white; padding: 10px; border-radius: 8px; font-family: monospace;">
                                        ${paymentMethodData.details?.phone || 'Not provided'}
                                    </p>
                                    <p style="margin: 10px 0 0 0; font-size: 12px; color: #666;">After payment, the seller will confirm and you'll receive access to your purchase.</p>
                                </div>
                            ` : paymentMethodData.type === 'instapay' ? `
                                <div style="background: #d1fae5; padding: 15px; border-radius: 10px;">
                                    <p style="margin: 0 0 10px 0;">🏦 Send the amount to this <strong>InstaPay</strong> account:</p>
                                    <p style="font-size: 24px; font-weight: bold; text-align: center; background: white; padding: 10px; border-radius: 8px; font-family: monospace;">
                                        ${paymentMethodData.details?.phone || 'Not provided'}
                                    </p>
                                </div>
                            ` : paymentMethodData.type === 'paypal' ? `
                                <div style="background: #e0e7ff; padding: 15px; border-radius: 10px;">
                                    <p style="margin: 0 0 10px 0;">💰 Send payment to this <strong>PayPal</strong> email:</p>
                                    <p style="font-size: 18px; font-weight: bold; text-align: center; background: white; padding: 10px; border-radius: 8px;">
                                        ${paymentMethodData.details?.email || 'Not provided'}
                                    </p>
                                </div>
                            ` : paymentMethodData.type === 'bank' ? `
                                <div style="background: #fef3c7; padding: 15px; border-radius: 10px;">
                                    <p style="margin: 0 0 10px 0;">🏛️ Transfer the amount to this <strong>Bank Account</strong>:</p>
                                    <table style="width: 100%; background: white; padding: 10px; border-radius: 8px;">
                                        <tr><td><strong>Bank:</strong></td><td>${paymentMethodData.details?.bankName || 'N/A'}</td></tr>
                                        <tr><td><strong>Account Name:</strong></td><td>${paymentMethodData.details?.accountName || 'N/A'}</td></tr>
                                        <tr><td><strong>Account Number:</strong></td><td>${paymentMethodData.details?.accountNumber || 'N/A'}</td></tr>
                                        ${paymentMethodData.details?.iban ? `<tr><td><strong>IBAN:</strong></td><td>${paymentMethodData.details.iban}</td></tr>` : ''}
                                    </table>
                                </div>
                            ` : `
                                <div style="background: #e5e7eb; padding: 15px; border-radius: 10px;">
                                    <p>Please complete the payment using your selected method. The seller will be notified.</p>
                                </div>
                            `}
                        </div>
                        
                        <div style="text-align: center;">
                            <a href="${FRONTEND_URL || 'https://mark-elasfar.web.app'}/store/orders/${order._id}" class="button">📦 Track Your Order</a>
                        </div>
                        
                        <p style="margin-top: 20px; font-size: 14px; color: #6b7280; text-align: center;">
                            💡 <strong>What's next?</strong><br>
                            1. Complete the payment using the instructions above<br>
                            2. The seller will confirm your payment<br>
                            3. You'll receive download links or delivery confirmation<br>
                            4. You can track your order status anytime
                        </p>
                        
                        <p style="margin-top: 20px; font-size: 12px; color: #9ca3af; text-align: center;">
                            If you have any questions, please contact the seller directly.
                        </p>
                    </div>
                    <div class="footer">
                        <p>© ${new Date().getFullYear()} MGZon. All rights reserved.</p>
                        <p>This is an automated message, please do not reply.</p>
                    </div>
                </div>
            </body>
            </html>
        `;
        
        // إرسال إيميل للمشتري
        await sendStoreEmailWithBrevo(
            buyer.email,
            `✅ Order Confirmation #${order.orderNumber}`,
            buyerEmailHtml,
            `Thank you for your order! Order #${order.orderNumber} has been confirmed. Total: ${storeSettings.currencySymbol || '$'}${storeCart.subtotal.toFixed(2)}`
        );
        
        // ============================================
        // 8. 📧 إرسال إيميل للبائع (إشعار بطلب جديد)
        // ============================================
        const sellerEmailHtml = `
            <!DOCTYPE html>
            <html dir="ltr">
            <head>
                <meta charset="UTF-8">
                <meta name="viewport" content="width=device-width, initial-scale=1.0">
                <title>New Order Received</title>
                <style>
                    body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; line-height: 1.6; color: #333; margin: 0; padding: 0; background: #f4f4f4; }
                    .container { max-width: 600px; margin: 0 auto; padding: 20px; }
                    .header { background: linear-gradient(135deg, #f59e0b 0%, #ef4444 100%); color: white; padding: 30px; text-align: center; border-radius: 10px 10px 0 0; }
                    .content { background: white; padding: 30px; border-radius: 0 0 10px 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
                    .order-details { background: #f9fafb; padding: 20px; border-radius: 10px; margin: 20px 0; border: 1px solid #e5e7eb; }
                    .action-buttons { display: flex; gap: 10px; margin-top: 20px; flex-wrap: wrap; }
                    .btn-primary { background: #10b981; color: white; padding: 12px 24px; text-decoration: none; border-radius: 8px; display: inline-block; }
                    .btn-secondary { background: #6b7280; color: white; padding: 12px 24px; text-decoration: none; border-radius: 8px; display: inline-block; }
                    .footer { text-align: center; padding: 20px; font-size: 12px; color: #6b7280; }
                </style>
            </head>
            <body>
                <div class="container">
                    <div class="header">
                        <h1>🛍️ New Order Received!</h1>
                        <p>Order #${order.orderNumber}</p>
                    </div>
                    <div class="content">
                        <h2>Congratulations, ${seller.profile?.nickname || seller.username}! 🎉</h2>
                        <p>You have received a new order from <strong>${buyer.profile?.nickname || buyer.username}</strong>.</p>
                        
                        <div class="order-details">
                            <h3>📋 Order Details</h3>
                            <p><strong>Order Number:</strong> <span style="font-family: monospace;">${order.orderNumber}</span></p>
                            <p><strong>Customer:</strong> ${buyer.username} (${buyer.email})</p>
                            <p><strong>Date:</strong> ${new Date().toLocaleString()}</p>
                            <p><strong>Payment Method:</strong> ${paymentMethodData.type === 'vodafone' ? '📱 Vodafone Cash' : paymentMethodData.type === 'instapay' ? '🏦 InstaPay' : paymentMethodData.type === 'paypal' ? '💰 PayPal' : paymentMethodData.type === 'bank' ? '🏛️ Bank Transfer' : paymentMethodData.type}</p>
                            
                            <h3 style="margin-top: 20px;">🛍️ Items Ordered</h3>
                            ${storeCart.items.map(item => `
                                <div class="product-item" style="padding: 10px 0; border-bottom: 1px solid #e5e7eb;">
                                    <strong>${item.title}</strong><br>
                                    Type: ${item.productType}<br>
                                    Quantity: ${item.quantity}<br>
                                    Price: ${storeSettings.currencySymbol || '$'}${(item.price * item.quantity).toFixed(2)}
                                </div>
                            `).join('')}
                            
                            <div class="total" style="margin-top: 20px; padding-top: 20px; border-top: 2px solid #e5e7eb;">
                                <strong>💰 Total Amount:</strong> 
                                <span style="font-size: 24px; color: #f59e0b;">${storeSettings.currencySymbol || '$'}${storeCart.subtotal.toFixed(2)}</span>
                            </div>
                            
                            ${buyerNotes ? `
                                <div style="margin-top: 20px; padding: 15px; background: #fef3c7; border-radius: 8px;">
                                    <strong>📝 Customer Notes:</strong><br>
                                    ${buyerNotes}
                                </div>
                            ` : ''}
                        </div>
                        
                        <div class="action-buttons">
                            <a href="${FRONTEND_URL || 'https://mark-elasfar.web.app'}/store/orders/${order._id}" class="btn-primary">📦 View & Process Order</a>
                            <a href="${FRONTEND_URL || 'https://mark-elasfar.web.app'}/store/earnings" class="btn-secondary">💰 Earnings Dashboard</a>
                        </div>
                        
                        <div style="margin-top: 20px; padding: 15px; background: #dbeafe; border-radius: 8px;">
                            <h3>💡 Next Steps</h3>
                            <ol style="margin: 0; padding-left: 20px;">
                                <li>✅ Confirm payment receipt from the customer</li>
                                <li>📝 Update order status to "Processing"</li>
                                <li>📎 For digital products: Upload files or provide download links</li>
                                <li>🎉 Mark order as "Completed" when done</li>
                                <li>⭐ Ask customer to leave a review</li>
                            </ol>
                        </div>
                        
                        <p style="margin-top: 20px; font-size: 12px; color: #6b7280; text-align: center;">
                            You're receiving this email because you have a store on MGZon.
                        </p>
                    </div>
                    <div class="footer">
                        <p>© ${new Date().getFullYear()} MGZon. All rights reserved.</p>
                        <p>This is an automated message, please do not reply.</p>
                    </div>
                </div>
            </body>
            </html>
        `;
        
        // إرسال إيميل للبائع
        await sendStoreEmailWithBrevo(
            seller.email,
            `🛍️ New Order #${order.orderNumber} from ${buyer.username}`,
            sellerEmailHtml,
            `New order received! Order #${order.orderNumber} from ${buyer.username}. Total: ${storeSettings.currencySymbol || '$'}${storeCart.subtotal.toFixed(2)}`
        );
        
        // ============================================
        // 9. 📱 إرسال إشعار عبر Socket.IO (في الوقت الفعلي)
        // ============================================
        const io = req.app.get('io');
        if (io) {
            // إشعار للبائع
            io.to(`user_${storeId}`).emit('new_order_notification', {
                orderId: order._id,
                orderNumber: order.orderNumber,
                buyerName: buyer.profile?.nickname || buyer.username,
                totalAmount: storeCart.subtotal,
                currency: storeSettings.currencySymbol || '$',
                itemsCount: storeCart.items.length,
                timestamp: new Date()
            });
            
            // إشعار للمشتري
            io.to(`user_${req.user.userId}`).emit('order_created', {
                orderId: order._id,
                orderNumber: order.orderNumber,
                status: 'pending',
                storeName: storeSettings.storeName,
                timestamp: new Date()
            });
        }
        
        // ============================================
        // 10. 📝 إنشاء إشعارات في قاعدة البيانات
        // ============================================
        
        // إشعار للبائع
        try {
            const Notification = mongoose.model('Notification');
            const sellerNotification = new Notification({
                userId: storeId,
                type: 'new_order',
                actorId: req.user.userId,
                actorName: buyer.profile?.nickname || buyer.username,
                content: `🛍️ New order #${order.orderNumber} from ${buyer.profile?.nickname || buyer.username} - ${storeCart.items.length} item(s) - Total: ${storeSettings.currencySymbol || '$'}${storeCart.subtotal.toFixed(2)}`,
                targetId: `/store/orders/${order._id}`,
                targetType: 'store',
                read: false
            });
            await sellerNotification.save();
        } catch (e) {
            console.log('Notification model not found, skipping...');
        }
        
        // إشعار للمشتري
        try {
            const Notification = mongoose.model('Notification');
            const buyerNotification = new Notification({
                userId: req.user.userId,
                type: 'order_status_update',
                actorId: storeId,
                actorName: storeSettings.storeName || seller.profile?.nickname || seller.username,
                content: `✅ Your order #${order.orderNumber} has been created and is pending confirmation from the seller`,
                targetId: `/store/orders/${order._id}`,
                targetType: 'store',
                read: false
            });
            await buyerNotification.save();
        } catch (e) {
            console.log('Notification model not found, skipping...');
        }
        
        // ============================================
        // 11. 🎉 إرسال الرد النهائي
        // ============================================
        res.json({
            success: true,
            orderId: order._id,
            orderNumber: order.orderNumber,
            totalAmount: storeCart.subtotal,
            currencySymbol: storeSettings.currencySymbol || '$',
            paymentMethods: storeSettings.paymentMethods,
            message: 'Order created successfully! Check your email for confirmation.'
        });
        
    } catch (error) {
        console.error('Error creating order:', error);
        res.status(500).json({ error: 'Failed to create order: ' + error.message });
    }
});

// ============================================
// 9. GET /api/checkout/payment-info/:storeId - جلب معلومات الدفع للمتجر
// ============================================
app.get('/api/checkout/payment-info/:storeId', async (req, res) => {
    try {
        const { storeId } = req.params;
        
        const storeSettings = await StoreSettings.findOne({ userId: storeId });
        if (!storeSettings) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        res.json({
            success: true,
            paymentMethods: storeSettings.paymentMethods || [],
            currencySymbol: storeSettings.currencySymbol || '$',
            storeName: storeSettings.storeName,
            storeLogo: storeSettings.storeLogo
        });
        
    } catch (error) {
        console.error('Error fetching payment info:', error);
        res.status(500).json({ error: 'Failed to fetch payment info' });
    }
});

// GET /api/store/orders/buyer - جلب طلبات المستخدم (كمشتري)
app.get('/api/store/orders/buyer', authenticateToken, async (req, res) => {
    try {
        const orders = await Order.find({ buyerId: req.user.userId })
            .sort({ createdAt: -1 })
            .populate('sellerId', 'username profile.nickname profile.avatar');
        
        res.json({ success: true, orders });
    } catch (error) {
        console.error('Error fetching buyer orders:', error);
        res.status(500).json({ error: 'Failed to fetch orders' });
    }
});

// GET /api/store/orders/seller - جلب طلبات المستخدم (كبائع)
app.get('/api/store/orders/seller', authenticateToken, async (req, res) => {
    try {
        const orders = await Order.find({ sellerId: req.user.userId })
            .sort({ createdAt: -1 })
            .populate('buyerId', 'username profile.nickname profile.avatar');
        
        res.json({ success: true, orders });
    } catch (error) {
        console.error('Error fetching seller orders:', error);
        res.status(500).json({ error: 'Failed to fetch orders' });
    }
});



// ========== 4. الإيرادات ==========

// GET /api/store/earnings - جلب إحصائيات الإيرادات
app.get('/api/store/earnings', authenticateToken, async (req, res) => {
    try {
        let earnings = await Earnings.findOne({ userId: req.user.userId });
        
        if (!earnings) {
            earnings = { totalSales: 0, totalEarnings: 0, pendingPayout: 0, transactions: [] };
        }
        
        const recentOrders = await Order.find({ sellerId: req.user.userId })
            .sort({ createdAt: -1 })
            .limit(10)
            .populate('buyerId', 'username profile.nickname');
        
        res.json({ success: true, earnings, recentOrders });
    } catch (error) {
        console.error('Error fetching earnings:', error);
        res.status(500).json({ error: 'Failed to fetch earnings' });
    }
});

// ========== 5. عربة التسوق (Backup) ==========


// ============================================
// 1. GET /api/cart - جلب السلة كاملة
// ============================================
app.get('/api/cart', authenticateToken, async (req, res) => {
    try {
        let cart = await Cart.findOne({ userId: req.user.userId });
        
        if (!cart) {
            return res.json({ 
                success: true, 
                cart: { stores: [], totalItems: 0, totalStores: 0 } 
            });
        }
        
        // تحويل الـ Map إلى Array للـ Frontend
        const storesArray = [];
        for (let [storeId, storeData] of cart.stores) {
            storesArray.push({
                storeId: storeId,
                storeName: storeData.storeName,
                storeLogo: storeData.storeLogo,
                items: storeData.items,
                subtotal: storeData.subtotal,
                itemCount: storeData.itemCount,
                updatedAt: storeData.updatedAt
            });
        }
        
        res.json({
            success: true,
            cart: {
                stores: storesArray,
                totalItems: cart.totalItems,
                totalStores: cart.totalStores
            }
        });
        
    } catch (error) {
        console.error('Error fetching cart:', error);
        res.status(500).json({ error: 'Failed to fetch cart' });
    }
});

// ============================================
// 2. POST /api/cart/add - إضافة منتج للسلة
// ============================================
app.post('/api/cart/add', authenticateToken, async (req, res) => {
    try {
        const { 
            productId, 
            storeId, 
            storeName, 
            title, 
            price, 
            image, 
            productType, 
            quantity = 1 
        } = req.body;
        
        // ✅ التحقق من البيانات
        if (!productId || !storeId || !title || !price) {
            return res.status(400).json({ error: 'Missing required fields' });
        }
        
        if (quantity < 1 || quantity > 99) {
            return res.status(400).json({ error: 'Quantity must be between 1 and 99' });
        }
        
        // ✅ جلب أو إنشاء السلة
        let cart = await Cart.findOne({ userId: req.user.userId });
        
        if (!cart) {
            cart = new Cart({ 
                userId: req.user.userId, 
                stores: new Map() 
            });
        }
        
        // ✅ الحصول على عربة هذا المتجر
        let storeCart = cart.stores.get(storeId);
        
        if (!storeCart) {
            // إنشاء عربة جديدة لهذا المتجر
            storeCart = {
                storeId: storeId,
                storeName: storeName || 'Store',
                storeLogo: '',
                items: [],
                subtotal: 0,
                itemCount: 0,
                createdAt: new Date(),
                updatedAt: new Date()
            };
        }
        
        // ✅ البحث عن المنتج الموجود
        const existingItemIndex = storeCart.items.findIndex(
            item => item.productId?.toString() === productId?.toString()
        );
        
        if (existingItemIndex !== -1) {
            // تحديث الكمية (حد أقصى 99)
            const newQuantity = storeCart.items[existingItemIndex].quantity + quantity;
            storeCart.items[existingItemIndex].quantity = Math.min(newQuantity, 99);
        } else {
            // إضافة منتج جديد
            storeCart.items.push({
                productId,
                title,
                price,
                quantity: Math.min(quantity, 99),
                image: image || '/assets/img/default-product.png',
                productType: productType || 'digital'
            });
        }
        
        // ✅ حساب الإجماليات لهذا المتجر
        let subtotal = 0;
        let itemCount = 0;
        for (const item of storeCart.items) {
            subtotal += item.price * item.quantity;
            itemCount += item.quantity;
        }
        storeCart.subtotal = subtotal;
        storeCart.itemCount = itemCount;
        storeCart.updatedAt = new Date();
        
        // ✅ حفظ في الـ Map
        cart.stores.set(storeId, storeCart);
        
        // ✅ حساب إجماليات السلة الكلية
        await cart.calculateTotals();
        
        
        cart.markModified('stores');

        await cart.save();
        
        // ✅ إرجاع السلة المحدثة
        const updatedStoreCart = cart.stores.get(storeId);
        
        res.json({
            success: true,
            message: 'Product added to cart',
            storeCart: {
                storeId: storeId,
                storeName: updatedStoreCart.storeName,
                items: updatedStoreCart.items,
                subtotal: updatedStoreCart.subtotal,
                itemCount: updatedStoreCart.itemCount
            },
            cartTotals: {
                totalItems: cart.totalItems,
                totalStores: cart.totalStores
            }
        });
        
    } catch (error) {
        console.error('Error adding to cart:', error);
        res.status(500).json({ error: 'Failed to add to cart' });
    }
});

// ============================================
// 3. PUT /api/cart/update - تحديث كمية منتج
// ============================================
app.put('/api/cart/update', authenticateToken, async (req, res) => {
    try {
        const { storeId, productId, quantity } = req.body;
        
        if (!storeId || !productId) {
            return res.status(400).json({ error: 'Missing required fields' });
        }
        
        if (!quantity || quantity < 1 || quantity > 99) {
            return res.status(400).json({ error: 'Quantity must be between 1 and 99' });
        }
        
        const cart = await Cart.findOne({ userId: req.user.userId });
        if (!cart) {
            return res.status(404).json({ error: 'Cart not found' });
        }
        
        const storeCart = cart.stores.get(storeId);
        if (!storeCart) {
            return res.status(404).json({ error: 'Store not found in cart' });
        }
        
        const itemIndex = storeCart.items.findIndex(
            item => item.productId?.toString() === productId?.toString()
        );
        if (itemIndex === -1) {
            return res.status(404).json({ error: 'Product not found in cart' });
        }
        
        // تحديث الكمية
        storeCart.items[itemIndex].quantity = quantity;
        
        // إعادة حساب الإجماليات
        let subtotal = 0;
        let itemCount = 0;
        for (const item of storeCart.items) {
            subtotal += item.price * item.quantity;
            itemCount += item.quantity;
        }
        storeCart.subtotal = subtotal;
        storeCart.itemCount = itemCount;
        storeCart.updatedAt = new Date();
        
        cart.stores.set(storeId, storeCart);
        await cart.calculateTotals();
        
        cart.markModified('stores');

        await cart.save();
        
        res.json({
            success: true,
            storeCart: {
                storeId: storeId,
                storeName: storeCart.storeName,
                items: storeCart.items,
                subtotal: storeCart.subtotal,
                itemCount: storeCart.itemCount
            },
            cartTotals: {
                totalItems: cart.totalItems,
                totalStores: cart.totalStores
            }
        });
        
    } catch (error) {
        console.error('Error updating cart:', error);
        res.status(500).json({ error: 'Failed to update cart' });
    }
});

// ============================================
// 4. DELETE /api/cart/remove - حذف منتج من السلة
// ============================================
app.delete('/api/cart/remove', authenticateToken, async (req, res) => {
    try {
        const { storeId, productId } = req.body;
        
        if (!storeId || !productId) {
            return res.status(400).json({ error: 'Missing required fields' });
        }
        
        const cart = await Cart.findOne({ userId: req.user.userId });
        if (!cart) {
            return res.status(404).json({ error: 'Cart not found' });
        }
        
        const storeCart = cart.stores.get(storeId);
        if (!storeCart) {
            return res.status(404).json({ error: 'Store not found in cart' });
        }
        
        // حذف المنتج
        storeCart.items = storeCart.items.filter(
            item => item.productId?.toString() !== productId?.toString()
        );
        
        if (storeCart.items.length === 0) {
            // إذا كانت السلة فارغة، احذف المتجر بالكامل
            cart.stores.delete(storeId);
        } else {
            // إعادة حساب الإجماليات
            let subtotal = 0;
            let itemCount = 0;
            for (const item of storeCart.items) {
                subtotal += item.price * item.quantity;
                itemCount += item.quantity;
            }
            storeCart.subtotal = subtotal;
            storeCart.itemCount = itemCount;
            storeCart.updatedAt = new Date();
            cart.stores.set(storeId, storeCart);
        }
        
        await cart.calculateTotals();
        
        cart.markModified('stores');

        await cart.save();
        
        res.json({
            success: true,
            message: 'Product removed from cart',
            cartTotals: {
                totalItems: cart.totalItems,
                totalStores: cart.totalStores
            }
        });
        
    } catch (error) {
        console.error('Error removing from cart:', error);
        res.status(500).json({ error: 'Failed to remove from cart' });
    }
});

// ============================================
// 5. DELETE /api/cart/clear-store - تفريغ سلة متجر واحد
// ============================================
app.delete('/api/cart/clear-store', authenticateToken, async (req, res) => {
    try {
        const { storeId } = req.body;
        
        if (!storeId) {
            return res.status(400).json({ error: 'Store ID is required' });
        }
        
        const cart = await Cart.findOne({ userId: req.user.userId });
        if (!cart) {
            return res.status(404).json({ error: 'Cart not found' });
        }
        
        cart.stores.delete(storeId);
        await cart.calculateTotals();
        
        cart.markModified('stores');

        await cart.save();
        
        res.json({
            success: true,
            message: 'Store cart cleared',
            cartTotals: {
                totalItems: cart.totalItems,
                totalStores: cart.totalStores
            }
        });
        
    } catch (error) {
        console.error('Error clearing store cart:', error);
        res.status(500).json({ error: 'Failed to clear store cart' });
    }
});


// ============================================
// 6. DELETE /api/cart/clear-all - تفريغ كل السلة
// ============================================
app.delete('/api/cart/clear-all', authenticateToken, async (req, res) => {
    try {
        await Cart.findOneAndDelete({ userId: req.user.userId });
        
        res.json({
            success: true,
            message: 'Cart cleared successfully'
        });
        
    } catch (error) {
        console.error('Error clearing cart:', error);
        res.status(500).json({ error: 'Failed to clear cart' });
    }
});

// ============================================
// 7. GET /api/cart/summary - ملخص سريع للسلة
// ============================================
app.get('/api/cart/summary', authenticateToken, async (req, res) => {
    try {
        const cart = await Cart.findOne({ userId: req.user.userId });
        
        if (!cart) {
            return res.json({
                success: true,
                summary: {
                    totalItems: 0,
                    totalStores: 0,
                    stores: []
                }
            });
        }
        
        const storesSummary = [];
        for (let [storeId, storeData] of cart.stores) {
            storesSummary.push({
                storeId: storeId,
                storeName: storeData.storeName,
                itemCount: storeData.itemCount,
                subtotal: storeData.subtotal
            });
        }
        
        res.json({
            success: true,
            summary: {
                totalItems: cart.totalItems,
                totalStores: cart.totalStores,
                stores: storesSummary
            }
        });
        
    } catch (error) {
        console.error('Error fetching cart summary:', error);
        res.status(500).json({ error: 'Failed to fetch cart summary' });
    }
});

// GET /api/cart/store/:storeId - جلب سلة متجر واحد
app.get('/api/cart/store/:storeId', authenticateToken, async (req, res) => {
    try {
        const { storeId } = req.params;
        const cart = await Cart.findOne({ userId: req.user.userId });
        
        if (!cart) {
            return res.json({ success: true, storeCart: null });
        }
        
        const storeCart = cart.stores.get(storeId);
        if (!storeCart) {
            return res.json({ success: true, storeCart: null });
        }
        
        res.json({
            success: true,
            storeCart: {
                storeId: storeId,
                storeName: storeCart.storeName,
                items: storeCart.items,
                subtotal: storeCart.subtotal,
                itemCount: storeCart.itemCount
            }
        });
    } catch (error) {
        res.status(500).json({ error: 'Failed to fetch store cart' });
    }
});




// POST /api/store/coupons - إنشاء كوبون
app.post('/api/store/coupons', authenticateToken, async (req, res) => {
    try {
        const { code, discountType, discountValue, minPurchase, maxDiscount, validUntil, usageLimit, applicableProducts } = req.body;
        
        // التحقق من أن الكوبون غير موجود
        const existingCoupon = await Coupon.findOne({ code: code.toUpperCase() });
        if (existingCoupon) {
            return res.status(400).json({ error: 'Coupon code already exists' });
        }
        
        const coupon = new Coupon({
            storeId: req.user.userId,
            code: code.toUpperCase(),
            discountType,
            discountValue,
            minPurchase: minPurchase || 0,
            maxDiscount,
            validUntil: validUntil ? new Date(validUntil) : null,
            usageLimit,
            applicableProducts: applicableProducts || []
        });
        
        await coupon.save();
        
        res.json({ success: true, coupon });
    } catch (error) {
        console.error('Error creating coupon:', error);
        res.status(500).json({ error: 'Failed to create coupon' });
    }
});

// POST /api/store/validate-coupon - التحقق من صحة الكوبون
app.post('/api/store/validate-coupon', authenticateToken, async (req, res) => {
    try {
        const { code, cartTotal, storeId } = req.body;
        
        const coupon = await Coupon.findOne({ 
            code: code.toUpperCase(), 
            storeId,
            isActive: true 
        });
        
        if (!coupon) {
            return res.status(404).json({ error: 'Invalid coupon code' });
        }
        
        // التحقق من صلاحية التاريخ
        const now = new Date();
        if (coupon.validFrom && now < coupon.validFrom) {
            return res.status(400).json({ error: 'Coupon not yet active' });
        }
        if (coupon.validUntil && now > coupon.validUntil) {
            return res.status(400).json({ error: 'Coupon has expired' });
        }
        
        // التحقق من الحد الأقصى للاستخدام
        if (coupon.usageLimit && coupon.usageCount >= coupon.usageLimit) {
            return res.status(400).json({ error: 'Coupon usage limit reached' });
        }
        
        // التحقق من الحد الأدنى للشراء
        if (cartTotal < coupon.minPurchase) {
            return res.status(400).json({ error: `Minimum purchase of $${coupon.minPurchase} required` });
        }
        
        // حساب الخصم
        let discountAmount = 0;
        if (coupon.discountType === 'percentage') {
            discountAmount = (cartTotal * coupon.discountValue) / 100;
            if (coupon.maxDiscount && discountAmount > coupon.maxDiscount) {
                discountAmount = coupon.maxDiscount;
            }
        } else {
            discountAmount = Math.min(coupon.discountValue, cartTotal);
        }
        
        res.json({ 
            success: true, 
            coupon,
            discountAmount,
            finalTotal: cartTotal - discountAmount
        });
    } catch (error) {
        console.error('Error validating coupon:', error);
        res.status(500).json({ error: 'Failed to validate coupon' });
    }
});

// ============================================
// STORE ANALYTICS
// ============================================

// GET /api/store/analytics - إحصائيات المتجر
app.get('/api/store/analytics', authenticateToken, async (req, res) => {
    try {
        const storeId = req.user.userId;
        
        // جلب إحصائيات الطلبات
        const ordersStats = await Order.aggregate([
            { $match: { sellerId: storeId } },
            { $group: {
                _id: null,
                totalOrders: { $sum: 1 },
                completedOrders: { $sum: { $cond: [{ $eq: ['$status', 'completed'] }, 1, 0] } },
                totalRevenue: { $sum: { $cond: [{ $eq: ['$status', 'completed'] }, '$totalAmount', 0] } },
                pendingOrders: { $sum: { $cond: [{ $eq: ['$status', 'pending'] }, 1, 0] } }
            }}
        ]);
        
        // جلب إحصائيات المنتجات
        const productsStats = await Product.aggregate([
            { $match: { userId: storeId } },
            { $group: {
                _id: '$type',
                count: { $sum: 1 },
                totalSales: { $sum: '$salesCount' }
            }}
        ]);
        
        // جلب إحصائيات الزوار (Google Analytics)
        const visitors = await ProfileAnalytics.findOne({ userId: storeId });
        
        // جلب المنتجات الأكثر مبيعاً
        const topProducts = await Product.find({ userId: storeId, isActive: true })
            .sort({ salesCount: -1 })
            .limit(5)
            .select('title salesCount price images');
        
        // جلب الطلبات الشهرية (آخر 6 أشهر)
        const monthlyOrders = await Order.aggregate([
            { $match: { sellerId: storeId, status: 'completed' } },
            { $group: {
                _id: { $dateToString: { format: '%Y-%m', date: '$createdAt' } },
                count: { $sum: 1 },
                revenue: { $sum: '$totalAmount' }
            }},
            { $sort: { _id: -1 } },
            { $limit: 6 }
        ]);
        
        res.json({
            success: true,
            analytics: {
                orders: ordersStats[0] || { totalOrders: 0, completedOrders: 0, totalRevenue: 0, pendingOrders: 0 },
                products: productsStats,
                visitors: visitors?.profileViews?.length || 0,
                topProducts,
                monthlyOrders: monthlyOrders.reverse()
            }
        });
    } catch (error) {
        console.error('Error fetching store analytics:', error);
        res.status(500).json({ error: 'Failed to fetch analytics' });
    }
});

// ============================================
// PAYMENT WEBHOOKS (للدفع الآمن - يدعم عدة مستخدمين)
// ============================================

// ============================================
// Webhook لـ PayPal (معدل لدعم عدة مستخدمين)
// ============================================
app.post('/api/webhooks/paypal', express.raw({ type: 'application/json' }), async (req, res) => {
    try {
        const event = req.body;
        const orderId = event.resource?.custom_id;
        
        if (!orderId) {
            return res.status(400).json({ error: 'Missing orderId' });
        }
        
        // 1. جلب الطلب ومعرفة البائع
        const order = await Order.findById(orderId).populate('sellerId');
        if (!order) {
            return res.status(404).json({ error: 'Order not found' });
        }
        
        // 2. جلب إعدادات المتجر
        const storeSettings = await StoreSettings.findOne({ userId: order.sellerId._id });
        if (!storeSettings) {
            return res.status(404).json({ error: 'Store settings not found' });
        }
        
        // 3. التحقق من وجود PayPal في طرق الدفع
        const paypalMethod = storeSettings.paymentMethods.find(
            m => m.type === 'paypal' && m.isActive !== false
        );
        
        if (!paypalMethod) {
            return res.status(400).json({ error: 'PayPal not configured' });
        }
        
        // 4. معالجة الحدث
        if (event.event_type === 'PAYMENT.CAPTURE.COMPLETED') {
            const transactionId = event.resource.id;
            
            await Order.findByIdAndUpdate(orderId, {
                status: 'paid',
                paymentDetails: {
                    transactionId,
                    provider: 'paypal',
                    capturedAt: new Date(),
                    webhookReceived: new Date(),
                    payerEmail: event.resource.payer?.email_address
                }
            });
            
            // ✅ تحديث الإيرادات
            await updateEarnings(orderId);
            
            // ✅ إرسال إشعارات
            await sendOrderPaidNotifications(orderId, req);
            
            console.log(`✅ PayPal payment confirmed for order #${order.orderNumber}`);
        }
        
        res.json({ received: true });
        
    } catch (error) {
        console.error('❌ PayPal webhook error:', error);
        res.status(500).json({ error: 'Webhook processing failed' });
    }
});

// ============================================
// Webhook لـ Stripe (معدل لدعم عدة مستخدمين)
// ============================================
app.post('/api/webhooks/stripe', express.raw({ type: 'application/json' }), async (req, res) => {
    const sig = req.headers['stripe-signature'];
    
    try {
        // 1. جلب orderId من الـ metadata
        const rawBody = req.body.toString();
        const parsed = JSON.parse(rawBody);
        const orderId = parsed.data?.object?.metadata?.orderId;
        
        if (!orderId) {
            return res.status(400).send('Missing orderId in metadata');
        }
        
        // 2. جلب الطلب ومعرفة البائع
        const order = await Order.findById(orderId).populate('sellerId');
        if (!order) {
            return res.status(404).send('Order not found');
        }
        
        // 3. جلب إعدادات المتجر للبائع
        const storeSettings = await StoreSettings.findOne({ userId: order.sellerId._id });
        if (!storeSettings) {
            return res.status(404).send('Store settings not found');
        }
        
        // 4. العثور على طريقة الدفع Stripe
        const stripeMethod = storeSettings.paymentMethods.find(
            m => m.type === 'stripe' && m.isActive !== false
        );
        
        if (!stripeMethod || !stripeMethod.details?.webhookSecret) {
            console.error('❌ Stripe webhook secret not configured for seller:', order.sellerId._id);
            return res.status(400).send('Stripe webhook secret not configured');
        }
        
        // 5. ✅ استخدام الـ webhook secret الخاص بالبائع
        const webhookSecret = stripeMethod.details.webhookSecret;
        const event = stripe.webhooks.constructEvent(req.body, sig, webhookSecret);
        
        // 6. معالجة الحدث
        if (event.type === 'checkout.session.completed') {
            const session = event.data.object;
            
            await Order.findByIdAndUpdate(orderId, {
                status: 'paid',
                paymentDetails: {
                    sessionId: session.id,
                    provider: 'stripe',
                    paymentIntent: session.payment_intent,
                    webhookReceived: new Date(),
                    customerEmail: session.customer_email
                }
            });
            
            // ✅ تحديث الإيرادات
            await updateEarnings(orderId);
            
            // ✅ إرسال إشعارات
            await sendOrderPaidNotifications(orderId, req);
            
            console.log(`✅ Stripe payment confirmed for order #${order.orderNumber}`);
        }
        
        res.json({ received: true });
        
    } catch (error) {
        console.error('❌ Stripe webhook error:', error);
        res.status(400).send(`Webhook Error: ${error.message}`);
    }
});

// ============================================
// Helper: تحديث الإيرادات عند الدفع
// ============================================
async function updateEarnings(orderId) {
    try {
        const order = await Order.findById(orderId);
        if (!order) return;
        
        let earnings = await Earnings.findOne({ userId: order.sellerId });
        if (!earnings) {
            earnings = new Earnings({ userId: order.sellerId });
        }
        
        earnings.totalSales += 1;
        earnings.totalEarnings += order.totalAmount;
        earnings.pendingPayout += order.totalAmount;
        earnings.lifetimeEarnings = (earnings.lifetimeEarnings || 0) + order.totalAmount;
        
        earnings.transactions.push({
            orderId: order._id,
            amount: order.totalAmount,
            type: 'sale',
            status: 'completed',
            notes: `Order #${order.orderNumber}`,
            createdAt: new Date()
        });
        
        // تحديث الإحصائيات الشهرية
        const monthKey = new Date().toISOString().slice(0, 7);
        const monthStat = earnings.monthlyStats.find(m => m.month === monthKey);
        if (monthStat) {
            monthStat.sales += 1;
            monthStat.earnings += order.totalAmount;
        } else {
            earnings.monthlyStats.push({
                month: monthKey,
                sales: 1,
                earnings: order.totalAmount
            });
        }
        
        await earnings.save();
        console.log(`✅ Earnings updated for seller ${order.sellerId}: +${order.totalAmount}`);
        
    } catch (error) {
        console.error('❌ Error updating earnings:', error);
    }
}


// ============================================
// 👑 ADMIN - STORES MANAGEMENT (إدارة المتاجر)
// ============================================

// GET /api/admin/stores - جلب جميع المتاجر (✅ موجود لكن نحتاج تحسين)
app.get('/api/admin/stores', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        // جلب جميع المستخدمين الذين لديهم متجر مفعل أو كان مفعلاً سابقاً
        const stores = await StoreSettings.find({})
            .populate('userId', 'username email profile.nickname profile.avatar profile.storeEnabled')
            .sort({ createdAt: -1 });
        
        // إضافة إحصائيات لكل متجر
        const storesWithStats = await Promise.all(stores.map(async (store) => {
            const productsCount = await Product.countDocuments({ userId: store.userId._id });
            const ordersCount = await Order.countDocuments({ sellerId: store.userId._id });
            const completedOrders = await Order.find({ sellerId: store.userId._id, status: 'completed' });
            const totalSales = completedOrders.reduce((sum, order) => sum + order.totalAmount, 0);
            
            return {
                _id: store._id,
                userId: store.userId,
                storeName: store.storeName || store.userId.profile?.nickname || store.userId.username,
                storeLogo: store.storeLogo,
                enabled: store.enabled,
                createdAt: store.createdAt,
                updatedAt: store.updatedAt,
                productsCount,
                ordersCount,
                totalSales,
                currencySymbol: store.currencySymbol || '$'
            };
        }));
        
        res.json({ success: true, stores: storesWithStats });
    } catch (error) {
        console.error('Error fetching stores:', error);
        res.status(500).json({ error: 'Failed to fetch stores' });
    }
});

// GET /api/admin/products - جلب جميع المنتجات
app.get('/api/admin/products', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { type, status, page = 1, limit = 20 } = req.query;
        const query = {};
        
        if (type && type !== 'all') query.type = type;
        if (status === 'active') query.isActive = true;
        else if (status === 'inactive') query.isActive = false;
        
        const products = await Product.find(query)
            .populate('userId', 'username email profile.nickname profile.avatar')
            .sort({ createdAt: -1 })
            .skip((page - 1) * limit)
            .limit(parseInt(limit));
        
        const total = await Product.countDocuments(query);
        
        res.json({
            success: true,
            products,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / limit)
            }
        });
    } catch (error) {
        console.error('Error fetching all products:', error);
        res.status(500).json({ error: 'Failed to fetch products' });
    }
});

// PUT /api/admin/stores/:userId/toggle - تفعيل/تعطيل متجر
app.put('/api/admin/stores/:userId/toggle', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { enabled } = req.body;
        const targetUserId = req.params.userId;
        
        // تحديث إعدادات المتجر
        await StoreSettings.findOneAndUpdate(
            { userId: targetUserId },
            { enabled: enabled === true || enabled === 'true', updatedAt: Date.now() },
            { upsert: true }
        );
        
        // تحديث حالة المتجر في البروفايل
        await User.findByIdAndUpdate(targetUserId, {
            'profile.storeEnabled': enabled === true || enabled === 'true'
        });
        
        // إشعار للمستخدم
        const user = await User.findById(targetUserId);
        if (user) {
            const notification = new Notification({
                userId: targetUserId,
                type: 'admin_action',
                actorId: req.user.userId,
                actorName: admin.username,
                content: enabled ? 'Your store has been enabled by admin.' : 'Your store has been disabled by admin.',
                targetId: `/shop/${user.profile?.nickname || user.username}`,
                targetType: 'store',
                read: false
            });
            await notification.save();
        }
        
        res.json({ success: true, enabled: enabled === true || enabled === 'true' });
    } catch (error) {
        console.error('Error toggling store:', error);
        res.status(500).json({ error: 'Failed to toggle store' });
    }
});

// DELETE /api/admin/stores/:userId - حذف متجر بالكامل
app.delete('/api/admin/stores/:userId', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const targetUserId = req.params.userId;
        
        // حذف جميع منتجات المتجر
        await Product.deleteMany({ userId: targetUserId });
        
        // حذف جميع طلبات المتجر
        await Order.deleteMany({ sellerId: targetUserId });
        
        // حذف إعدادات المتجر
        await StoreSettings.findOneAndDelete({ userId: targetUserId });
        
        // تعطيل المتجر في البروفايل
        await User.findByIdAndUpdate(targetUserId, {
            'profile.storeEnabled': false
        });
        
        res.json({ success: true, message: 'Store deleted successfully' });
    } catch (error) {
        console.error('Error deleting store:', error);
        res.status(500).json({ error: 'Failed to delete store' });
    }
});

// ============================================
// 👑 ADMIN - ALL PRODUCTS MANAGEMENT (جميع المنتجات)
// ============================================

// PUT /api/admin/products/:productId/toggle - تفعيل/تعطيل منتج
app.put('/api/admin/products/:productId/toggle', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { isActive } = req.body;
        const product = await Product.findByIdAndUpdate(
            req.params.productId,
            { isActive: isActive === true || isActive === 'true', updatedAt: Date.now() },
            { new: true }
        );
        
        if (!product) {
            return res.status(404).json({ error: 'Product not found' });
        }
        
        // إشعار لصاحب المنتج
        const user = await User.findById(product.userId);
        if (user) {
            const notification = new Notification({
                userId: product.userId,
                type: 'admin_action',
                actorId: req.user.userId,
                actorName: admin.username,
                content: isActive ? 'Your product has been approved and is now active.' : 'Your product has been deactivated by admin.',
                targetId: `/product.html?id=${product._id}&owner=${user.profile?.nickname || user.username}`,
                targetType: 'product',
                read: false
            });
            await notification.save();
        }
        
        res.json({ success: true, product });
    } catch (error) {
        console.error('Error toggling product:', error);
        res.status(500).json({ error: 'Failed to toggle product' });
    }
});

// DELETE /api/admin/products/:productId - حذف منتج
app.delete('/api/admin/products/:productId', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const product = await Product.findByIdAndDelete(req.params.productId);
        
        if (!product) {
            return res.status(404).json({ error: 'Product not found' });
        }
        
        res.json({ success: true });
    } catch (error) {
        console.error('Error deleting product:', error);
        res.status(500).json({ error: 'Failed to delete product' });
    }
});

// ============================================
// 👑 ADMIN - ALL ORDERS MANAGEMENT (جميع الطلبات)
// ============================================

// GET /api/admin/orders - جلب جميع الطلبات
app.get('/api/admin/orders', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { status, page = 1, limit = 20 } = req.query;
        const query = {};
        if (status && status !== 'all') query.status = status;
        
        const orders = await Order.find(query)
            .populate('buyerId', 'username email profile.nickname profile.avatar')
            .populate('sellerId', 'username email profile.nickname profile.avatar')
            .sort({ createdAt: -1 })
            .skip((page - 1) * limit)
            .limit(parseInt(limit));
        
        const total = await Order.countDocuments(query);
        
        res.json({
            success: true,
            orders,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / limit)
            }
        });
    } catch (error) {
        console.error('Error fetching all orders:', error);
        res.status(500).json({ error: 'Failed to fetch orders' });
    }
});

// PUT /api/admin/orders/:orderId/status - تحديث حالة طلب
app.put('/api/admin/orders/:orderId/status', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { status, adminNotes } = req.body;
        const order = await Order.findByIdAndUpdate(
            req.params.orderId,
            { status, adminNotes, updatedAt: Date.now() },
            { new: true }
        );
        
        if (!order) {
            return res.status(404).json({ error: 'Order not found' });
        }
        
        // إشعار للمشتري
        const notification = new Notification({
            userId: order.buyerId,
            type: 'order_status_update',
            actorId: req.user.userId,
            actorName: admin.username,
            content: `Order #${order.orderNumber} status updated to ${status} by admin.`,
            targetId: `/order-details.html?id=${order._id}`,
            targetType: 'order',
            read: false
        });
        await notification.save();
        
        res.json({ success: true, order });
    } catch (error) {
        console.error('Error updating order status:', error);
        res.status(500).json({ error: 'Failed to update order status' });
    }
});

// ============================================
// 👑 ADMIN - PLATFORM BANK ACCOUNTS (حسابات البنك)
// ============================================

// GET /api/admin/platform-banks - جلب حسابات البنك
app.get('/api/admin/platform-banks', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        // يمكن تخزين حسابات البنك في Collection منفصلة أو في Site Settings
        let banks = await PlatformBank.find().sort({ order: 1 });
        
        if (!banks || banks.length === 0) {
            // إعدادات افتراضية
            banks = [];
        }
        
        res.json({ success: true, banks });
    } catch (error) {
        console.error('Error fetching platform banks:', error);
        res.status(500).json({ error: 'Failed to fetch banks' });
    }
});

// POST /api/admin/platform-banks - إضافة حساب بنك
app.post('/api/admin/platform-banks', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { bankName, accountName, accountNumber, iban, swiftCode, isActive, order } = req.body;
        
        const bank = new PlatformBank({
            bankName,
            accountName,
            accountNumber,
            iban,
            swiftCode,
            isActive: isActive !== false,
            order: order || 0,
            createdAt: new Date()
        });
        
        await bank.save();
        
        res.status(201).json({ success: true, bank });
    } catch (error) {
        console.error('Error adding platform bank:', error);
        res.status(500).json({ error: 'Failed to add bank' });
    }
});

// PUT /api/admin/platform-banks/:bankId - تحديث حساب بنك
app.put('/api/admin/platform-banks/:bankId', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { bankName, accountName, accountNumber, iban, swiftCode, isActive, order } = req.body;
        
        const bank = await PlatformBank.findByIdAndUpdate(
            req.params.bankId,
            { bankName, accountName, accountNumber, iban, swiftCode, isActive, order, updatedAt: Date.now() },
            { new: true }
        );
        
        if (!bank) {
            return res.status(404).json({ error: 'Bank not found' });
        }
        
        res.json({ success: true, bank });
    } catch (error) {
        console.error('Error updating platform bank:', error);
        res.status(500).json({ error: 'Failed to update bank' });
    }
});

// DELETE /api/admin/platform-banks/:bankId - حذف حساب بنك
app.delete('/api/admin/platform-banks/:bankId', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        await PlatformBank.findByIdAndDelete(req.params.bankId);
        
        res.json({ success: true });
    } catch (error) {
        console.error('Error deleting platform bank:', error);
        res.status(500).json({ error: 'Failed to delete bank' });
    }
});

// ============================================
// 👑 ADMIN - USERS MANAGEMENT (إدارة المستخدمين)
// ============================================

// GET /api/admin/users - جلب جميع المستخدمين مع تفاصيل إضافية
app.get('/api/admin/users/all', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { role, page = 1, limit = 20 } = req.query;
        const query = {};
        if (role === 'admin') query.isAdmin = true;
        else if (role === 'user') query.isAdmin = false;
        
        const users = await User.find(query)
            .select('username email isAdmin createdAt profile.nickname profile.avatar profile.storeEnabled')
            .sort({ createdAt: -1 })
            .skip((page - 1) * limit)
            .limit(parseInt(limit));
        
        const total = await User.countDocuments(query);
        
        // إضافة إحصائيات لكل مستخدم
        const usersWithStats = await Promise.all(users.map(async (user) => {
            const productsCount = await Product.countDocuments({ userId: user._id });
            const ordersCount = await Order.countDocuments({ buyerId: user._id });
            const salesCount = await Order.countDocuments({ sellerId: user._id, status: 'completed' });
            
            return {
                ...user.toObject(),
                stats: { productsCount, ordersCount, salesCount }
            };
        }));
        
        res.json({
            success: true,
            users: usersWithStats,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / limit)
            }
        });
    } catch (error) {
        console.error('Error fetching users:', error);
        res.status(500).json({ error: 'Failed to fetch users' });
    }
});

// POST /api/admin/users/:userId/make-admin - جعل مستخدم مسؤول
app.post('/api/admin/users/:userId/make-admin', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { isAdmin } = req.body;
        const targetUser = await User.findByIdAndUpdate(
            req.params.userId,
            { isAdmin: isAdmin === true || isAdmin === 'true' },
            { new: true }
        );
        
        if (!targetUser) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        // إشعار للمستخدم
        const notification = new Notification({
            userId: targetUser._id,
            type: 'admin_action',
            actorId: req.user.userId,
            actorName: admin.username,
            content: isAdmin ? 'You have been granted admin privileges.' : 'Your admin privileges have been revoked.',
            targetId: '/admin',
            targetType: 'system',
            read: false
        });
        await notification.save();
        
        res.json({ success: true, isAdmin: targetUser.isAdmin });
    } catch (error) {
        console.error('Error updating user role:', error);
        res.status(500).json({ error: 'Failed to update user role' });
    }
});

// ============================================
// 👑 ADMIN - SYSTEM LOGS (سجلات النظام)
// ============================================

// GET /api/admin/logs - جلب سجلات النظام
app.get('/api/admin/logs', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { type, page = 1, limit = 50 } = req.query;
        
        // جلب الإشعارات والإجراءات الإدارية
        const query = {};
        if (type === 'admin') query.type = { $in: ['admin_action', 'admin_report', 'admin_info'] };
        else if (type === 'user') query.type = { $nin: ['admin_action', 'admin_report', 'admin_info'] };
        
        const logs = await Notification.find(query)
            .populate('userId', 'username email')
            .populate('actorId', 'username')
            .sort({ createdAt: -1 })
            .skip((page - 1) * limit)
            .limit(parseInt(limit));
        
        const total = await Notification.countDocuments(query);
        
        res.json({
            success: true,
            logs,
            pagination: {
                page: parseInt(page),
                limit: parseInt(limit),
                total,
                pages: Math.ceil(total / limit)
            }
        });
    } catch (error) {
        console.error('Error fetching logs:', error);
        res.status(500).json({ error: 'Failed to fetch logs' });
    }
});

// ============================================
// 👑 ADMIN - BACKUP / EXPORT
// ============================================

// GET /api/admin/export/users - تصدير المستخدمين
app.get('/api/admin/export/users', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const users = await User.find({})
            .select('username email isAdmin createdAt profile.nickname profile.jobTitle profile.phone')
            .lean();
        
        // تحويل إلى CSV
        const csvHeaders = ['Username', 'Email', 'Nickname', 'Job Title', 'Phone', 'Is Admin', 'Created At'];
        const csvRows = users.map(user => [
            user.username || '',
            user.email || '',
            user.profile?.nickname || '',
            user.profile?.jobTitle || '',
            user.profile?.phone || '',
            user.isAdmin ? 'Yes' : 'No',
            new Date(user.createdAt).toLocaleDateString()
        ]);
        
        const csvContent = [csvHeaders, ...csvRows].map(row => row.join(',')).join('\n');
        
        res.setHeader('Content-Type', 'text/csv');
        res.setHeader('Content-Disposition', `attachment; filename=users_export_${Date.now()}.csv`);
        res.send(csvContent);
    } catch (error) {
        console.error('Error exporting users:', error);
        res.status(500).json({ error: 'Failed to export users' });
    }
});

// GET /api/admin/export/orders - تصدير الطلبات
app.get('/api/admin/export/orders', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const orders = await Order.find({})
            .populate('buyerId', 'username email')
            .populate('sellerId', 'username email')
            .lean();
        
        const csvHeaders = ['Order Number', 'Buyer', 'Seller', 'Total Amount', 'Status', 'Payment Method', 'Created At'];
        const csvRows = orders.map(order => [
            order.orderNumber || '',
            order.buyerId?.username || '',
            order.sellerId?.username || '',
            order.totalAmount || 0,
            order.status || '',
            order.paymentMethod || '',
            new Date(order.createdAt).toLocaleDateString()
        ]);
        
        const csvContent = [csvHeaders, ...csvRows].map(row => row.join(',')).join('\n');
        
        res.setHeader('Content-Type', 'text/csv');
        res.setHeader('Content-Disposition', `attachment; filename=orders_export_${Date.now()}.csv`);
        res.send(csvContent);
    } catch (error) {
        console.error('Error exporting orders:', error);
        res.status(500).json({ error: 'Failed to export orders' });
    }
});

// POST /api/admin/backup - إنشاء نسخة احتياطية
app.post('/api/admin/backup', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        // جلب البيانات للنسخ الاحتياطي
        const users = await User.find({}).select('-password -refreshTokens').lean();
        const products = await Product.find({}).lean();
        const orders = await Order.find({}).lean();
        const subscriptions = await UserSubscription.find({}).populate('planId').lean();
        
        const backup = {
            timestamp: new Date(),
            version: '1.0',
            data: {
                users,
                products,
                orders,
                subscriptions,
                stats: {
                    totalUsers: users.length,
                    totalProducts: products.length,
                    totalOrders: orders.length,
                    totalSubscriptions: subscriptions.length
                }
            }
        };
        
        // يمكن حفظ النسخة في ملف أو Cloudinary
        const backupJson = JSON.stringify(backup, null, 2);
        
        res.setHeader('Content-Type', 'application/json');
        res.setHeader('Content-Disposition', `attachment; filename=backup_${Date.now()}.json`);
        res.send(backupJson);
    } catch (error) {
        console.error('Error creating backup:', error);
        res.status(500).json({ error: 'Failed to create backup' });
    }
});

// ============================================
// 💳 SUBSCRIPTION API ENDPOINTS
// ============================================

// ========== 1. إدارة خطط الاشتراك (Admin Only) ==========

// GET /api/admin/subscription/plans - جلب كل الخطط
app.get('/api/admin/subscription/plans', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const plans = await SubscriptionPlan.find().sort({ order: 1, price: 1 });
        res.json({ success: true, plans });
    } catch (error) {
        console.error('Error fetching plans:', error);
        res.status(500).json({ error: 'Failed to fetch plans' });
    }
});

// POST /api/admin/subscription/plans - إنشاء خطة جديدة
app.post('/api/admin/subscription/plans', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { name, nameAr, description, descriptionAr, price, currency, duration, features, hasFreeTrial, freeTrialDays, badge, icon, order } = req.body;
        
        // التحقق من عدم وجود خطة بنفس الاسم
        const existingPlan = await SubscriptionPlan.findOne({ name });
        if (existingPlan) {
            return res.status(400).json({ error: 'Plan name already exists' });
        }
        
        const plan = new SubscriptionPlan({
            name,
            nameAr: nameAr || '',
            description: description || '',
            descriptionAr: descriptionAr || '',
            price: parseFloat(price),
            currency: currency || 'USD',
            currencySymbol: currency === 'USD' ? '$' : currency === 'EUR' ? '€' : currency === 'GBP' ? '£' : 'ج.م',
            duration: duration || 'monthly',
            durationDays: duration === 'monthly' ? 30 : duration === 'yearly' ? 365 : 0,
            features: {
                storeEnabled: features?.storeEnabled || false,
                maxProducts: features?.maxProducts || 0,
                maxDigitalProducts: features?.maxDigitalProducts || 0,
                maxProjects: features?.maxProjects || 0,
                maxServices: features?.maxServices || 0,
                pageBuilderEnabled: features?.pageBuilderEnabled || false,
                customDomain: features?.customDomain || false,
                analyticsEnabled: features?.analyticsEnabled || false,
                prioritySupport: features?.prioritySupport || false,
                removeBranding: features?.removeBranding || false,
                teamMembers: features?.teamMembers || 1,
                apiAccess: features?.apiAccess || false,
                customCss: features?.customCss || false,
                advancedAnalytics: features?.advancedAnalytics || false,
                exportData: features?.exportData || false
            },
            hasFreeTrial: hasFreeTrial || false,
            freeTrialDays: freeTrialDays || 0,
            badge: badge || null,
            icon: icon || 'bx-star',
            isActive: true,
            order: order || 0
        });
        
        await plan.save();
        res.status(201).json({ success: true, plan });
    } catch (error) {
        console.error('Error creating plan:', error);
        res.status(500).json({ error: 'Failed to create plan' });
    }
});

// PUT /api/admin/subscription/plans/:planId - تحديث خطة
app.put('/api/admin/subscription/plans/:planId', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { name, nameAr, description, descriptionAr, price, currency, duration, features, hasFreeTrial, freeTrialDays, badge, icon, isActive, order } = req.body;
        
        const plan = await SubscriptionPlan.findById(req.params.planId);
        if (!plan) {
            return res.status(404).json({ error: 'Plan not found' });
        }
        
        // تحديث الحقول
        if (name) plan.name = name;
        if (nameAr !== undefined) plan.nameAr = nameAr;
        if (description !== undefined) plan.description = description;
        if (descriptionAr !== undefined) plan.descriptionAr = descriptionAr;
        if (price !== undefined) plan.price = parseFloat(price);
        if (currency) plan.currency = currency;
        if (duration) {
            plan.duration = duration;
            plan.durationDays = duration === 'monthly' ? 30 : duration === 'yearly' ? 365 : 0;
        }
        if (features) {
            plan.features = { ...plan.features, ...features };
        }
        if (hasFreeTrial !== undefined) plan.hasFreeTrial = hasFreeTrial;
        if (freeTrialDays !== undefined) plan.freeTrialDays = freeTrialDays;
        if (badge !== undefined) plan.badge = badge;
        if (icon) plan.icon = icon;
        if (isActive !== undefined) plan.isActive = isActive;
        if (order !== undefined) plan.order = order;
        
        plan.updatedAt = Date.now();
        await plan.save();
        
        res.json({ success: true, plan });
    } catch (error) {
        console.error('Error updating plan:', error);
        res.status(500).json({ error: 'Failed to update plan' });
    }
});

// DELETE /api/admin/subscription/plans/:planId - حذف خطة
app.delete('/api/admin/subscription/plans/:planId', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        // التحقق من عدم وجود اشتراكات نشطة بهذه الخطة
        const activeSubscriptions = await UserSubscription.countDocuments({
            planId: req.params.planId,
            status: { $in: ['active', 'pending'] }
        });
        
        if (activeSubscriptions > 0) {
            return res.status(400).json({ 
                error: `Cannot delete plan with ${activeSubscriptions} active subscriptions. Deactivate it instead.` 
            });
        }
        
        await SubscriptionPlan.findByIdAndDelete(req.params.planId);
        res.json({ success: true });
    } catch (error) {
        console.error('Error deleting plan:', error);
        res.status(500).json({ error: 'Failed to delete plan' });
    }
});

// GET /api/subscription/plans - جلب الخطط النشطة للمستخدمين
app.get('/api/subscription/plans', async (req, res) => {
    try {
        const plans = await SubscriptionPlan.find({ isActive: true }).sort({ order: 1, price: 1 });
        
        // إضافة معلومات عن اشتراك المستخدم الحالي إذا كان مسجلاً
        let currentSubscription = null;
        if (req.user && req.user.userId) {
            currentSubscription = await UserSubscription.findOne({
                userId: req.user.userId,
                status: 'active'
            }).populate('planId');
        }
        
        res.json({ success: true, plans, currentSubscription });
    } catch (error) {
        console.error('Error fetching active plans:', error);
        res.status(500).json({ error: 'Failed to fetch plans' });
    }
});

// ========== 2. إدارة طرق الدفع (Admin Only) ==========

// GET /api/admin/subscription/payment-methods - جلب طرق الدفع
app.get('/api/admin/subscription/payment-methods', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const methods = await PlatformPaymentMethod.find().sort({ order: 1 });
        res.json({ success: true, methods });
    } catch (error) {
        console.error('Error fetching payment methods:', error);
        res.status(500).json({ error: 'Failed to fetch payment methods' });
    }
});

// POST /api/admin/subscription/payment-methods - إضافة طريقة دفع جديدة
app.post('/api/admin/subscription/payment-methods', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { name, nameAr, type, icon, instructions, instructionsAr, bankDetails, mobileWalletDetails, onlineDetails, order } = req.body;
        
        const method = new PlatformPaymentMethod({
            name,
            nameAr: nameAr || '',
            type,
            icon: icon || (type === 'bank' ? 'bx-bank' : type === 'mobile_wallet' ? 'bx-mobile-alt' : 'bx-credit-card'),
            instructions: instructions || '',
            instructionsAr: instructionsAr || '',
            bankDetails: bankDetails || {},
            mobileWalletDetails: mobileWalletDetails || {},
            onlineDetails: onlineDetails || {},
            isActive: true,
            order: order || 0
        });
        
        await method.save();
        res.status(201).json({ success: true, method });
    } catch (error) {
        console.error('Error creating payment method:', error);
        res.status(500).json({ error: 'Failed to create payment method' });
    }
});

// PUT /api/admin/subscription/payment-methods/:methodId - تحديث طريقة دفع
app.put('/api/admin/subscription/payment-methods/:methodId', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const method = await PlatformPaymentMethod.findById(req.params.methodId);
        if (!method) {
            return res.status(404).json({ error: 'Payment method not found' });
        }
        
        const { name, nameAr, instructions, instructionsAr, bankDetails, mobileWalletDetails, onlineDetails, isActive, order } = req.body;
        
        if (name) method.name = name;
        if (nameAr !== undefined) method.nameAr = nameAr;
        if (instructions !== undefined) method.instructions = instructions;
        if (instructionsAr !== undefined) method.instructionsAr = instructionsAr;
        if (bankDetails) method.bankDetails = { ...method.bankDetails, ...bankDetails };
        if (mobileWalletDetails) method.mobileWalletDetails = { ...method.mobileWalletDetails, ...mobileWalletDetails };
        if (onlineDetails) method.onlineDetails = { ...method.onlineDetails, ...onlineDetails };
        if (isActive !== undefined) method.isActive = isActive;
        if (order !== undefined) method.order = order;
        
        method.updatedAt = Date.now();
        await method.save();
        
        res.json({ success: true, method });
    } catch (error) {
        console.error('Error updating payment method:', error);
        res.status(500).json({ error: 'Failed to update payment method' });
    }
});

// DELETE /api/admin/subscription/payment-methods/:methodId - حذف طريقة دفع
app.delete('/api/admin/subscription/payment-methods/:methodId', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        await PlatformPaymentMethod.findByIdAndDelete(req.params.methodId);
        res.json({ success: true });
    } catch (error) {
        console.error('Error deleting payment method:', error);
        res.status(500).json({ error: 'Failed to delete payment method' });
    }
});

// GET /api/subscription/payment-methods - جلب طرق الدفع النشطة للمستخدمين
app.get('/api/subscription/payment-methods', async (req, res) => {
    try {
        const methods = await PlatformPaymentMethod.find({ isActive: true }).sort({ order: 1 });
        res.json({ success: true, methods });
    } catch (error) {
        console.error('Error fetching payment methods:', error);
        res.status(500).json({ error: 'Failed to fetch payment methods' });
    }
});

// ========== 3. إدارة اشتراكات المستخدمين ==========

// POST /api/subscription/subscribe - إنشاء اشتراك جديد
app.post('/api/subscription/subscribe', authenticateToken, upload.single('paymentProof'), async (req, res) => {
    try {
        const { planId, paymentMethodId, paymentDetails, autoRenew } = req.body;
        
        // التحقق من وجود الخطة
        const plan = await SubscriptionPlan.findById(planId);
        if (!plan || !plan.isActive) {
            return res.status(404).json({ error: 'Plan not found or inactive' });
        }
        
        // التحقق من وجود طريقة الدفع
        const paymentMethod = await PlatformPaymentMethod.findById(paymentMethodId);
        if (!paymentMethod || !paymentMethod.isActive) {
            return res.status(404).json({ error: 'Payment method not found' });
        }
        
        // التحقق من عدم وجود اشتراك نشط للمستخدم
        const existingSubscription = await UserSubscription.findOne({
            userId: req.user.userId,
            status: { $in: ['active', 'pending'] }
        });
        
        let isTrial = false;
        let trialEndDate = null;
        
        // التحقق من التجربة المجانية
        if (plan.hasFreeTrial && !existingSubscription) {
            isTrial = true;
            trialEndDate = new Date();
            trialEndDate.setDate(trialEndDate.getDate() + plan.freeTrialDays);
        }
        
        let paymentProofUrl = null;
        let paymentProofPublicId = null;
        
        // رفع إثبات الدفع إذا وجد
        if (req.file) {
            paymentProofUrl = req.file.path;
            paymentProofPublicId = req.file.filename;
        }
        
        const startDate = isTrial ? new Date() : null;
        const endDate = isTrial ? trialEndDate : null;
        
        const subscription = new UserSubscription({
            userId: req.user.userId,
            planId,
            status: isTrial ? 'active' : 'pending',
            startDate,
            endDate,
            isTrial,
            trialEndDate,
            paymentMethod: paymentMethod.name,
            paymentDetails: paymentDetails ? JSON.parse(paymentDetails) : {},
            paymentProof: paymentProofUrl,
            paymentProofPublicId,
            amount: isTrial ? 0 : plan.price,
            currency: plan.currency,
            autoRenew: autoRenew === 'true' || autoRenew === true,
            createdAt: new Date()
        });
        
        await subscription.save();
        
        // إشعار للإدارة (إذا كان الاشتراك مدفوع)
        if (!isTrial) {
            const adminUsers = await User.find({ isAdmin: true });
            for (const admin of adminUsers) {
                const notification = new Notification({
                    userId: admin._id,
                    type: 'subscription_pending',
                    actorId: req.user.userId,
                    actorName: req.user.username,
                    content: `New subscription request from ${req.user.username} for plan ${plan.name}`,
                    targetId: `/admin/subscriptions/${subscription._id}`,
                    targetType: 'subscription',
                    read: false
                });
                await notification.save();
            }
        }
        
        // إرسال إيميل تأكيد
        const user = await User.findById(req.user.userId);
        const emailHtml = `
            <h2>Subscription Request Received</h2>
            <p>Dear ${user.username},</p>
            <p>Your subscription request for plan "${plan.name}" has been received.</p>
            ${isTrial ? `<p>You are on a ${plan.freeTrialDays}-day free trial starting now.</p>` : '<p>Your request is pending admin approval. You will be notified once approved.</p>'}
            <p>Thank you for choosing MGZon!</p>
        `;
        
        await sendStoreEmailWithBrevo(user.email, `Subscription Request - ${plan.name}`, emailHtml, '');
        
        res.status(201).json({ 
            success: true, 
            subscription,
            isTrial,
            message: isTrial ? 'Free trial started successfully!' : 'Subscription request submitted for approval'
        });
        
    } catch (error) {
        console.error('Error creating subscription:', error);
        res.status(500).json({ error: 'Failed to create subscription' });
    }
});

// GET /api/subscription/my - جلب اشتراك المستخدم الحالي
app.get('/api/subscription/my', authenticateToken, async (req, res) => {
    try {
        const subscription = await UserSubscription.findOne({
            userId: req.user.userId,
            status: { $in: ['active', 'pending'] }
        }).populate('planId').sort({ createdAt: -1 });
        
        const history = await UserSubscription.find({
            userId: req.user.userId
        }).populate('planId').sort({ createdAt: -1 }).limit(10);
        
        res.json({ success: true, subscription, history });
    } catch (error) {
        console.error('Error fetching user subscription:', error);
        res.status(500).json({ error: 'Failed to fetch subscription' });
    }
});

// ========== 4. إدارة الاشتراكات (Admin Only) ==========

// GET /api/admin/subscriptions - جلب كل الاشتراكات
app.get('/api/admin/subscriptions', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { status, page = 1, limit = 20 } = req.query;
        const query = {};
        if (status && status !== 'all') query.status = status;
        
        const subscriptions = await UserSubscription.find(query)
            .populate('userId', 'username email profile.nickname profile.avatar')
            .populate('planId')
            .sort({ createdAt: -1 })
            .skip((page - 1) * limit)
            .limit(parseInt(limit));
        
        const total = await UserSubscription.countDocuments(query);
        
        res.json({ 
            success: true, 
            subscriptions, 
            pagination: { page: parseInt(page), limit: parseInt(limit), total, pages: Math.ceil(total / limit) }
        });
    } catch (error) {
        console.error('Error fetching subscriptions:', error);
        res.status(500).json({ error: 'Failed to fetch subscriptions' });
    }
});

// PUT /api/admin/subscriptions/:subId/approve - الموافقة على اشتراك
app.put('/api/admin/subscriptions/:subId/approve', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { adminNotes } = req.body;
        const subscription = await UserSubscription.findById(req.params.subId).populate('planId');
        
        if (!subscription) {
            return res.status(404).json({ error: 'Subscription not found' });
        }
        
        const startDate = new Date();
        const endDate = new Date();
        endDate.setDate(endDate.getDate() + subscription.planId.durationDays);
        
        subscription.status = 'active';
        subscription.startDate = startDate;
        subscription.endDate = endDate;
        subscription.adminNotes = adminNotes || '';
        subscription.approvedBy = req.user.userId;
        subscription.approvedAt = new Date();
        subscription.updatedAt = new Date();
        
        await subscription.save();
        
        // تسجيل الإيرادات
        if (subscription.amount > 0) {
            const earning = new SubscriptionEarnings({
                subscriptionId: subscription._id,
                userId: subscription.userId,
                planId: subscription.planId._id,
                amount: subscription.amount,
                currency: subscription.currency,
                status: 'completed',
                paymentMethod: subscription.paymentMethod,
                transactionId: subscription.transactionId,
                payoutStatus: 'pending'
            });
            await earning.save();
        }
        
        // تحديث صلاحيات المستخدم بناءً على الخطة
        await updateUserPermissions(subscription.userId, subscription.planId);
        
        // إشعار المستخدم
        const user = await User.findById(subscription.userId);
        const notification = new Notification({
            userId: subscription.userId,
            type: 'subscription_approved',
            actorId: req.user.userId,
            actorName: admin.username,
            content: `Your subscription to "${subscription.planId.name}" has been approved!`,
            targetId: `/subscription`,
            targetType: 'subscription',
            read: false
        });
        await notification.save();
        
        // إرسال إيميل
        const emailHtml = `
            <h2>Subscription Approved! 🎉</h2>
            <p>Dear ${user.username},</p>
            <p>Your subscription to "${subscription.planId.name}" has been approved and is now active.</p>
            <p><strong>Start Date:</strong> ${startDate.toLocaleDateString()}</p>
            <p><strong>End Date:</strong> ${endDate.toLocaleDateString()}</p>
            <p>You can now access all the features included in your plan.</p>
            <a href="${FRONTEND_URL}/dashboard">Go to Dashboard</a>
        `;
        await sendStoreEmailWithBrevo(user.email, `Subscription Approved - ${subscription.planId.name}`, emailHtml, '');
        
        res.json({ success: true, subscription });
    } catch (error) {
        console.error('Error approving subscription:', error);
        res.status(500).json({ error: 'Failed to approve subscription' });
    }
});

// PUT /api/admin/subscriptions/:subId/reject - رفض اشتراك
app.put('/api/admin/subscriptions/:subId/reject', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { rejectionReason } = req.body;
        const subscription = await UserSubscription.findById(req.params.subId).populate('planId');
        
        if (!subscription) {
            return res.status(404).json({ error: 'Subscription not found' });
        }
        
        subscription.status = 'cancelled';
        subscription.cancelledAt = new Date();
        subscription.cancellationReason = rejectionReason || 'Rejected by admin';
        subscription.adminNotes = rejectionReason || '';
        subscription.updatedAt = new Date();
        
        await subscription.save();
        
        // إشعار المستخدم
        const user = await User.findById(subscription.userId);
        const notification = new Notification({
            userId: subscription.userId,
            type: 'subscription_rejected',
            actorId: req.user.userId,
            actorName: admin.username,
            content: `Your subscription to "${subscription.planId.name}" was rejected. Reason: ${rejectionReason || 'Not specified'}`,
            targetId: `/subscription`,
            targetType: 'subscription',
            read: false
        });
        await notification.save();
        
        res.json({ success: true });
    } catch (error) {
        console.error('Error rejecting subscription:', error);
        res.status(500).json({ error: 'Failed to reject subscription' });
    }
});

// PUT /api/admin/subscriptions/:subId/cancel - إلغاء اشتراك نشط
app.put('/api/admin/subscriptions/:subId/cancel', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const { reason } = req.body;
        const subscription = await UserSubscription.findById(req.params.subId).populate('planId');
        
        if (!subscription) {
            return res.status(404).json({ error: 'Subscription not found' });
        }
        
        subscription.status = 'cancelled';
        subscription.cancelledAt = new Date();
        subscription.cancellationReason = reason || 'Cancelled by admin';
        subscription.updatedAt = new Date();
        
        await subscription.save();
        
        // تحديث صلاحيات المستخدم (تعطيل)
        await updateUserPermissions(subscription.userId, null);
        
        res.json({ success: true });
    } catch (error) {
        console.error('Error cancelling subscription:', error);
        res.status(500).json({ error: 'Failed to cancel subscription' });
    }
});

// ========== 5. إحصائيات الاشتراكات (Admin Dashboard) ==========

// GET /api/admin/subscription/stats - إحصائيات الاشتراكات
app.get('/api/admin/subscription/stats', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        // إحصائيات عامة
        const totalSubscriptions = await UserSubscription.countDocuments();
        const activeSubscriptions = await UserSubscription.countDocuments({ status: 'active' });
        const pendingSubscriptions = await UserSubscription.countDocuments({ status: 'pending' });
        const expiredSubscriptions = await UserSubscription.countDocuments({ status: 'expired' });
        const cancelledSubscriptions = await UserSubscription.countDocuments({ status: 'cancelled' });
        
        // إحصائيات الإيرادات
        const earnings = await SubscriptionEarnings.aggregate([
            { $match: { status: 'completed' } },
            { $group: { _id: null, total: { $sum: '$amount' } } }
        ]);
        
        const monthlyEarnings = await SubscriptionEarnings.aggregate([
            { $match: { status: 'completed' } },
            { $group: {
                _id: { $dateToString: { format: '%Y-%m', date: '$createdAt' } },
                total: { $sum: '$amount' },
                count: { $sum: 1 }
            }},
            { $sort: { _id: -1 } },
            { $limit: 12 }
        ]);
        
        // أكثر الخطط مبيعاً
        const topPlans = await UserSubscription.aggregate([
            { $match: { status: 'active' } },
            { $group: { _id: '$planId', count: { $sum: 1 } } },
            { $sort: { count: -1 } },
            { $limit: 5 }
        ]);
        
        // جلب تفاصيل الخطط
        for (const plan of topPlans) {
            const planDetails = await SubscriptionPlan.findById(plan._id);
            if (planDetails) {
                plan.name = planDetails.name;
                plan.price = planDetails.price;
            }
        }
        
        // الاشتراكات التي تنتظر المراجعة
        const pendingList = await UserSubscription.find({ status: 'pending' })
            .populate('userId', 'username email')
            .populate('planId')
            .limit(10);
        
        res.json({
            success: true,
            stats: {
                total: totalSubscriptions,
                active: activeSubscriptions,
                pending: pendingSubscriptions,
                expired: expiredSubscriptions,
                cancelled: cancelledSubscriptions,
                totalRevenue: earnings[0]?.total || 0,
                monthlyEarnings: monthlyEarnings.reverse()
            },
            topPlans,
            pendingSubscriptionsList: pendingList
        });
    } catch (error) {
        console.error('Error fetching subscription stats:', error);
        res.status(500).json({ error: 'Failed to fetch stats' });
    }
});

// ============================================
// MISSING API ENDPOINTS
// ============================================



// GET /api/subscription/settings - جلب إعدادات الاشتراكات
app.get('/api/subscription/settings', authenticateToken, async (req, res) => {
    try {
        let settings = await SubscriptionSettings.findOne();
        if (!settings) {
            settings = new SubscriptionSettings();
            await settings.save();
        }
        res.json({ success: true, settings });
    } catch (error) {
        res.status(500).json({ error: 'Failed to fetch subscription settings' });
    }
});

// PUT /api/subscription/settings - تحديث إعدادات الاشتراكات
app.put('/api/subscription/settings', authenticateToken, async (req, res) => {
    try {
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const settings = await SubscriptionSettings.findOneAndUpdate(
            {},
            req.body,
            { upsert: true, new: true }
        );
        
        res.json({ success: true, settings });
    } catch (error) {
        res.status(500).json({ error: 'Failed to save subscription settings' });
    }
});

// ============================================
// GET /api/subscription/check - التحقق من صلاحية الاشتراك
// ============================================
app.get('/api/subscription/check', authenticateToken, async (req, res) => {
    try {
        const subscription = await UserSubscription.findOne({
            userId: req.user.userId,
            status: 'active'
        }).populate('planId');
        
        if (!subscription) {
            return res.json({ 
                success: true, 
                hasActiveSubscription: false,
                canCreateStore: false,
                message: 'No active subscription'
            });
        }
        
        const plan = subscription.planId;
        const now = new Date();
        const isExpired = subscription.endDate && new Date(subscription.endDate) < now;
        
        if (isExpired) {
            subscription.status = 'expired';
            await subscription.save();
            return res.json({ 
                success: true, 
                hasActiveSubscription: false,
                isExpired: true,
                canCreateStore: false,
                message: 'Subscription expired'
            });
        }
        
        const canCreateStore = plan?.features?.storeEnabled === true;
        const daysLeft = Math.ceil((new Date(subscription.endDate) - now) / (1000 * 60 * 60 * 24));
        
        res.json({ 
            success: true, 
            hasActiveSubscription: true,
            isTrial: subscription.isTrial || false,
            trialEndDate: subscription.trialEndDate,
            plan: {
                id: plan._id,
                name: plan.name,
                features: plan.features,
                price: plan.price,
                currencySymbol: plan.currencySymbol || '$'
            },
            canCreateStore,
            endDate: subscription.endDate,
            daysLeft: daysLeft > 0 ? daysLeft : 0,
            autoRenew: subscription.autoRenew || false
        });
        
    } catch (error) {
        console.error('Error checking subscription:', error);
        res.status(500).json({ error: 'Failed to check subscription' });
    }
});
// ============================================
// POST /api/subscription/renew - تجديد الاشتراك
// ============================================
app.post('/api/subscription/renew', authenticateToken, upload.single('paymentProof'), async (req, res) => {
    try {
        const { planId, paymentMethodId, paymentDetails } = req.body;
        
        // العثور على الاشتراك المنتهي أو الملغي
        const oldSubscription = await UserSubscription.findOne({
            userId: req.user.userId,
            status: { $in: ['expired', 'cancelled'] }
        }).sort({ createdAt: -1 });
        
        const plan = await SubscriptionPlan.findById(planId);
        if (!plan || !plan.isActive) {
            return res.status(404).json({ error: 'Plan not found' });
        }
        
        const paymentMethod = await PlatformPaymentMethod.findById(paymentMethodId);
        if (!paymentMethod || !paymentMethod.isActive) {
            return res.status(404).json({ error: 'Payment method not found' });
        }
        
        let paymentProofUrl = null;
        let paymentProofPublicId = null;
        if (req.file) {
            paymentProofUrl = req.file.path;
            paymentProofPublicId = req.file.filename;
        }
        
        const startDate = new Date();
        const endDate = new Date();
        endDate.setDate(endDate.getDate() + plan.durationDays);
        
        const newSubscription = new UserSubscription({
            userId: req.user.userId,
            planId,
            status: plan.price === 0 ? 'active' : 'pending',
            startDate,
            endDate,
            isTrial: false,
            paymentMethod: paymentMethod.name,
            paymentDetails: paymentDetails ? JSON.parse(paymentDetails) : {},
            paymentProof: paymentProofUrl,
            paymentProofPublicId,
            amount: plan.price,
            currency: plan.currency,
            autoRenew: false,
            createdAt: new Date()
        });
        
        await newSubscription.save();
        
        // إذا كان السعر 0 (مجاني) فعّل مباشرة
        if (plan.price === 0) {
            await updateUserPermissions(req.user.userId, plan);
        }
        
        // إشعار للإدارة إذا كان مدفوع
        if (plan.price > 0) {
            const adminUsers = await User.find({ isAdmin: true });
            for (const admin of adminUsers) {
                const notification = new Notification({
                    userId: admin._id,
                    type: 'subscription_renewal',
                    actorId: req.user.userId,
                    actorName: req.user.username,
                    content: `Subscription renewal request from ${req.user.username} for plan ${plan.name}`,
                    targetId: `/admin/subscriptions/${newSubscription._id}`,
                    targetType: 'subscription',
                    read: false
                });
                await notification.save();
            }
        }
        
        res.json({ 
            success: true, 
            subscription: newSubscription,
            message: plan.price === 0 ? 'Subscription renewed successfully!' : 'Renewal request submitted for approval'
        });
        
    } catch (error) {
        console.error('Error renewing subscription:', error);
        res.status(500).json({ error: 'Failed to renew subscription' });
    }
});

// ============================================
// POST /api/subscription/cancel - إلغاء اشتراك المستخدم
// ============================================
app.post('/api/subscription/cancel', authenticateToken, async (req, res) => {
    try {
        const { reason } = req.body;
        
        // العثور على الاشتراك النشط
        const subscription = await UserSubscription.findOne({
            userId: req.user.userId,
            status: 'active'
        }).populate('planId');
        
        if (!subscription) {
            return res.status(404).json({ 
                success: false,
                error: 'No active subscription found' 
            });
        }
        
        // تحديث حالة الاشتراك
        subscription.status = 'cancelled';
        subscription.cancelledAt = new Date();
        subscription.cancellationReason = reason || 'Cancelled by user';
        subscription.autoRenew = false;
        subscription.updatedAt = new Date();
        await subscription.save();
        
        // تعطيل صلاحيات المتجر (إذا كان لديه متجر)
        await User.findByIdAndUpdate(req.user.userId, {
            'profile.storeEnabled': false
        });
        
        // إشعار للمستخدم
        const notification = new Notification({
            userId: req.user.userId,
            type: 'subscription_cancelled',
            content: `Your subscription to "${subscription.planId.name}" has been cancelled. You will retain access until ${new Date(subscription.endDate).toLocaleDateString()}.`,
            targetId: `/subscription`,
            targetType: 'subscription',
            read: false
        });
        await notification.save();
        
        // إرسال إيميل
        const user = await User.findById(req.user.userId);
        const emailHtml = `
            <h2>Subscription Cancelled</h2>
            <p>Dear ${user.username},</p>
            <p>Your subscription to "${subscription.planId.name}" has been cancelled.</p>
            <p><strong>Access valid until:</strong> ${new Date(subscription.endDate).toLocaleDateString()}</p>
            <p>You can resubscribe at any time from your account settings.</p>
            <a href="${FRONTEND_URL}/subscription.html">View Plans →</a>
        `;
        await sendStoreEmailWithBrevo(user.email, 'Subscription Cancelled', emailHtml, '');
        
        res.json({ 
            success: true, 
            message: 'Subscription cancelled successfully',
            endDate: subscription.endDate
        });
        
    } catch (error) {
        console.error('Error cancelling subscription:', error);
        res.status(500).json({ error: 'Failed to cancel subscription' });
    }
});


// ============================================
// GET /api/visual-builder/sections - جلب جميع الأقسام (للمحرر البصري)
// ============================================
app.get('/api/visual-builder/sections', authenticateToken, async (req, res) => {
    try {
        const storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        
        const sections = storeSettings?.pageBuilder?.sections || [
            { id: 'hero', type: 'hero', enabled: true, order: 1, content: { title: 'Welcome to my store', subtitle: '', buttonText: 'Shop Now', buttonLink: '#products' } },
            { id: 'products', type: 'products', enabled: true, order: 2, title: 'All Products', limit: 12, layout: 'grid' },
            { id: 'categories', type: 'categories', enabled: true, order: 3, title: 'Categories' }
        ];
        
        res.json({ success: true, sections });
    } catch (error) {
        console.error('Error fetching sections:', error);
        res.status(500).json({ error: 'Failed to fetch sections' });
    }
});

// ============================================
// PUT /api/visual-builder/sections - حفظ جميع الأقسام (بعد الترتيب)
// ============================================
app.put('/api/visual-builder/sections', authenticateToken, async (req, res) => {
    try {
        const { sections } = req.body;
        
        if (!sections || !Array.isArray(sections)) {
            return res.status(400).json({ error: 'Invalid sections data' });
        }
        
        // تحديث ترتيب الأقسام
        const updatedSections = sections.map((section, index) => ({
            ...section,
            order: index + 1,
            updatedAt: new Date()
        }));
        
        await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { 
                $set: { 'pageBuilder.sections': updatedSections },
                updatedAt: new Date()
            },
            { upsert: true }
        );
        
        res.json({ success: true, sections: updatedSections });
    } catch (error) {
        console.error('Error saving sections:', error);
        res.status(500).json({ error: 'Failed to save sections' });
    }
});

// ============================================
// POST /api/visual-builder/section - إضافة قسم جديد
// ============================================
app.post('/api/visual-builder/section', authenticateToken, async (req, res) => {
    try {
        const { type, content, title, settings } = req.body;
        
        const storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        const currentSections = storeSettings?.pageBuilder?.sections || [];
        
        const newSection = {
            id: `${type}_${Date.now()}`,
            type: type,
            enabled: true,
            order: currentSections.length + 1,
            title: title || null,
            content: content || {},
            settings: settings || {},
            createdAt: new Date()
        };
        
        currentSections.push(newSection);
        
        await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { 
                $set: { 'pageBuilder.sections': currentSections },
                updatedAt: new Date()
            },
            { upsert: true }
        );
        
        res.json({ success: true, section: newSection });
    } catch (error) {
        console.error('Error adding section:', error);
        res.status(500).json({ error: 'Failed to add section' });
    }
});

// ============================================
// PUT /api/visual-builder/section/:sectionId - تحديث قسم
// ============================================
app.put('/api/visual-builder/section/:sectionId', authenticateToken, async (req, res) => {
    try {
        const { sectionId } = req.params;
        const { content, title, enabled, settings } = req.body;
        
        const storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        const currentSections = storeSettings?.pageBuilder?.sections || [];
        
        const sectionIndex = currentSections.findIndex(s => s.id === sectionId);
        if (sectionIndex === -1) {
            return res.status(404).json({ error: 'Section not found' });
        }
        
        // تحديث القسم
        if (content !== undefined) currentSections[sectionIndex].content = content;
        if (title !== undefined) currentSections[sectionIndex].title = title;
        if (enabled !== undefined) currentSections[sectionIndex].enabled = enabled;
        if (settings !== undefined) currentSections[sectionIndex].settings = settings;
        currentSections[sectionIndex].updatedAt = new Date();
        
        await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { 
                $set: { 'pageBuilder.sections': currentSections },
                updatedAt: new Date()
            }
        );
        
        res.json({ success: true, section: currentSections[sectionIndex] });
    } catch (error) {
        console.error('Error updating section:', error);
        res.status(500).json({ error: 'Failed to update section' });
    }
});

// ============================================
// DELETE /api/visual-builder/section/:sectionId - حذف قسم
// ============================================
app.delete('/api/visual-builder/section/:sectionId', authenticateToken, async (req, res) => {
    try {
        const { sectionId } = req.params;
        
        const storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        const currentSections = storeSettings?.pageBuilder?.sections || [];
        
        const filteredSections = currentSections.filter(s => s.id !== sectionId);
        
        // إعادة ترتيب الأقسام
        const reorderedSections = filteredSections.map((section, index) => ({
            ...section,
            order: index + 1
        }));
        
        await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { 
                $set: { 'pageBuilder.sections': reorderedSections },
                updatedAt: new Date()
            }
        );
        
        res.json({ success: true });
    } catch (error) {
        console.error('Error deleting section:', error);
        res.status(500).json({ error: 'Failed to delete section' });
    }
});

// ============================================
// GET /api/visual-builder/section-types - جلب أنواع الأقسام المتاحة
// ============================================
app.get('/api/visual-builder/section-types', authenticateToken, async (req, res) => {
    const sectionTypes = [
        {
            type: 'hero',
            name: 'Hero Section',
            icon: 'bx-home',
            color: 'blue',
            description: 'Large banner with title, subtitle, and CTA button',
            defaultContent: {
                title: 'Welcome to my store',
                subtitle: '',
                buttonText: 'Shop Now',
                buttonLink: '#products'
            },
            settings: [
                { name: 'textColor', type: 'color', default: '#ffffff' },
                { name: 'overlayOpacity', type: 'range', min: 0, max: 1, step: 0.1, default: 0.4 }
            ]
        },
        {
            type: 'products',
            name: 'Products Grid',
            icon: 'bx-package',
            color: 'purple',
            description: 'Display products in a grid layout',
            defaultContent: {
                limit: 12,
                layout: 'grid',
                sort: 'newest',
                columns: 4
            },
            settings: [
                { name: 'showFilters', type: 'boolean', default: false },
                { name: 'showSort', type: 'boolean', default: true }
            ]
        },
        {
            type: 'featured',
            name: 'Featured Products',
            icon: 'bx-star',
            color: 'green',
            description: 'Showcase your best-selling products',
            defaultContent: {
                limit: 6,
                title: 'Featured Products'
            }
        },
        {
            type: 'categories',
            name: 'Categories',
            icon: 'bx-category',
            color: 'orange',
            description: 'Display product categories',
            defaultContent: {
                layout: 'grid',
                showCount: true
            }
        },
        {
            type: 'testimonials',
            name: 'Testimonials',
            icon: 'bx-chat',
            color: 'pink',
            description: 'Customer reviews and testimonials',
            defaultContent: {
                limit: 4,
                autoplay: false,
                title: 'What Our Customers Say'
            }
        },
        {
            type: 'faq',
            name: 'FAQ Section',
            icon: 'bx-question-mark',
            color: 'yellow',
            description: 'Frequently asked questions',
            defaultContent: {
                items: [
                    { question: 'Question 1?', answer: 'Answer 1' },
                    { question: 'Question 2?', answer: 'Answer 2' }
                ],
                title: 'Frequently Asked Questions'
            }
        },
        {
            type: 'contact',
            name: 'Contact Form',
            icon: 'bx-envelope',
            color: 'indigo',
            description: 'Contact form for customer inquiries',
            defaultContent: {
                email: '',
                phone: '',
                title: 'Contact Us'
            }
        },
        {
            type: 'html',
            name: 'Custom HTML',
            icon: 'bx-code-alt',
            color: 'gray',
            description: 'Custom HTML content',
            defaultContent: {
                html: '<div class="custom-content"><h2>Your Custom Content</h2><p>Edit this HTML</p></div>'
            }
        },
        {
            type: 'products_grid',
            name: 'Custom Products Grid',
            icon: 'bx-grid-alt',
            color: 'teal',
            description: 'Customizable products grid with filters',
            defaultContent: {
                limit: 8,
                columns: 4,
                type: 'all',
                sort: 'newest',
                showFilters: true,
                title: 'Products'
            }
        }
    ];
    
    res.json({ success: true, sectionTypes });
});

// ============================================
// POST /api/visual-builder/preview - معاينة القسم قبل الإضافة
// ============================================
app.post('/api/visual-builder/preview', authenticateToken, async (req, res) => {
    try {
        const { type, content, settings } = req.body;
        
        // توليد HTML للمعاينة
        let previewHtml = '';
        
        switch (type) {
            case 'hero':
                previewHtml = `
                    <div class="bg-gradient-to-r from-purple-500 to-pink-500 text-white p-8 rounded-xl text-center">
                        <h2 class="text-2xl font-bold">${content?.title || 'Welcome'}</h2>
                        <p class="mt-2">${content?.subtitle || 'Your subtitle here'}</p>
                        <button class="mt-4 px-4 py-2 bg-white rounded-lg text-purple-600">${content?.buttonText || 'Shop Now'}</button>
                    </div>
                `;
                break;
            case 'products':
                previewHtml = `
                    <div class="border-2 border-dashed border-gray-300 rounded-xl p-4 text-center">
                        <i class='bx bx-package text-4xl text-gray-400'></i>
                        <p class="mt-2 text-gray-500">Products Grid: ${content?.limit || 12} products, ${content?.layout || 'grid'} layout</p>
                        <div class="grid grid-cols-4 gap-2 mt-3">
                            ${Array(4).fill().map(() => `<div class="h-20 bg-gray-100 rounded"></div>`).join('')}
                        </div>
                    </div>
                `;
                break;
            case 'html':
                previewHtml = content?.html || '<div class="p-4 bg-gray-100 rounded">Custom HTML Content</div>';
                break;
            default:
                previewHtml = `<div class="p-4 bg-gray-100 rounded text-center">${type} section preview</div>`;
        }
        
        res.json({ success: true, previewHtml });
    } catch (error) {
        console.error('Error generating preview:', error);
        res.status(500).json({ error: 'Failed to generate preview' });
    }
});

// ============================================
// POST /api/visual-builder/duplicate/:sectionId - نسخ قسم
// ============================================
app.post('/api/visual-builder/duplicate/:sectionId', authenticateToken, async (req, res) => {
    try {
        const { sectionId } = req.params;
        
        const storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        const currentSections = storeSettings?.pageBuilder?.sections || [];
        
        const originalSection = currentSections.find(s => s.id === sectionId);
        if (!originalSection) {
            return res.status(404).json({ error: 'Section not found' });
        }
        
        const duplicatedSection = {
            ...JSON.parse(JSON.stringify(originalSection)),
            id: `${originalSection.type}_${Date.now()}`,
            order: currentSections.length + 1,
            title: `${originalSection.title || originalSection.type} (Copy)`
        };
        
        currentSections.push(duplicatedSection);
        
        await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { $set: { 'pageBuilder.sections': currentSections } }
        );
        
        res.json({ success: true, section: duplicatedSection });
    } catch (error) {
        console.error('Error duplicating section:', error);
        res.status(500).json({ error: 'Failed to duplicate section' });
    }
});




// ============================================
// POST /api/ai/generate-layout - توليد تخطيط صفحة
// ============================================
app.post('/api/ai/generate-layout', authenticateToken, async (req, res) => {
    try {
        const { description, storeType } = req.body;
        
        if (!description) {
            return res.status(400).json({ error: 'Description is required' });
        }
        
        const result = await aiService.generatePageLayout(description, storeType || 'general');
        
        res.json(result);
    } catch (error) {
        console.error('AI layout generation error:', error);
        res.status(500).json({ error: 'Failed to generate layout' });
    }
});

// ============================================
// POST /api/ai/generate-shortcode - توليد Shortcode
// ============================================
app.post('/api/ai/generate-shortcode', authenticateToken, async (req, res) => {
    try {
        const { description } = req.body;
        
        if (!description) {
            return res.status(400).json({ error: 'Description is required' });
        }
        
        const result = await aiService.generateShortcode(description);
        
        res.json(result);
    } catch (error) {
        console.error('AI shortcode generation error:', error);
        res.status(500).json({ error: 'Failed to generate shortcode' });
    }
});

// ============================================
// POST /api/ai/suggest-design - اقتراح تصميم
// ============================================
app.post('/api/ai/suggest-design', authenticateToken, async (req, res) => {
    try {
        const { storeType } = req.body;
        
        const design = aiService.suggestDesign(storeType || 'general');
        
        res.json({
            success: true,
            design
        });
    } catch (error) {
        console.error('AI design suggestion error:', error);
        res.status(500).json({ error: 'Failed to suggest design' });
    }
});

// ============================================
// POST /api/ai/enhance-description - تحسين وصف المنتج
// ============================================
app.post('/api/ai/enhance-description', authenticateToken, async (req, res) => {
    try {
        const { title, description, tags } = req.body;
        
        if (!title) {
            return res.status(400).json({ error: 'Title is required' });
        }
        
        const result = await aiService.enhanceProductDescription(title, description, tags);
        
        res.json(result);
    } catch (error) {
        console.error('AI description enhancement error:', error);
        res.status(500).json({ error: 'Failed to enhance description' });
    }
});

// ============================================
// POST /api/ai/suggest-keywords - اقتراح كلمات مفتاحية
// ============================================
app.post('/api/ai/suggest-keywords', authenticateToken, async (req, res) => {
    try {
        const { title, category, storeType } = req.body;
        
        if (!title) {
            return res.status(400).json({ error: 'Title is required' });
        }
        
        const result = await aiService.suggestKeywords(title, category, storeType);
        
        res.json(result);
    } catch (error) {
        console.error('AI keyword suggestion error:', error);
        res.status(500).json({ error: 'Failed to suggest keywords' });
    }
});

// ============================================
// POST /api/ai/generate-store-description - توليد وصف للمتجر
// ============================================
app.post('/api/ai/generate-store-description', authenticateToken, async (req, res) => {
    try {
        const { storeName, industry, products } = req.body;
        
        if (!storeName) {
            return res.status(400).json({ error: 'Store name is required' });
        }
        
        const result = await aiService.generateStoreDescription(
            storeName,
            industry || 'general',
            products || []
        );
        
        res.json(result);
    } catch (error) {
        console.error('AI store description generation error:', error);
        res.status(500).json({ error: 'Failed to generate store description' });
    }
});

// ============================================
// POST /api/ai/clear-cache - مسح التخزين المؤقت (للإدارة فقط)
// ============================================
app.post('/api/ai/clear-cache', authenticateToken, async (req, res) => {
    try {
        // التحقق من صلاحيات الأدمن
        const isAdmin = req.user.role === 'admin';
        if (!isAdmin) {
            return res.status(403).json({ error: 'Forbidden' });
        }
        
        aiService.clearCache();
        
        res.json({ success: true, message: 'AI cache cleared' });
    } catch (error) {
        console.error('Error clearing AI cache:', error);
        res.status(500).json({ error: 'Failed to clear cache' });
    }
});

// ============================================
// POST /api/ai/generate-template - توليد قالب كامل
// ============================================
app.post('/api/ai/generate-template', authenticateToken, async (req, res) => {
    try {
        const { description, style } = req.body;
        
        if (!description) {
            return res.status(400).json({ error: 'Description is required' });
        }
        
        const result = await aiService.generateCompleteTemplate(description, style || 'modern');
        
        res.json(result);
    } catch (error) {
        console.error('AI template generation error:', error);
        res.status(500).json({ error: 'Failed to generate template' });
    }
});

// ============================================
// GET /api/ai/admin/stats - إحصائيات استخدام النماذج (للمشرفين فقط)
// ============================================
app.get('/api/ai/admin/stats', authenticateToken, async (req, res) => {
    try {
        // التحقق من صلاحيات المشرف
        const user = await User.findById(req.user.userId);
        if (!user || !user.isAdmin) {
            return res.status(403).json({ error: 'Forbidden - Admin access required' });
        }
        
        res.json({
            success: true,
            modelStats: aiService.modelStats,
            models: {
                fast: aiService.models.fast,
                precise: aiService.models.precise
            },
            cacheSize: aiService.cache.size
        });
    } catch (error) {
        console.error('Error getting AI stats:', error);
        res.status(500).json({ error: 'Failed to get stats' });
    }
});

// ============================================
// POST /api/ai/clear-cache - مسح التخزين المؤقت (للمشرفين فقط)
// ============================================
app.post('/api/ai/admin/clear-cache', authenticateToken, async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user || !user.isAdmin) {
            return res.status(403).json({ error: 'Forbidden - Admin access required' });
        }
        
        aiService.clearCache();
        
        res.json({
            success: true,
            message: 'AI cache cleared successfully'
        });
    } catch (error) {
        console.error('Error clearing AI cache:', error);
        res.status(500).json({ error: 'Failed to clear cache' });
    }
});



// ============================================
// 🐛 DEBUG: GET /api/templates/debug/:id - تصحيح أخطاء القالب
// ============================================
app.get('/api/templates/debug/:id', async (req, res) => {
    try {
        let template;
        
        if (req.params.id.match(/^[0-9a-fA-F]{24}$/)) {
            template = await TemplateStore.findById(req.params.id);
        } else {
            template = await TemplateStore.findOne({ slug: req.params.id });
        }
        
        if (!template) {
            return res.status(404).json({ error: 'Template not found' });
        }
        
        // ✅ إرجاع معلومات التصحيح
        res.json({
            success: true,
            debug: {
                id: template._id,
                slug: template.slug,
                name: template.name,
                hasThemeData: !!template.themeData,
                templateUrl: template.themeData?.templateUrl || null,
                hasUploadedFiles: !!template.themeData?.uploadedFiles,
                htmlFilesCount: template.themeData?.uploadedFiles?.htmlFiles?.length || 0,
                htmlFiles: template.themeData?.uploadedFiles?.htmlFiles?.map(f => ({
                    name: f.name,
                    url: f.url?.substring(0, 100)
                })),
                cssFilesCount: template.themeData?.uploadedFiles?.cssFiles?.length || 0,
                jsFilesCount: template.themeData?.uploadedFiles?.jsFiles?.length || 0,
                imageFilesCount: template.themeData?.uploadedFiles?.imageFiles?.length || 0
            }
        });
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// ============================================
// GET /api/templates - جلب جميع القوالب
// ============================================
app.get('/api/templates', async (req, res) => {
    try {
        const { category, sort, limit = 20, offset = 0, search } = req.query;
        
        const filters = {
            category: category || 'all',
            sort: sort || 'popular',
            limit: parseInt(limit),
            offset: parseInt(offset)
        };
        
        let templates;
        if (search) {
            templates = await TemplateStore.searchTemplates(search, filters);
        } else {
            const query = { isActive: true };
            if (category && category !== 'all') {
                query.category = category;
            }
            
            let sortOption = {};
            switch (sort) {
                case 'popular': sortOption = { downloadsCount: -1 }; break;
                case 'rating': sortOption = { rating: -1 }; break;
                case 'newest': sortOption = { createdAt: -1 }; break;
                default: sortOption = { downloadsCount: -1 };
            }
            
            templates = await TemplateStore.find(query)
                .sort(sortOption)
                .limit(filters.limit)
                .skip(filters.offset);
        }
        
        const total = await TemplateStore.countDocuments({ isActive: true });
        
        res.json({
            success: true,
            templates,
            pagination: {
                total,
                limit: filters.limit,
                offset: filters.offset,
                hasMore: filters.offset + filters.limit < total
            }
        });
    } catch (error) {
        console.error('Error fetching templates:', error);
        res.status(500).json({ error: 'Failed to fetch templates' });
    }
});

// ============================================
// GET /api/templates/featured - جلب القوالب المميزة
// ============================================
app.get('/api/templates/featured', async (req, res) => {
    try {
        const limit = parseInt(req.query.limit) || 6;
        const templates = await TemplateStore.getFeatured(limit);
        
        res.json({ success: true, templates });
    } catch (error) {
        console.error('Error fetching featured templates:', error);
        res.status(500).json({ error: 'Failed to fetch featured templates' });
    }
});

// ============================================
// GET /api/templates/popular - جلب القوالب الأكثر تحميلاً
// ============================================
app.get('/api/templates/popular', async (req, res) => {
    try {
        const limit = parseInt(req.query.limit) || 12;
        const templates = await TemplateStore.getMostDownloaded(limit);
        
        res.json({ success: true, templates });
    } catch (error) {
        console.error('Error fetching popular templates:', error);
        res.status(500).json({ error: 'Failed to fetch popular templates' });
    }
});

// ============================================
// GET /api/templates/categories - جلب التصنيفات مع عدد القوالب
// ============================================
app.get('/api/templates/categories', async (req, res) => {
    try {
        const categories = await TemplateStore.aggregate([
            { $match: { isActive: true } },
            { $group: { _id: '$category', count: { $sum: 1 } } },
            { $sort: { count: -1 } }
        ]);
        
        res.json({ success: true, categories });
    } catch (error) {
        console.error('Error fetching categories:', error);
        res.status(500).json({ error: 'Failed to fetch categories' });
    }
});

// ============================================
// GET /api/templates/:id - جلب تفاصيل قالب (محدث)
// ============================================
app.get('/api/templates/:id', async (req, res) => {
    try {
        let template;
        
        if (req.params.id.match(/^[0-9a-fA-F]{24}$/)) {
            template = await TemplateStore.findById(req.params.id);
        } else {
            template = await TemplateStore.findOne({ slug: req.params.id });
        }
        
        if (!template) {
            return res.status(404).json({ error: 'Template not found' });
        }
        
        // زيادة عدد المشاهدات (غير متزامن)
        TemplateStore.incrementViews(template._id).catch(console.error);
        
        // ✅ إضافة templateUrl للرد (للمعاينة)
        let templateUrl = null;
        if (template.themeData?.templateUrl) {
            templateUrl = template.themeData.templateUrl;
        } else if (template.themeData?.uploadedFiles?.htmlFiles?.length > 0) {
            const indexFile = template.themeData.uploadedFiles.htmlFiles.find(f => 
                f.name === 'index.html' || f.name.endsWith('/index.html')
            );
            if (indexFile && indexFile.url) {
                templateUrl = indexFile.url;
            }
        }
        
        // جلب قوالب مشابهة
        const similar = await TemplateStore.find({
            isActive: true,
            category: template.category,
            _id: { $ne: template._id }
        }).limit(4);
        
        res.json({
            success: true,
            template: {
                ...template.toObject(),
                templateUrl: templateUrl  // ✅ أضف هذا
            },
            similar
        });
    } catch (error) {
        console.error('Error fetching template:', error);
        res.status(500).json({ error: 'Failed to fetch template' });
    }
});


// ============================================
// POST /api/templates/:id/preview - معاينة قالب (بدون تثبيت)
// ============================================
app.post('/api/templates/:id/preview', async (req, res) => {
    try {
        let template;
        
        if (req.params.id.match(/^[0-9a-fA-F]{24}$/)) {
            template = await TemplateStore.findById(req.params.id);
        } else {
            template = await TemplateStore.findOne({ slug: req.params.id });
        }
        
        if (!template) {
            return res.status(404).json({ error: 'Template not found' });
        }
        
        // إرجاع بيانات القالب للمعاينة
        res.json({
            success: true,
            previewData: {
                name: template.name,
                themeData: template.themeData,
                previewImages: template.previewImages,
                demoUrl: template.demoUrl
            }
        });
    } catch (error) {
        console.error('Error previewing template:', error);
        res.status(500).json({ error: 'Failed to preview template' });
    }
});

// ============================================
// ============================================
// POST /api/templates/:id/apply - تطبيق قالب كامل (نسخة نهائية متكاملة مع Cloudinary)
// ============================================
app.post('/api/templates/:id/apply', authenticateToken, async (req, res) => {
    try {
        let template;
        
        if (req.params.id.match(/^[0-9a-fA-F]{24}$/)) {
            template = await TemplateStore.findById(req.params.id);
        } else {
            template = await TemplateStore.findOne({ slug: req.params.id });
        }
        
        if (!template) {
            return res.status(404).json({ error: 'Template not found' });
        }
        
        const userId = req.user.userId;
        const themeData = template.themeData || {};
        const colors = themeData.colors || {};
        const typography = themeData.typography || {};
        const layout = themeData.layout || {};
        
        // ============================================
        // 1. البحث عن رابط القالب (index.html)
        // ============================================
        let templateUrl = null;
        let hasFullTemplate = false;
        
        // من themeData.templateUrl
        if (themeData.templateUrl) {
            templateUrl = themeData.templateUrl;
            hasFullTemplate = true;
            console.log(`✅ Template URL from Cloudinary: ${templateUrl}`);
        }
        
        // من uploadedFiles
        if (!templateUrl && themeData.uploadedFiles?.htmlFiles) {
            const indexFile = themeData.uploadedFiles.htmlFiles.find(f => 
                f.name === 'index.html' || f.name.endsWith('/index.html')
            );
            if (indexFile && indexFile.url) {
                templateUrl = indexFile.url;
                hasFullTemplate = true;
                console.log(`✅ Found index.html in uploadedFiles: ${templateUrl}`);
            }
        }
        
        // ============================================
        // 2. تحديث StoreSettings
        // ============================================
        let storeSettings = await StoreSettings.findOne({ userId });
        
        const updateData = {
            primaryColor: colors.primary || '#3b82f6',
            secondaryColor: colors.secondary || '#8b5cf6',
            colorPalette: {
                primaryHover: adjustColor(colors.primary || '#3b82f6', -20),
                secondaryHover: adjustColor(colors.secondary || '#8b5cf6', -20),
                buttonText: '#ffffff',
                linkColor: colors.primary || '#3b82f6',
                linkHover: adjustColor(colors.primary || '#3b82f6', -20),
                headingColor: colors.text || '#1f2937',
                bodyColor: '#374151',
                borderColor: '#e5e7eb',
                successColor: '#10b981',
                errorColor: '#ef4444',
                warningColor: '#f59e0b'
            },
            fontFamily: typography.fontFamily || 'Inter, sans-serif',
            typography: {
                headingFont: typography.headingFont || typography.fontFamily || 'Inter, sans-serif',
                baseFontSize: typography.baseFontSize || '16px',
                enableGoogleFonts: typography.enableGoogleFonts !== false
            },
            borderRadius: themeData.borderRadius || 16,
            shadowType: themeData.shadowType || layout.shadowType || 'md',
            animationType: themeData.animationType || 'lift',
            glassEffect: themeData.glassEffect || false,
            backgroundType: themeData.backgroundType || 'default',
            backgroundValue: themeData.backgroundValue || '',
            customCss: themeData.customCss || '',
            productViewType: themeData.productsSettings?.productViewType || 'modal',
            autoApproveReviews: themeData.productsSettings?.autoApproveReviews || false,
            layoutSettings: {
                headerLayout: layout.headerLayout || 'default',
                footerLayout: layout.footerLayout || 'default',
                sidebarPosition: layout.sidebarPosition || 'none',
                productsPerRowMobile: layout.productsPerRowMobile || 2,
                productsPerRowTablet: layout.productsPerRowTablet || 3,
                productsPerRowDesktop: layout.columns || themeData.productsSettings?.productsPerRow || 4,
                enableStickyAddToCart: layout.enableStickyAddToCart !== false,
                enableQuickView: themeData.productsSettings?.enableQuickView !== false,
                enableCompareProducts: layout.enableCompareProducts || false,
                enableWishlist: layout.enableWishlist || false,
                enableRecentlyViewed: layout.enableRecentlyViewed !== false,
                enableProductReviews: themeData.productsSettings?.enableProductReviews !== false
            },
            pageBuilder: { sections: themeData.sections || [] },
            appliedTemplate: {
                slug: template.slug,
                name: template.name,
                templateUrl: templateUrl,
                appliedAt: new Date(),
                hasFullTemplate: hasFullTemplate
            },
            // ✅ إضافة بيانات القالب الكامل للمساعدة في المعاينة
            themeData: {
                uploadedFiles: themeData.uploadedFiles,
                templateUrl: templateUrl
            },
            updatedAt: Date.now()
        };
        
        // معلومات المتجر
        if (themeData.storeInfo) {
            updateData.storeName = themeData.storeInfo.storeName || storeSettings?.storeName;
            updateData.storeLogo = themeData.storeInfo.storeLogo || storeSettings?.storeLogo;
            updateData.storeBanner = themeData.storeInfo.storeBanner || storeSettings?.storeBanner;
            updateData.storeDescription = themeData.storeInfo.storeDescription || storeSettings?.storeDescription;
            updateData.contactEmail = themeData.storeInfo.contactEmail || storeSettings?.contactEmail;
        }
        
        // العملة والدفع
        if (themeData.currency) {
            updateData.currency = themeData.currency;
            updateData.currencySymbol = getCurrencySymbol(themeData.currency);
        }
        if (themeData.paymentSettings) {
            updateData.paymentSettings = { ...storeSettings?.paymentSettings, ...themeData.paymentSettings };
        }
        
        // التواصل الاجتماعي
        if (themeData.socialLinks) {
            updateData.socialLinks = { ...storeSettings?.socialLinks, ...themeData.socialLinks };
        }
        
        // SEO
        if (themeData.seoSettings) {
            updateData.seoSettings = { ...storeSettings?.seoSettings, ...themeData.seoSettings };
        }
        
        // أكواد الخصم ومناطق الشحن
        if (themeData.storeCoupons) updateData.storeCoupons = themeData.storeCoupons;
        if (themeData.shippingZones) updateData.shippingZones = themeData.shippingZones;
        if (themeData.pagesOrder) updateData.pagesOrder = themeData.pagesOrder;
        if (themeData.performanceSettings) {
            updateData.performanceSettings = { ...storeSettings?.performanceSettings, ...themeData.performanceSettings };
        }
        
        storeSettings = await StoreSettings.findOneAndUpdate(
            { userId },
            updateData,
            { upsert: true, new: true }
        );
        
        // ============================================
        // 3. تحديث StoreTheme
        // ============================================
        let theme = await StoreTheme.findOne({ userId });
        if (!theme) theme = new StoreTheme({ userId });
        
        theme.name = template.name;
        theme.isActive = true;
        theme.version = template.version || '1.0.0';
        
        theme.colors = {
            primary: colors.primary || '#3b82f6',
            secondary: colors.secondary || '#8b5cf6',
            accent: colors.accent || '#f59e0b',
            background: colors.background || '#ffffff',
            text: colors.text || '#1f2937',
            textLight: colors.textLight || '#6b7280',
            border: colors.border || '#e5e7eb',
            success: colors.success || '#10b981',
            error: colors.error || '#ef4444',
            warning: colors.warning || '#f59e0b'
        };
        
        theme.typography = {
            fontFamily: typography.fontFamily || 'Inter, sans-serif',
            headingFont: typography.headingFont || typography.fontFamily || 'Inter, sans-serif',
            baseFontSize: typography.baseFontSize || '16px',
            enableGoogleFonts: typography.enableGoogleFonts !== false
        };
        
        theme.layout = layout.type || 'full-width';
        theme.settings = {
            containerWidth: layout.containerWidth || '1280px',
            containerPadding: layout.containerPadding || '20px',
            showBreadcrumb: layout.showBreadcrumb !== false,
            stickyHeader: layout.stickyHeader || false,
            backToTop: layout.backToTop !== false,
            showSearchBar: layout.showSearchBar !== false,
            showCategories: layout.showCategories !== false,
            productsPerRow: layout.columns || themeData.productsSettings?.productsPerRow || 4,
            productsPerPage: layout.productsPerPage || 12,
            enableLazyLoad: layout.enableLazyLoad !== false,
            enableAnimations: layout.enableAnimations !== false
        };
        
        if (themeData.customCss) theme.customAssets.css = themeData.customCss;
        if (themeData.customJs) theme.customAssets.js = themeData.customJs;
        
        if (themeData.customHeaderFooter) {
            theme.customTemplates = {
                ...theme.customTemplates,
                header: themeData.customHeaderFooter.header || '',
                footer: themeData.customHeaderFooter.footer || '',
                sidebar: themeData.customHeaderFooter.sidebar || '',
                productCard: themeData.customHeaderFooter.productCard || '',
                categoryCard: themeData.customHeaderFooter.categoryCard || ''
            };
            if (themeData.customHeaderFooter.css) theme.customAssets.css = themeData.customHeaderFooter.css;
            if (themeData.customHeaderFooter.js) theme.customAssets.js = themeData.customHeaderFooter.js;
        }
        
        if (templateUrl) {
            theme.uploadedTheme = {
                filename: `${template.slug}.zip`,
                fileUrl: templateUrl,
                extractedFiles: themeData.uploadedFiles || { 
                    htmlFiles: [], 
                    cssFiles: [], 
                    jsFiles: [], 
                    imageFiles: [],
                    fontFiles: []
                }
            };
        }
        
        await theme.save();
        
        // ============================================
        // 4. تحديث الصفحات (إذا وجدت)
        // ============================================
        if (themeData.pages && Array.isArray(themeData.pages)) {
            for (const pageData of themeData.pages) {
                await Page.findOneAndUpdate(
                    { storeId: userId, slug: pageData.slug },
                    {
                        title: pageData.title,
                        content: pageData.content || '',
                        css: pageData.css || '',
                        js: pageData.js || '',
                        seo: pageData.seo || {},
                        isEnabled: pageData.isEnabled !== false,
                        order: pageData.order || 0,
                        type: pageData.type || 'custom',
                        updatedAt: Date.now()
                    },
                    { upsert: true }
                );
            }
        }
        
        if (themeData.defaultPages) {
            for (const slug of ['about', 'contact']) {
                if (themeData.defaultPages[slug]) {
                    await Page.findOneAndUpdate(
                        { storeId: userId, slug: slug },
                        {
                            title: themeData.defaultPages[slug].title || (slug === 'about' ? 'About Us' : 'Contact Us'),
                            content: themeData.defaultPages[slug].content || '',
                            css: themeData.defaultPages[slug].css || '',
                            js: themeData.defaultPages[slug].js || '',
                            seo: themeData.defaultPages[slug].seo || {},
                            isEnabled: true,
                            type: 'default',
                            updatedAt: Date.now()
                        },
                        { upsert: true }
                    );
                }
            }
        }
        
        // ============================================
        // 5. تفعيل المتجر وتسجيل التحميل
        // ============================================
        await User.findByIdAndUpdate(userId, { 'profile.storeEnabled': true });
        await TemplateStore.recordDownload(template._id, userId, userId);
        
        // ============================================
        // 6. إرجاع الرد
        // ============================================
        res.json({
            success: true,
            message: `✅ Template "${template.name}" applied successfully! Your store has been completely updated.`,
            appliedSettings: {
                primaryColor: theme.colors.primary,
                secondaryColor: theme.colors.secondary,
                fontFamily: theme.typography.fontFamily,
                borderRadius: storeSettings.borderRadius,
                shadowType: storeSettings.shadowType,
                animationType: storeSettings.animationType,
                glassEffect: storeSettings.glassEffect,
                backgroundType: storeSettings.backgroundType,
                sectionsCount: themeData.sections?.length || 0,
                layout: theme.layout,
                productsPerRow: theme.settings.productsPerRow,
                hasCustomCss: !!theme.customAssets.css,
                hasCustomHeader: !!theme.customTemplates.header,
                hasFullTemplate: hasFullTemplate,
                templateUrl: templateUrl
            },
            needsRefresh: true,
            redirectUrl: `/shop/${req.user.username || userId}`
        });
        
        console.log(`✅ Template "${template.name}" applied for user ${userId}`);
        
    } catch (error) {
        console.error('Error applying template:', error);
        res.status(500).json({ 
            error: 'Failed to apply template: ' + error.message,
            details: process.env.NODE_ENV === 'development' ? error.stack : undefined
        });
    }
});


// ============================================
// GET /api/templates/serve/:slug - خدمة معاينة القالب (محدث - يعرض HTML مباشرة)
// ============================================
app.get('/api/templates/serve/:slug', async (req, res) => {
    try {
        const { slug } = req.params;
        const isPreview = req.query.preview === '1';
        
        const template = await TemplateStore.findOne({ slug });
        
        if (!template) {
            return res.status(404).send('Template not found');
        }
        
        // ✅ البحث عن رابط index.html
        let indexUrl = null;
        
        if (template.themeData?.templateUrl) {
            indexUrl = template.themeData.templateUrl;
        } else if (template.themeData?.uploadedFiles?.htmlFiles) {
            const indexFile = template.themeData.uploadedFiles.htmlFiles.find(f => 
                f.name === 'index.html' || f.name.endsWith('/index.html')
            );
            if (indexFile && indexFile.url) {
                indexUrl = indexFile.url;
            }
        }
        
        if (!indexUrl) {
            return res.status(404).send('Template preview not available');
        }
        
        if (isPreview) {
            try {
                // ✅ جلب محتوى HTML من Cloudinary
                const response = await axios.get(indexUrl, {
                    responseType: 'text',
                    headers: { 'Accept': 'text/html' }
                });
                
                let html = response.data;
                
                // ✅ استبدال مسارات الملفات النسبية بروابط Cloudinary الكاملة
                const uploadedFiles = template.themeData?.uploadedFiles;
                if (uploadedFiles) {
                    // إنشاء Map لجميع الملفات (اسم الملف -> الرابط)
                    const fileMap = new Map();
                    
                    [...(uploadedFiles.htmlFiles || []),
                     ...(uploadedFiles.cssFiles || []),
                     ...(uploadedFiles.jsFiles || []),
                     ...(uploadedFiles.imageFiles || []),
                     ...(uploadedFiles.fontFiles || [])
                    ].forEach(file => {
                        const filename = file.name.split('/').pop();
                        fileMap.set(filename, file.url);
                        fileMap.set(file.name, file.url);
                    });
                    
                    // استبدال المسارات في src و href
                    html = html.replace(/(src|href)=["']([^"']+)["']/g, (match, attr, url) => {
                        // تجاهل الروابط الخارجية
                        if (url.startsWith('http://') || url.startsWith('https://') || url.startsWith('//')) {
                            return match;
                        }
                        
                        const filename = url.split('/').pop();
                        if (fileMap.has(filename)) {
                            return `${attr}="${fileMap.get(filename)}"`;
                        }
                        if (fileMap.has(url)) {
                            return `${attr}="${fileMap.get(url)}"`;
                        }
                        return match;
                    });
                }
                
                // ✅ إضافة شريط المعاينة
                const previewBar = `
                    <div style="position: fixed; top: 0; left: 0; right: 0; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 10px 20px; text-align: center; font-size: 14px; z-index: 10000; display: flex; justify-content: space-between; align-items: center; box-shadow: 0 2px 10px rgba(0,0,0,0.2);">
                        <span>
                            <i class='bx bx-show-alt' style="margin-right: 8px;"></i> 
                            <strong>Preview Mode:</strong> ${template.name}
                        </span>
                        <div>
                            <button onclick="window.location.href='/template-store.html'" style="background: rgba(255,255,255,0.2); border: none; color: white; padding: 6px 14px; border-radius: 20px; cursor: pointer; margin-right: 10px; transition: all 0.2s;">
                                ← Back
                            </button>
                            <button onclick="applyTemplateAndClose()" style="background: white; border: none; color: #667eea; padding: 6px 20px; border-radius: 20px; cursor: pointer; font-weight: bold; transition: all 0.2s;">
                                ✨ Apply This Template
                            </button>
                        </div>
                    </div>
                    <div style="margin-top: 55px;">
                        ${html}
                    </div>
                    <script>
                        function applyTemplateAndClose() {
                            const templateId = '${template._id}';
                            const token = localStorage.getItem('userToken');
                            
                            if (!token) {
                                alert('Please login to apply templates');
                                window.location.href = '/login.html?redirect=/template-store.html';
                                return;
                            }
                            
                            if (confirm('⚠️ Apply this template? It will replace your current store design.')) {
                                fetch('/api/templates/' + templateId + '/apply', {
                                    method: 'POST',
                                    headers: {
                                        'Authorization': 'Bearer ' + token,
                                        'Content-Type': 'application/json'
                                    }
                                })
                                .then(res => res.json())
                                .then(data => {
                                    if (data.success) {
                                        alert('✅ Template applied successfully!');
                                        window.location.href = '/shop/me';
                                    } else {
                                        alert('❌ Failed to apply template: ' + (data.error || 'Unknown error'));
                                    }
                                })
                                .catch(err => {
                                    console.error(err);
                                    alert('❌ Failed to apply template');
                                });
                            }
                        }
                        
                        // منع النقر على الروابط التي قد تعيد التوجيه خارج المعاينة
                        document.addEventListener('click', function(e) {
                            const link = e.target.closest('a');
                            if (link && link.href && !link.href.includes('/api/templates/serve/')) {
                                e.preventDefault();
                                if (confirm('This link will take you outside the preview. Continue?')) {
                                    window.open(link.href, '_blank');
                                }
                            }
                        });
                    <\/script>
                `;
                
                // ✅ إرسال HTML مع Content-Type الصحيح
                res.setHeader('Content-Type', 'text/html');
                res.setHeader('X-Frame-Options', 'SAMEORIGIN');
                res.send(previewBar);
                
            } catch (fetchError) {
                console.error('Error fetching template HTML:', fetchError);
                // Fallback: إعادة توجيه فقط
                res.redirect(indexUrl);
            }
        } else {
            // إعادة توجيه عادية (للاستخدامات الأخرى)
            res.redirect(indexUrl);
        }
        
    } catch (error) {
        console.error('Error serving template preview:', error);
        res.status(500).send('Internal Server Error');
    }
});


// ============================================
// GET /api/templates/serve/:slug/* - خدمة ملفات القالب (محدث)
// ============================================
app.get('/api/templates/serve/:slug/*', async (req, res) => {
    try {
        const { slug } = req.params;
        const filePath = req.params[0] || 'index.html';
        
        const template = await TemplateStore.findOne({ slug });
        
        if (!template) {
            return res.status(404).json({ error: 'Template not found' });
        }
        
        // ============================================
        // 1. البحث عن الملف في Cloudinary
        // ============================================
        const uploadedFiles = template.themeData?.uploadedFiles;
        
        if (uploadedFiles) {
            // جمع جميع الملفات
            const allFiles = [
                ...(uploadedFiles.htmlFiles || []),
                ...(uploadedFiles.cssFiles || []),
                ...(uploadedFiles.jsFiles || []),
                ...(uploadedFiles.imageFiles || []),
                ...(uploadedFiles.fontFiles || [])
            ];
            
            // البحث عن الملف
            const foundFile = allFiles.find(f => {
                if (f.name === filePath) return true;
                if (f.name.endsWith(filePath)) return true;
                if (f.name.split('/').pop() === filePath.split('/').pop()) return true;
                return false;
            });
            
            if (foundFile && foundFile.url) {
                console.log(`✅ Serving file ${filePath} from Cloudinary`);
                return res.redirect(foundFile.url);
            }
        }
        
        // ============================================
        // 2. Fallback: رابط القالب الرئيسي
        // ============================================
        let templateUrl = null;
        if (template.themeData?.templateUrl) {
            templateUrl = template.themeData.templateUrl;
        } else if (uploadedFiles?.htmlFiles?.length > 0) {
            const indexFile = uploadedFiles.htmlFiles.find(f => 
                f.name === 'index.html' || f.name.endsWith('/index.html')
            );
            if (indexFile && indexFile.url) {
                templateUrl = indexFile.url;
            }
        }
        
        if (templateUrl && (filePath === 'index.html' || filePath === '')) {
            return res.redirect(templateUrl);
        }
        
        // ============================================
        // 3. إذا لم يتم العثور على الملف
        // ============================================
        console.error(`❌ File not found: ${filePath} for template ${slug}`);
        res.status(404).json({ 
            error: 'File not found',
            path: filePath,
            template: slug,
            availableFiles: {
                html: uploadedFiles?.htmlFiles?.map(f => f.name) || [],
                css: uploadedFiles?.cssFiles?.map(f => f.name) || [],
                js: uploadedFiles?.jsFiles?.map(f => f.name) || []
            }
        });
        
    } catch (error) {
        console.error('Error serving template file:', error);
        res.status(500).json({ 
            error: 'Internal Server Error',
            message: error.message 
        });
    }
});

// ============================================
// GET /api/templates/serve/:slug/file/* - خدمة ملفات القالب مع Content-Type الصحيح
// ============================================
app.get('/api/templates/serve/:slug/file/*', async (req, res) => {
    try {
        const { slug } = req.params;
        const filePath = req.params[0];
        
        const template = await TemplateStore.findOne({ slug });
        
        if (!template || !template.themeData?.uploadedFiles) {
            return res.status(404).json({ error: 'Template not found' });
        }
        
        // جمع جميع الملفات
        const allFiles = [
            ...(template.themeData.uploadedFiles.htmlFiles || []),
            ...(template.themeData.uploadedFiles.cssFiles || []),
            ...(template.themeData.uploadedFiles.jsFiles || []),
            ...(template.themeData.uploadedFiles.imageFiles || []),
            ...(template.themeData.uploadedFiles.fontFiles || [])
        ];
        
        // البحث عن الملف
        const foundFile = allFiles.find(f => 
            f.name === filePath || 
            f.name.endsWith(filePath) ||
            f.name.split('/').pop() === filePath.split('/').pop()
        );
        
        if (!foundFile || !foundFile.url) {
            return res.status(404).json({ error: 'File not found' });
        }
        
        // ✅ تحديد نوع المحتوى بناءً على الامتداد
        const ext = filePath.split('.').pop().toLowerCase();
        const contentTypes = {
            'html': 'text/html',
            'css': 'text/css',
            'js': 'application/javascript',
            'json': 'application/json',
            'jpg': 'image/jpeg',
            'jpeg': 'image/jpeg',
            'png': 'image/png',
            'gif': 'image/gif',
            'svg': 'image/svg+xml',
            'webp': 'image/webp',
            'ico': 'image/x-icon',
            'woff': 'font/woff',
            'woff2': 'font/woff2',
            'ttf': 'font/ttf',
            'eot': 'application/vnd.ms-fontobject'
        };
        
        const contentType = contentTypes[ext] || 'application/octet-stream';
        
        // ✅ جلب الملف من Cloudinary وإرساله مع Content-Type الصحيح
        const fileResponse = await axios.get(foundFile.url, { 
            responseType: 'arraybuffer',
            headers: { 'Accept': contentType }
        });
        
        res.setHeader('Content-Type', contentType);
        res.setHeader('Cache-Control', 'public, max-age=3600');
        res.send(fileResponse.data);
        
    } catch (error) {
        console.error('Error serving template file:', error);
        res.status(500).json({ error: 'Failed to serve file' });
    }
});
// ============================================
// دالة مساعدة للحصول على رمز العملة
// ============================================
function getCurrencySymbol(currency) {
    const symbols = {
        'USD': '$', 'EUR': '€', 'GBP': '£', 'EGP': 'ج.م',
        'SAR': '﷼', 'AED': 'د.إ', 'CAD': 'C$', 'AUD': 'A$',
        'JPY': '¥', 'CNY': '¥', 'INR': '₹', 'BRL': 'R$',
        'KRW': '₩', 'RUB': '₽', 'TRY': '₺', 'MXN': '$'
    };
    return symbols[currency] || '$';
}

// ============================================
// دالة مساعدة لتعديل اللون (تفتيح/تغميق)
// ============================================
function adjustColor(color, percent) {
    if (!color || !color.startsWith('#')) return color;
    
    try {
        const R = parseInt(color.substring(1, 3), 16);
        const G = parseInt(color.substring(3, 5), 16);
        const B = parseInt(color.substring(5, 7), 16);
        
        const adjustedR = Math.max(0, Math.min(255, R + (R * percent) / 100));
        const adjustedG = Math.max(0, Math.min(255, G + (G * percent) / 100));
        const adjustedB = Math.max(0, Math.min(255, B + (B * percent) / 100));
        
        return `#${Math.round(adjustedR).toString(16).padStart(2, '0')}${Math.round(adjustedG).toString(16).padStart(2, '0')}${Math.round(adjustedB).toString(16).padStart(2, '0')}`;
    } catch (e) {
        return color;
    }
}

// ============================================
// POST /api/templates/:id/review - إضافة تقييم للقالب
// ============================================
app.post('/api/templates/:id/review', authenticateToken, async (req, res) => {
    try {
        const { rating, comment } = req.body;
        
        if (!rating || rating < 1 || rating > 5) {
            return res.status(400).json({ error: 'Rating must be between 1 and 5' });
        }
        
        let template;
        if (req.params.id.match(/^[0-9a-fA-F]{24}$/)) {
            template = await TemplateStore.findById(req.params.id);
        } else {
            template = await TemplateStore.findOne({ slug: req.params.id });
        }
        
        if (!template) {
            return res.status(404).json({ error: 'Template not found' });
        }
        
        await TemplateStore.addReview(template._id, req.user.userId, rating, comment);
        
        res.json({
            success: true,
            message: 'Review added successfully'
        });
    } catch (error) {
        console.error('Error adding review:', error);
        res.status(500).json({ error: 'Failed to add review' });
    }
});

// ============================================
// GET /api/templates/my/installed - جلب القوالب المثبتة لدى المستخدم
// ============================================
app.get('/api/templates/my/installed', authenticateToken, async (req, res) => {
    try {
        const templates = await TemplateStore.find({
            'installedBy.userId': req.user.userId,
            isActive: true
        }).select('name slug previewImage installedBy');
        
        const installedTemplates = templates.map(t => ({
            _id: t._id,
            name: t.name,
            slug: t.slug,
            previewImage: t.previewImage,
            installedAt: t.installedBy.find(i => i.userId.toString() === req.user.userId)?.installedAt
        }));
        
        res.json({ success: true, templates: installedTemplates });
    } catch (error) {
        console.error('Error fetching installed templates:', error);
        res.status(500).json({ error: 'Failed to fetch installed templates' });
    }
});


// ============================================
// 🎯 LIVE PREVIEW ENDPOINTS
// ============================================
// GET /shop/preview - صفحة المعاينة الحية
app.get('/shop/preview', async (req, res) => {
    try {
        const html = `
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
    <title>Live Preview - MGZon Store</title>
    <script src="https://cdn.tailwindcss.com"></script>
    <link href="https://cdn.jsdelivr.net/npm/boxicons@2.1.4/css/boxicons.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Poppins:wght@400;500;600;700&family=Roboto:wght@400;500;700&family=Playfair+Display:wght@400;500;600;700&family=Courier+Prime:wght@400;700&display=swap" rel="stylesheet">
    <style>
        /* كل الـ styles الموجودة كما هي ... */
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        
        body {
            font-family: 'Inter', sans-serif;
            background: #f9fafb;
            min-height: 100vh;
            transition: all 0.2s ease;
        }
        
        /* Dark mode support */
        .dark body {
            background: #111827;
        }
        
        /* Preview badge */
        .preview-badge {
            position: fixed;
            bottom: 20px;
            right: 20px;
            background: linear-gradient(135deg, #8b5cf6, #6366f1);
            color: white;
            padding: 8px 16px;
            border-radius: 9999px;
            font-size: 12px;
            font-weight: 500;
            z-index: 9999;
            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
            backdrop-filter: blur(4px);
            cursor: pointer;
            transition: all 0.2s;
        }
        
        .preview-badge:hover {
            transform: scale(1.05);
            background: linear-gradient(135deg, #7c3aed, #4f46e5);
        }
        
        /* Section highlight for click-to-edit */
        .preview-section {
            transition: all 0.2s ease;
            cursor: pointer;
            position: relative;
            scroll-margin-top: 80px;
        }
        
        .preview-section:hover {
            outline: 2px solid #8b5cf6;
            outline-offset: 2px;
            background: rgba(139, 92, 246, 0.05);
        }
        
        .preview-section:active {
            outline: 3px solid #7c3aed;
        }
        
        /* Section highlight animation */
        .section-highlight {
            animation: highlightPulse 0.6s ease-out;
        }
        
        @keyframes highlightPulse {
            0% { outline: 2px solid #8b5cf6; background: rgba(139, 92, 246, 0.1); }
            100% { outline: 2px solid transparent; background: transparent; }
        }
        
        /* Toast notification */
        .preview-toast {
            position: fixed;
            bottom: 80px;
            right: 20px;
            background: #1f2937;
            color: white;
            padding: 8px 16px;
            border-radius: 8px;
            font-size: 12px;
            z-index: 10000;
            opacity: 0;
            transition: opacity 0.3s;
            pointer-events: none;
        }
        
        .preview-toast.show {
            opacity: 1;
        }
        
        /* Loading spinner */
        .preview-spinner {
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            width: 40px;
            height: 40px;
            border: 3px solid #e5e7eb;
            border-top-color: #8b5cf6;
            border-radius: 50%;
            animation: spin 0.8s linear infinite;
            z-index: 10000;
        }
        
        @keyframes spin {
            to { transform: translate(-50%, -50%) rotate(360deg); }
        }
        
        /* Product card animation */
        .product-card {
            transition: all 0.2s ease;
        }
        
        .product-card:hover {
            transform: translateY(-4px);
            box-shadow: 0 10px 25px -5px rgba(0,0,0,0.1);
        }
        
        /* Section transitions */
        .section-enter {
            animation: fadeInUp 0.3s ease-out;
        }
        
        @keyframes fadeInUp {
            from {
                opacity: 0;
                transform: translateY(20px);
            }
            to {
                opacity: 1;
                transform: translateY(0);
            }
        }
        
        /* Glass effect */
        .glass-effect {
            background: rgba(255, 255, 255, 0.1);
            backdrop-filter: blur(10px);
        }
        
        /* Custom scrollbar */
        ::-webkit-scrollbar {
            width: 6px;
        }
        
        ::-webkit-scrollbar-track {
            background: #f1f1f1;
        }
        
        ::-webkit-scrollbar-thumb {
            background: #cbd5e1;
            border-radius: 3px;
        }
        
        ::-webkit-scrollbar-thumb:hover {
            background: #8b5cf6;
        }
        
        /* Background patterns */
        body.bg-dots {
            background-image: radial-gradient(circle, #cbd5e1 1px, transparent 1px);
            background-size: 24px 24px;
        }
        
        body.bg-grid {
            background-image: linear-gradient(to right, #e5e7eb 1px, transparent 1px),
                              linear-gradient(to bottom, #e5e7eb 1px, transparent 1px);
            background-size: 24px 24px;
        }
        
        body.bg-cross {
            background-image: linear-gradient(45deg, #cbd5e1 1px, transparent 1px),
                              linear-gradient(-45deg, #cbd5e1 1px, transparent 1px);
            background-size: 24px 24px;
        }
        
        /* Border radius utilities */
        .rounded-card-sm { border-radius: 0.25rem; }
        .rounded-card-md { border-radius: 0.5rem; }
        .rounded-card-lg { border-radius: 1rem; }
        .rounded-card-xl { border-radius: 1.5rem; }
        
        /* Animation utilities */
        .hover-lift:hover { transform: translateY(-4px); }
        .hover-scale:hover { transform: scale(1.02); }
        .hover-glow:hover { box-shadow: 0 0 15px rgba(139, 92, 246, 0.3); }
        
        /* Shadow utilities */
        .shadow-sm { box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05); }
        .shadow-md { box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); }
        .shadow-lg { box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05); }
        .shadow-xl { box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04); }
        
        /* Line clamp */
        .line-clamp-2 {
            display: -webkit-box;
            -webkit-line-clamp: 2;
            -webkit-box-orient: vertical;
            overflow: hidden;
        }
        
        .line-clamp-3 {
            display: -webkit-box;
            -webkit-line-clamp: 3;
            -webkit-box-orient: vertical;
            overflow: hidden;
        }
    </style>
</head>
<body>
    <div id="app">
        <div class="preview-spinner" id="loading-spinner" style="display: none;"></div>
        <div id="store-content">
            <div class="flex items-center justify-center h-screen">
                <div class="text-center">
                    <i class='bx bx-store text-5xl text-gray-300 mb-3'></i>
                    <p class="text-gray-400">Loading preview...</p>
                </div>
            </div>
        </div>
    </div>
    
    <div class="preview-badge" id="preview-badge">
        <i class='bx bx-show-alt mr-1'></i> Live Preview Mode
    </div>
    <div class="preview-toast" id="preview-toast">
        <i class='bx bx-check-circle mr-1'></i> <span id="toast-message">Updated</span>
    </div>
    
    <script>
        let currentSettings = null;
        let currentProducts = [];
        let currentSections = [];
        let updateTimeout = null;
        let lastUpdateTime = 0;
        
        // Show toast notification
        function showToast(message, type = 'success') {
            const toast = document.getElementById('preview-toast');
            const toastMsg = document.getElementById('toast-message');
            if (toast && toastMsg) {
                toastMsg.innerHTML = message;
                toast.classList.add('show');
                setTimeout(() => toast.classList.remove('show'), 2000);
            }
        }
        
        // Show/hide loading spinner
        function setLoading(loading) {
            const spinner = document.getElementById('loading-spinner');
            if (spinner) {
                spinner.style.display = loading ? 'block' : 'none';
            }
        }
        

        // Apply CSS variables from settings
        function applyTheme(settings) {
            const root = document.documentElement;
            const body = document.body;
            
            // Apply colors
            if (settings.primaryColor) {
                root.style.setProperty('--primary-color', settings.primaryColor);
                const style = document.createElement('style');
                style.textContent = \`
                    .btn-primary { background-color: \${settings.primaryColor} !important; }
                    .btn-primary:hover { background-color: \${adjustColor(settings.primaryColor, -20)} !important; }
                    .text-primary { color: \${settings.primaryColor} !important; }
                    .border-primary { border-color: \${settings.primaryColor} !important; }
                    .bg-primary-light { background-color: \${settings.primaryColor}20 !important; }
                \`;
                document.head.appendChild(style);
            }
            
            if (settings.secondaryColor) {
                root.style.setProperty('--secondary-color', settings.secondaryColor);
            }
            
            // Apply font family
            if (settings.fontFamily && settings.fontFamily !== 'Inter, sans-serif') {
                body.style.fontFamily = settings.fontFamily;
            }
            
            // Apply border radius
            if (settings.borderRadius) {
                root.style.setProperty('--border-radius', settings.borderRadius + 'px');
                const radiusClass = \`rounded-card-\${settings.borderRadius <= 8 ? 'sm' : settings.borderRadius <= 16 ? 'md' : settings.borderRadius <= 24 ? 'lg' : 'xl'}\`;
                document.querySelectorAll('.product-card, .section-card').forEach(el => {
                    el.classList.add(radiusClass);
                });
            }
            
            // Apply glass effect
            if (settings.glassEffect) {
                body.classList.add('glass-effect');
            } else {
                body.classList.remove('glass-effect');
            }
            
            // Apply shadow type
            const shadowMap = { none: '', sm: 'shadow-sm', md: 'shadow-md', lg: 'shadow-lg', xl: 'shadow-xl' };
            const shadowClass = shadowMap[settings.shadowType] || 'shadow-md';
            document.querySelectorAll('.product-card, .section-card').forEach(el => {
                el.classList.remove('shadow-sm', 'shadow-md', 'shadow-lg', 'shadow-xl');
                if (settings.shadowType !== 'none') el.classList.add(shadowClass);
            });
            
            // Apply animation type
            const animationMap = { none: '', hover: 'hover-lift', scale: 'hover-scale', glow: 'hover-glow' };
            const animationClass = animationMap[settings.animationType] || '';
            document.querySelectorAll('.product-card').forEach(el => {
                el.classList.remove('hover-lift', 'hover-scale', 'hover-glow');
                if (animationClass) el.classList.add(animationClass);
            });
            
            // Apply background
            body.classList.remove('bg-dots', 'bg-grid', 'bg-cross');
            
            if (settings.backgroundType === 'gradient' && settings.backgroundValue) {
                body.style.background = settings.backgroundValue;
                body.style.backgroundAttachment = 'fixed';
            } else if (settings.backgroundType === 'image' && settings.backgroundValue) {
                body.style.background = \`url(\${settings.backgroundValue}) center/cover fixed\`;
            } else if (settings.backgroundType === 'dots') {
                body.classList.add('bg-dots');
                body.style.background = '';
            } else if (settings.backgroundType === 'grid') {
                body.classList.add('bg-grid');
                body.style.background = '';
            } else if (settings.backgroundType === 'cross') {
                body.classList.add('bg-cross');
                body.style.background = '';
            } else {
                body.style.background = '';
            }
            
            // Apply zoom level
            if (settings.zoomLevel && settings.zoomLevel !== 100) {
                body.style.zoom = settings.zoomLevel + '%';
            } else {
                body.style.zoom = '';
            }
            
            // Apply custom CSS
            if (settings.customCss) {
                let customStyle = document.getElementById('custom-css');
                if (!customStyle) {
                    customStyle = document.createElement('style');
                    customStyle.id = 'custom-css';
                    document.head.appendChild(customStyle);
                }
                customStyle.textContent = settings.customCss;
            }
        }
        
        // Helper function to adjust color brightness
        function adjustColor(color, percent) {
            // Simple color adjustment - can be expanded
            return color;
        }
        
        // Generate store HTML
        function generateStoreHTML(settings, products, sections) {
            const currencySymbol = settings.currencySymbol || '$';
            const storeEnabled = settings.storeEnabled !== false;
            
            if (!storeEnabled) {
                return \`
                    <div class="flex items-center justify-center min-h-screen">
                        <div class="text-center p-8">
                            <i class='bx bx-store-alt text-6xl text-gray-300 mb-4'></i>
                            <h2 class="text-xl font-semibold text-gray-600 mb-2">Store is Disabled</h2>
                            <p class="text-gray-400">Enable your store from settings to see the preview</p>
                        </div>
                    </div>
                \`;
            }
            
            // Sort sections by order
            const sortedSections = [...sections].sort((a, b) => (a.order || 0) - (b.order || 0));
            
            // Build sections HTML
            let sectionsHtml = '';
            for (const section of sortedSections) {
                if (!section.enabled) continue;
                sectionsHtml += renderSection(section, products, settings, currencySymbol);
            }
            
            // Get animation class
            const animationClass = settings.animationType === 'hover' ? 'hover-lift' : 
                                   settings.animationType === 'scale' ? 'hover-scale' : 
                                   settings.animationType === 'glow' ? 'hover-glow' : '';
            
            return \`
                <div class="store-wrapper" style="background: inherit;">
                    <!-- Store Header -->
                    <div class="store-header preview-section section-card" data-section-id="header" data-section-type="header" data-order="-1">
                        \${settings.storeBanner ? \`
                            <div class="relative h-48 md:h-64 overflow-hidden">
                                <img src="\${settings.storeBanner}" alt="Store Banner" class="w-full h-full object-cover" onerror="this.src='/assets/img/default-banner.jpg'">
                                <div class="absolute inset-0 bg-gradient-to-t from-black/50 to-transparent"></div>
                            </div>
                        \` : ''}
                        <div class="text-center py-6 px-4">
                            \${settings.storeLogo ? \`
                                <img src="\${settings.storeLogo}" alt="Store Logo" class="w-24 h-24 rounded-full mx-auto mb-3 border-4 border-white shadow-lg object-cover" onerror="this.src='/assets/img/default-store.png'">
                            \` : \`
                                <div class="w-24 h-24 rounded-full bg-gradient-to-r from-purple-500 to-pink-500 mx-auto mb-3 flex items-center justify-center">
                                    <i class='bx bx-store text-4xl text-white'></i>
                                </div>
                            \`}
                            <h1 class="text-2xl md:text-3xl font-bold text-gray-800 dark:text-white">\${escapeHtml(settings.storeName || 'My Store')}</h1>
                            \${settings.storeDescription ? \`
                                <p class="text-gray-600 dark:text-gray-300 mt-2 max-w-2xl mx-auto">\${escapeHtml(settings.storeDescription)}</p>
                            \` : ''}
                        </div>
                    </div>
                    
                    <!-- Store Sections -->
                    <div class="store-sections max-w-6xl mx-auto px-4 py-8">
                        \${sectionsHtml}
                    </div>
                    
                    <!-- Store Footer -->
                    <div class="store-footer text-center py-6 border-t dark:border-gray-700 text-gray-500 text-sm">
                        <p>© \${new Date().getFullYear()} \${escapeHtml(settings.storeName || 'My Store')}. All rights reserved.</p>
                        <p class="text-xs mt-1">Powered by MGZon</p>
                    </div>
                </div>
            \`;
        }
        
        // Render individual section
        function renderSection(section, products, settings, currencySymbol) {
            const sectionClass = "preview-section mb-8 section-enter section-card";
            const sectionId = section.id || section.type;
            const sectionTitle = section.title || getSectionTitle(section.type);
            const order = section.order || 0;
            
            switch(section.type) {
                case 'hero':
                    return \`
                        <div class="\${sectionClass}" data-section-id="\${sectionId}" data-section-type="hero" data-order="\${order}">
                            <div class="bg-gradient-to-r from-purple-600 to-pink-600 rounded-2xl overflow-hidden">
                                <div class="text-center py-16 px-4 text-white">
                                    <h2 class="text-3xl md:text-4xl font-bold mb-3">\${escapeHtml(section.content?.title || 'Welcome to My Store')}</h2>
                                    \${section.content?.subtitle ? \`<p class="text-lg opacity-90 mb-6">\${escapeHtml(section.content.subtitle)}</p>\` : ''}
                                    \${section.content?.buttonText ? \`
                                        <button class="px-6 py-3 bg-white text-purple-600 rounded-lg font-semibold hover:shadow-lg transition btn-primary" style="background-color: white; color: \${settings.primaryColor || '#7c3aed'}">
                                            \${escapeHtml(section.content.buttonText)}
                                        </button>
                                    \` : ''}
                                </div>
                            </div>
                        </div>
                    \`;
                    
                case 'featured':
                    const featuredProducts = products.filter(p => p.isActive !== false).slice(0, section.limit || 6);
                    return \`
                        <div class="\${sectionClass}" data-section-id="\${sectionId}" data-section-type="featured" data-order="\${order}">
                            <h2 class="text-xl md:text-2xl font-bold mb-6 text-gray-800 dark:text-white" style="color: \${settings.primaryColor || '#1f2937'}">\${escapeHtml(sectionTitle)}</h2>
                            <div class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 gap-6">
                                \${featuredProducts.map(product => renderProductCard(product, currencySymbol, settings)).join('')}
                            </div>
                            \${featuredProducts.length === 0 ? \`
                                <div class="text-center py-12 text-gray-400">
                                    <i class='bx bx-package text-4xl mb-2'></i>
                                    <p>No products yet. Add your first product to see it here.</p>
                                </div>
                            \` : ''}
                        </div>
                    \`;
                    
                case 'products':
                    const allProducts = products.filter(p => p.isActive !== false).slice(0, section.limit || 12);
                    return \`
                        <div class="\${sectionClass}" data-section-id="\${sectionId}" data-section-type="products" data-order="\${order}">
                            <h2 class="text-xl md:text-2xl font-bold mb-6 text-gray-800 dark:text-white" style="color: \${settings.primaryColor || '#1f2937'}">\${escapeHtml(sectionTitle)}</h2>
                            <div class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 gap-6">
                                \${allProducts.map(product => renderProductCard(product, currencySymbol, settings)).join('')}
                            </div>
                            \${allProducts.length === 0 ? \`
                                <div class="text-center py-12 text-gray-400">
                                    <i class='bx bx-package text-4xl mb-2'></i>
                                    <p>No products yet. Click "Add Product" to start selling.</p>
                                </div>
                            \` : ''}
                        </div>
                    \`;
                    
                case 'categories':
                    const categories = [
                        { name: 'Digital', icon: 'bx-download', count: products.filter(p => p.type === 'digital').length },
                        { name: 'Projects', icon: 'bx-code-alt', count: products.filter(p => p.type === 'project').length },
                        { name: 'Services', icon: 'bx-briefcase', count: products.filter(p => p.type === 'service').length }
                    ];
                    const activeCategories = categories.filter(c => c.count > 0);
                    return \`
                        <div class="\${sectionClass}" data-section-id="\${sectionId}" data-section-type="categories" data-order="\${order}">
                            <h2 class="text-xl md:text-2xl font-bold mb-6 text-gray-800 dark:text-white" style="color: \${settings.primaryColor || '#1f2937'}">\${escapeHtml(sectionTitle)}</h2>
                            <div class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 gap-4">
                                \${(activeCategories.length > 0 ? activeCategories : categories).map(cat => \`
                                    <div class="bg-gray-50 dark:bg-gray-800 rounded-xl p-6 text-center hover:shadow-md transition cursor-pointer">
                                        <i class='bx \${cat.icon} text-4xl text-purple-500 mb-3'></i>
                                        <h3 class="font-semibold text-lg">\${cat.name}</h3>
                                        <p class="text-sm text-gray-500">\${cat.count} products</p>
                                    </div>
                                \`).join('')}
                            </div>
                        </div>
                    \`;
                    
                case 'testimonials':
                    const testimonials = section.content?.items || [
                        { text: "Amazing products! Highly recommend this store.", author: "Sarah Johnson", role: "Verified Buyer", rating: 5 },
                        { text: "Great quality and fast delivery. Will shop again!", author: "Michael Chen", role: "Repeat Customer", rating: 5 },
                        { text: "The support team is very helpful. 10/10 experience.", author: "Emily Davis", role: "Happy Customer", rating: 5 }
                    ];
                    return \`
                        <div class="\${sectionClass}" data-section-id="\${sectionId}" data-section-type="testimonials" data-order="\${order}">
                            <h2 class="text-xl md:text-2xl font-bold mb-6 text-gray-800 dark:text-white" style="color: \${settings.primaryColor || '#1f2937'}">\${escapeHtml(sectionTitle)}</h2>
                            <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
                                \${testimonials.slice(0, section.limit || 6).map(t => \`
                                    <div class="bg-gray-50 dark:bg-gray-800 p-6 rounded-xl">
                                        <div class="flex gap-1 mb-3">
                                            \${Array(5).fill().map((_, i) => \`<i class='bx bxs-star text-yellow-400 text-sm'\${i >= (t.rating || 5) ? ' style="opacity:0.3"' : ''}></i>\`).join('')}
                                        </div>
                                        <p class="text-gray-600 dark:text-gray-300 mb-4">"\${escapeHtml(t.text)}"</p>
                                        <div class="flex items-center gap-3">
                                            <div class="w-10 h-10 rounded-full bg-purple-100 dark:bg-purple-900 flex items-center justify-center">
                                                <i class='bx bx-user text-purple-500'></i>
                                            </div>
                                            <div>
                                                <p class="font-semibold text-sm">\${escapeHtml(t.author)}</p>
                                                <p class="text-xs text-gray-500">\${escapeHtml(t.role || 'Customer')}</p>
                                            </div>
                                        </div>
                                    </div>
                                \`).join('')}
                            </div>
                        </div>
                    \`;
                    
                case 'faq':
                    const faqItems = section.content?.items || [
                        { question: "How do I download my purchase?", answer: "After payment confirmation, you'll receive a download link via email and in your order history." },
                        { question: "What is your refund policy?", answer: "We offer a 30-day money-back guarantee on all digital products. Contact support for assistance." },
                        { question: "How long does delivery take?", answer: "For digital products, delivery is instant. For services, delivery time varies by service type." }
                    ];
                    return \`
                        <div class="\${sectionClass}" data-section-id="\${sectionId}" data-section-type="faq" data-order="\${order}">
                            <h2 class="text-xl md:text-2xl font-bold mb-6 text-gray-800 dark:text-white" style="color: \${settings.primaryColor || '#1f2937'}">\${escapeHtml(sectionTitle)}</h2>
                            <div class="space-y-4">
                                \${faqItems.map(item => \`
                                    <div class="border rounded-lg p-4 hover:shadow-md transition">
                                        <h3 class="font-semibold mb-2">\${escapeHtml(item.question)}</h3>
                                        <p class="text-gray-600 dark:text-gray-400 text-sm">\${escapeHtml(item.answer)}</p>
                                    </div>
                                \`).join('')}
                            </div>
                        </div>
                    \`;
                    
                case 'contact':
                    return \`
                        <div class="\${sectionClass}" data-section-id="\${sectionId}" data-section-type="contact" data-order="\${order}">
                            <h2 class="text-xl md:text-2xl font-bold mb-6 text-gray-800 dark:text-white" style="color: \${settings.primaryColor || '#1f2937'}">\${escapeHtml(sectionTitle)}</h2>
                            <div class="bg-gray-50 dark:bg-gray-800 rounded-xl p-6">
                                <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
                                    <div>
                                        <div class="flex items-center gap-3 mb-4">
                                            <div class="w-10 h-10 rounded-full bg-purple-100 dark:bg-purple-900 flex items-center justify-center">
                                                <i class='bx bx-envelope text-purple-500 text-xl'></i>
                                            </div>
                                            <div>
                                                <p class="text-sm text-gray-500">Email</p>
                                                <p class="font-medium">\${escapeHtml(section.content?.email || 'store@example.com')}</p>
                                            </div>
                                        </div>
                                        \${section.content?.phone ? \`
                                            <div class="flex items-center gap-3 mb-4">
                                                <div class="w-10 h-10 rounded-full bg-purple-100 dark:bg-purple-900 flex items-center justify-center">
                                                    <i class='bx bx-phone text-purple-500 text-xl'></i>
                                                </div>
                                                <div>
                                                    <p class="text-sm text-gray-500">Phone</p>
                                                    <p class="font-medium">\${escapeHtml(section.content.phone)}</p>
                                                </div>
                                            </div>
                                        \` : ''}
                                    </div>
                                    <div>
                                        <form class="space-y-3" onsubmit="event.preventDefault(); showToast('Contact form demo - integrate with backend', 'info');">
                                            <input type="text" placeholder="Your Name" class="w-full p-2 border rounded-lg dark:bg-gray-700">
                                            <input type="email" placeholder="Your Email" class="w-full p-2 border rounded-lg dark:bg-gray-700">
                                            <textarea placeholder="Your Message" rows="3" class="w-full p-2 border rounded-lg dark:bg-gray-700"></textarea>
                                            <button type="submit" class="btn-primary px-4 py-2 bg-purple-500 text-white rounded-lg hover:bg-purple-600 transition w-full" style="background-color: \${settings.primaryColor || '#7c3aed'}">
                                                Send Message
                                            </button>
                                        </form>
                                    </div>
                                </div>
                            </div>
                        </div>
                    \`;
                    
                default:
                    return '';
            }
        }
        
        // Render product card
        function renderProductCard(product, currencySymbol, settings) {
            const imageUrl = product.images?.[0] || '/assets/img/default-product.png';
            const animationClass = settings.animationType === 'hover' ? 'hover-lift' : 
                                   settings.animationType === 'scale' ? 'hover-scale' : 
                                   settings.animationType === 'glow' ? 'hover-glow' : '';
            const shadowClass = settings.shadowType === 'none' ? '' : 
                                settings.shadowType === 'sm' ? 'shadow-sm' : 
                                settings.shadowType === 'md' ? 'shadow-md' : 
                                settings.shadowType === 'lg' ? 'shadow-lg' : 'shadow-xl';
            
            return \`
                <div class="product-card bg-white dark:bg-gray-800 rounded-xl overflow-hidden \${shadowClass} \${animationClass} transition-all">
                    <img src="\${imageUrl}" alt="\${escapeHtml(product.title)}" class="w-full h-40 object-cover" onerror="this.src='/assets/img/default-product.png'">
                    <div class="p-4">
                        <span class="text-xs px-2 py-0.5 rounded-full \${product.type === 'digital' ? 'bg-blue-100 text-blue-700' : product.type === 'project' ? 'bg-green-100 text-green-700' : 'bg-purple-100 text-purple-700'} mb-2 inline-block">
                            \${product.type === 'digital' ? '📁 Digital' : product.type === 'project' ? '💻 Project' : '⚡ Service'}
                        </span>
                        <h3 class="font-semibold text-gray-800 dark:text-white truncate">\${escapeHtml(product.title)}</h3>
                        <p class="text-sm text-gray-500 mt-1 line-clamp-2">\${escapeHtml(product.description?.substring(0, 80) || '')}</p>
                        <div class="flex justify-between items-center mt-3">
                            <span class="text-lg font-bold" style="color: \${settings.primaryColor || '#7c3aed'}">\${product.price} \${currencySymbol}</span>
                            <button class="px-3 py-1 bg-purple-500 text-white rounded-lg text-sm hover:bg-purple-600 transition" style="background-color: \${settings.primaryColor || '#7c3aed'}">
                                Buy Now
                            </button>
                        </div>
                    </div>
                </div>
            \`;
        }
        
        // Get section title by type
        function getSectionTitle(type) {
            const titles = {
                hero: 'Hero Section',
                featured: 'Featured Products',
                products: 'All Products',
                categories: 'Categories',
                testimonials: 'Testimonials',
                faq: 'FAQ',
                contact: 'Contact'
            };
            return titles[type] || type;
        }
        
        // Escape HTML
        function escapeHtml(str) {
            if (!str) return '';
            return String(str).replace(/[&<>]/g, function(m) {
                if (m === '&') return '&amp;';
                if (m === '<') return '&lt;';
                if (m === '>') return '&gt;';
                return m;
            });
        }
        
        // Render full store
        function renderStore(settings, products, sections) {
            setLoading(false);
            const html = generateStoreHTML(settings, products, sections);
            const container = document.getElementById('store-content');
            if (container) {
                container.innerHTML = html;
                applyTheme(settings);
                attachClickListeners();
                // Scroll to highlighted section if needed
                const hash = window.location.hash;
                if (hash && hash.startsWith('#section-')) {
                    const element = document.querySelector(\`[data-section-id="\${hash.replace('#section-', '')}"]\`);
                    if (element) {
                        setTimeout(() => {
                            element.scrollIntoView({ behavior: 'smooth', block: 'start' });
                            element.classList.add('section-highlight');
                            setTimeout(() => element.classList.remove('section-highlight'), 600);
                        }, 100);
                    }
                }
            }
        }
        
        // Attach click listeners to sections
        function attachClickListeners() {
            document.querySelectorAll('.preview-section').forEach(el => {
                el.removeEventListener('click', handleSectionClick);
                el.addEventListener('click', handleSectionClick);
            });
        }
        
        // Handle section click
        function handleSectionClick(e) {
            e.stopPropagation();
            const sectionId = this.dataset.sectionId;
            const sectionType = this.dataset.sectionType;
            if (sectionId) {
                window.parent.postMessage({
                    type: 'preview-click',
                    sectionId: sectionId,
                    sectionType: sectionType
                }, '*');
                // Visual feedback
                this.classList.add('section-highlight');
                setTimeout(() => this.classList.remove('section-highlight'), 600);
                showToast(\`Editing: \${sectionType || sectionId}\`, 'info');
            }
        }
        
        // Receive updates from parent window
        window.addEventListener('message', (event) => {
            const { type, settings, products, sections, paymentMethods, page, timestamp } = event.data || {};
            
            // ✅ معاينة المنتجات فقط
            if (type === 'refresh-products-only') {
                if (timestamp && timestamp <= lastUpdateTime) return;
                lastUpdateTime = timestamp || Date.now();
                
                currentSettings = settings;
                currentProducts = products || [];
                
                if (updateTimeout) clearTimeout(updateTimeout);
                updateTimeout = setTimeout(() => {
                    renderProductsOnly(currentSettings, currentProducts);
                }, 50);
            }

            if (type === 'update-tab') {
                const { tabName, storeId, pageSlug } = event.data;
                updatePreviewBasedOnTab(tabName, storeId, currentSettings, currentProducts, currentSections, currentPaymentMethods, pageSlug);
            }
            
            // ✅ معاينة طرق الدفع فقط
            else if (type === 'refresh-payment-methods') {
                if (timestamp && timestamp <= lastUpdateTime) return;
                lastUpdateTime = timestamp || Date.now();
                
                currentSettings = settings;
                
                if (updateTimeout) clearTimeout(updateTimeout);
                updateTimeout = setTimeout(() => {
                    renderPaymentMethodsPreview(currentSettings, paymentMethods || []);
                }, 50);
            }
            
            // ✅ معاينة الصفحات (جديد)
            else if (type === 'refresh-page') {
                if (timestamp && timestamp <= lastUpdateTime) return;
                lastUpdateTime = timestamp || Date.now();
                
                if (updateTimeout) clearTimeout(updateTimeout);
                updateTimeout = setTimeout(() => {
                    renderPagePreview(page);
                    showToast(\`Page preview: \${page.title}\`, 'success');
                }, 50);
            }
            
            // ✅ المعاينة الكاملة
            else if (type === 'refresh-store') {
                if (timestamp && timestamp <= lastUpdateTime) return;
                lastUpdateTime = timestamp || Date.now();
                
                currentSettings = settings;
                currentProducts = products || [];
                currentSections = sections || [];
                
                if (updateTimeout) clearTimeout(updateTimeout);
                updateTimeout = setTimeout(() => {
                    renderStore(currentSettings, currentProducts, currentSections);
                    showToast('Preview updated', 'success');
                }, 50);
            }
        });
        
        // دالة عرض معاينة الصفحة (جديدة)
        function renderPagePreview(page) {
            if (!page) return;
            const container = document.getElementById('store-content');
            if (!container) return;
            
            // إزالة أي CSS مخصص سابق
            const oldStyle = document.getElementById('page-preview-style');
            if (oldStyle) oldStyle.remove();
            
            // بناء HTML بسيط للصفحة مع إمكانية تطبيق التنسيقات الخاصة
            container.innerHTML = \`
                <div class="page-preview-wrapper max-w-4xl mx-auto p-6">
                    <div class="bg-white dark:bg-gray-800 rounded-2xl shadow-lg overflow-hidden">
                        <div class="p-6">
                            <h1 class="text-2xl md:text-3xl font-bold mb-4 text-gray-800 dark:text-white">\${escapeHtml(page.title)}</h1>
                            <div class="page-content-wrapper prose max-w-none dark:prose-invert">
                                \${page.content || '<p class="text-gray-500">No content available.</p>'}
                            </div>
                        </div>
                    </div>
                </div>
            \`;
            
            // تطبيق CSS المخصص للصفحة (إذا وجد)
            if (page.css && page.css.trim()) {
                const style = document.createElement('style');
                style.id = 'page-preview-style';
                style.textContent = page.css;
                document.head.appendChild(style);
            }
            
            // تنفيذ JavaScript المخصص (بحذر)
            if (page.js && page.js.trim()) {
                try {
                    // نستخدم Function بدلاً من eval لتقليل المخاطر
                    const scriptFunc = new Function(page.js);
                    scriptFunc();
                } catch(e) {
                    console.error('Page preview JS error:', e);
                }
            }
            
            // تطبيق الإعدادات العامة للمتجر (مثل الألوان) إذا أردت
            if (currentSettings) {
                applyTheme(currentSettings);
            }
        }
        
        // Load initial data
        async function loadInitialData() {
            setLoading(true);
            try {
                // جلب الإعدادات والمنتجات من API واحد
                const token = localStorage.getItem('userToken');
                
                const [settingsRes, productsRes] = await Promise.all([
                    fetch('/api/store/settings', {
                        headers: { 'Authorization': \`Bearer \${token}\` }

                    }),
                    fetch('/api/store/products', {
                        headers: { 'Authorization': \`Bearer \${token}\` }

                    })
                ]);
                
                const settingsData = await settingsRes.json();
                const productsData = await productsRes.json();
                
                if (settingsData.success && productsData.success) {
                    const storeSettings = settingsData.settings;
                    
                    currentSettings = {
                        storeName: storeSettings.storeName || 'My Store',
                        storeDescription: storeSettings.storeDescription || '',
                        storeLogo: storeSettings.storeLogo || '',
                        storeBanner: storeSettings.storeBanner || '',
                        primaryColor: storeSettings.primaryColor || '#3b82f6',
                        secondaryColor: storeSettings.secondaryColor || '#8b5cf6',
                        fontFamily: storeSettings.fontFamily || 'Inter, sans-serif',
                        borderRadius: storeSettings.borderRadius || 16,
                        shadowType: storeSettings.shadowType || 'md',
                        animationType: storeSettings.animationType || 'lift',
                        glassEffect: storeSettings.glassEffect || false,
                        backgroundType: storeSettings.backgroundType || 'default',
                        backgroundValue: storeSettings.backgroundValue || '',
                        customCss: storeSettings.customCss || '',
                        currency: storeSettings.currency || 'USD',
                        currencySymbol: storeSettings.currencySymbol || '$',
                        storeEnabled: storeSettings.enabled !== false
                    };
                    
                    currentProducts = productsData.products || [];
                    currentSections = storeSettings.pageBuilder?.sections || [];
                    
                    if (currentSections.length === 0) {
                        currentSections = getDefaultSections();
                    }
                    
                    renderStore(currentSettings, currentProducts, currentSections);
                    showToast('Preview loaded!', 'success');
                } else {
                    throw new Error('Failed to load data');
                }
            } catch (error) {
                console.error('Preview load error:', error);
                document.getElementById('store-content').innerHTML = \`
                    <div class="flex items-center justify-center min-h-screen">
                        <div class="text-center p-8">
                            <i class='bx bx-error-circle text-6xl text-red-400 mb-3'></i>
                            <h2 class="text-xl font-semibold text-gray-600 mb-2">Failed to Load Preview</h2>
                            <p class="text-gray-400">\${error.message}</p>
                            <button onclick="location.reload()" class="mt-4 px-4 py-2 bg-purple-500 text-white rounded-lg">Retry</button>
                        </div>
                    </div>
                \`;
            } finally {
                setLoading(false);
            }
        }
        
        function getDefaultSections() {
            return [
                { 
                    id: 'hero', 
                    type: 'hero', 
                    enabled: true, 
                    order: 1, 
                    content: { 
                        title: 'Welcome to my store', 
                        subtitle: '', 
                        buttonText: 'Shop Now', 
                        buttonLink: '#products' 
                    } 
                },
                { 
                    id: 'featured', 
                    type: 'featured', 
                    enabled: true, 
                    order: 2, 
                    title: 'Featured Products', 
                    limit: 6 
                },
                { 
                    id: 'products', 
                    type: 'products', 
                    enabled: true, 
                    order: 3, 
                    title: 'All Products', 
                    layout: 'grid',
                    limit: 12
                },
                { 
                    id: 'categories', 
                    type: 'categories', 
                    enabled: true, 
                    order: 4, 
                    title: 'Categories' 
                },
                { 
                    id: 'testimonials', 
                    type: 'testimonials', 
                    enabled: false, 
                    order: 5, 
                    title: 'What Customers Say',
                    limit: 6,
                    content: {
                        items: [
                            { text: "Amazing products! Highly recommend this store.", author: "Sarah Johnson", role: "Verified Buyer", rating: 5 },
                            { text: "Great quality and fast delivery. Will shop again!", author: "Michael Chen", role: "Repeat Customer", rating: 5 },
                            { text: "The support team is very helpful. 10/10 experience.", author: "Emily Davis", role: "Happy Customer", rating: 5 }
                        ]
                    }
                },
                { 
                    id: 'faq', 
                    type: 'faq', 
                    enabled: false, 
                    order: 6, 
                    title: 'Frequently Asked Questions',
                    content: {
                        items: [
                            { question: "How do I download my purchase?", answer: "After payment confirmation, you'll receive a download link via email and in your order history." },
                            { question: "What is your refund policy?", answer: "We offer a 30-day money-back guarantee on all digital products." },
                            { question: "How long does delivery take?", answer: "For digital products, delivery is instant. For services, delivery time varies." }
                        ]
                    }
                },
                { 
                    id: 'contact', 
                    type: 'contact', 
                    enabled: false, 
                    order: 7, 
                    title: 'Contact Me',
                    content: {
                        email: '',
                        phone: ''
                    }
                }
            ];
        }
        // Notify parent that preview is ready
        window.parent.postMessage({ type: 'preview-ready' }, '*');
        
        // Start loading
        loadInitialData();
        
        // Badge click to show info
        document.getElementById('preview-badge')?.addEventListener('click', () => {
            showToast('Live preview mode - changes appear instantly', 'info');
        });
        
        // Listen for hash changes
        window.addEventListener('hashchange', () => {
            const hash = window.location.hash;
            if (hash && hash.startsWith('#section-')) {
                const element = document.querySelector(\`[data-section-id="\${hash.replace('#section-', '')}"]\`);
                if (element) {
                    element.scrollIntoView({ behavior: 'smooth', block: 'start' });
                    element.classList.add('section-highlight');
                    setTimeout(() => element.classList.remove('section-highlight'), 600);
                }
            }
        });


        // ============================================
        // 🎯 دوال لمعاينة المنتجات وطرق الدفع فقط (موجودة بالفعل)
        // ============================================

        // عرض المنتجات فقط (بدون المتجر كامل)
        function renderProductsOnly(settings, products) {
            const currencySymbol = settings.currencySymbol || '$';
            const primaryColor = settings.primaryColor || '#8b5cf6';
            
            let html = '';
            html += '<div class="max-w-6xl mx-auto px-4 py-8">';
            html += '<div class="text-center mb-8">';
            html += '<div class="inline-flex items-center justify-center w-16 h-16 rounded-full mb-4" style="background: ' + primaryColor + '20">';
            html += '<i class="bx bx-package text-3xl" style="color: ' + primaryColor + '"></i>';
            html += '</div>';
            html += '<h1 class="text-2xl font-bold" style="color: ' + primaryColor + '">Products Preview</h1>';
            html += '<p class="text-gray-500 text-sm mt-2">This is how your products will appear in your store</p>';
            html += '<p class="text-xs text-gray-400 mt-1">Showing ' + products.length + ' product(s) | Click any product to edit</p>';
            html += '</div>';
            
            if (!products || products.length === 0) {
                html += '<div class="text-center py-12 bg-white dark:bg-gray-800 rounded-xl shadow-sm">';
                html += '<i class="bx bx-package text-5xl text-gray-300 mb-3"></i>';
                html += '<p class="text-gray-500">No products yet</p>';
                html += '<p class="text-sm text-gray-400 mt-1">Click "Add Product" in settings to start selling</p>';
                html += '</div>';
            } else {
                html += '<div class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-6">';
                
                products.slice(0, 12).forEach(function(product) {
                    var imageUrl = product.images && product.images[0] ? product.images[0] : '/assets/img/default-product.png';
                    var typeBadge = '';
                    var typeClass = '';
                    
                    if (product.type === 'digital') {
                        typeBadge = '📁 Digital';
                        typeClass = 'bg-blue-100 text-blue-700';
                    } else if (product.type === 'project') {
                        typeBadge = '💻 Project';
                        typeClass = 'bg-green-100 text-green-700';
                    } else {
                        typeBadge = '⚡ Service';
                        typeClass = 'bg-purple-100 text-purple-700';
                    }
                    
                    html += '<div class="product-card bg-white dark:bg-gray-800 rounded-xl overflow-hidden shadow-md hover:shadow-lg transition-all cursor-pointer" ';
                    html += 'onclick="window.parent.postMessage({ type: \'preview-click\', sectionType: \'product\', productId: \'' + product._id + '\' }, \'*\')">';
                    html += '<img src="' + imageUrl + '" class="w-full h-40 object-cover" onerror="this.src=\'/assets/img/default-product.png\'">';
                    html += '<div class="p-4">';
                    html += '<span class="text-xs px-2 py-0.5 rounded-full ' + typeClass + ' mb-2 inline-block">' + typeBadge + '</span>';
                    html += '<h3 class="font-semibold text-gray-800 dark:text-white truncate">' + escapeHtml(product.title) + '</h3>';
                    html += '<p class="text-sm text-gray-500 mt-1 line-clamp-2">' + escapeHtml((product.description || '').substring(0, 80)) + '</p>';
                    html += '<div class="flex justify-between items-center mt-3">';
                    html += '<span class="text-lg font-bold" style="color: ' + primaryColor + '">' + product.price + ' ' + currencySymbol + '</span>';
                    html += '<button class="px-3 py-1 rounded-lg text-sm text-white transition" style="background-color: ' + primaryColor + '">Buy Now</button>';
                    html += '</div></div></div>';
                });
                
                html += '</div>';
            }
            
            html += '<div class="mt-8 p-4 bg-blue-50 dark:bg-blue-900/20 rounded-xl text-center text-sm text-blue-700">';
            html += '<i class="bx bx-info-circle"></i> ' + products.length + ' product(s) available | Click any product to edit it';
            html += '</div></div>';
            
            var container = document.getElementById('store-content');
            if (container) {
                container.innerHTML = html;
                applyTheme(settings);
                
                var productCards = document.querySelectorAll('.product-card');
                for (var i = 0; i < productCards.length; i++) {
                    productCards[i].addEventListener('click', function(e) {
                        e.stopPropagation();
                    });
                }
                
                showToast('Products preview updated', 'success');
            }
        }

        // عرض طرق الدفع فقط
        function renderPaymentMethodsPreview(settings, paymentMethods) {
            var primaryColor = settings.primaryColor || '#8b5cf6';
            var methodsHtml = '';
            
            if (!paymentMethods || paymentMethods.length === 0) {
                methodsHtml = '<div class="text-center py-12 bg-white dark:bg-gray-800 rounded-xl shadow-sm">';
                methodsHtml += '<i class="bx bx-credit-card text-5xl text-gray-300 mb-3"></i>';
                methodsHtml += '<p class="text-gray-500">No payment methods added yet</p>';
                methodsHtml += '<p class="text-sm text-gray-400 mt-1">Click "Add Method" in settings to add payment options</p>';
                methodsHtml += '</div>';
            } else {
                var methodsArray = [];
                for (var i = 0; i < paymentMethods.length; i++) {
                    var method = paymentMethods[i];
                    var methodIcon = getMethodIcon(method.type);
                    var methodName = getMethodName(method.type);
                    var methodDesc = getMethodDescription(method.type);
                    var detailsHtml = '';
                    
                    if (method.type === 'vodafone' || method.type === 'instapay') {
                        detailsHtml = '<div class="mt-2 p-2 bg-gray-50 dark:bg-gray-700 rounded-lg">';
                        detailsHtml += '<p class="text-xs text-gray-500">Account Details:</p>';
                        detailsHtml += '<p class="text-sm font-mono font-medium">' + (method.details && method.details.phone ? method.details.phone : 'Not provided') + '</p>';
                        detailsHtml += '</div>';
                    } else if (method.type === 'paypal') {
                        detailsHtml = '<div class="mt-2 p-2 bg-gray-50 dark:bg-gray-700 rounded-lg">';
                        detailsHtml += '<p class="text-xs text-gray-500">PayPal Email:</p>';
                        detailsHtml += '<p class="text-sm font-mono">' + (method.details && method.details.email ? method.details.email : 'Not provided') + '</p>';
                        detailsHtml += '</div>';
                    } else if (method.type === 'bank') {
                        detailsHtml = '<div class="mt-2 p-2 bg-gray-50 dark:bg-gray-700 rounded-lg space-y-1">';
                        detailsHtml += '<p class="text-xs text-gray-500">Bank Account Details:</p>';
                        detailsHtml += '<p class="text-sm"><span class="text-gray-500">Bank:</span> ' + (method.details && method.details.bankName ? method.details.bankName : 'N/A') + '</p>';
                        detailsHtml += '<p class="text-sm"><span class="text-gray-500">Account Name:</span> ' + (method.details && method.details.accountName ? method.details.accountName : 'N/A') + '</p>';
                        detailsHtml += '<p class="text-sm"><span class="text-gray-500">Account Number:</span> <span class="font-mono">' + (method.details && method.details.accountNumber ? method.details.accountNumber : 'N/A') + '</span></p>';
                        detailsHtml += '</div>';
                    }
                    
                    var activeClass = method.isActive !== false ? 'bg-green-100 text-green-700' : 'bg-gray-100 text-gray-500';
                    var activeText = method.isActive !== false ? '✓ Active' : '✗ Inactive';
                    
                    methodsArray.push(
                        '<div class="bg-white dark:bg-gray-800 rounded-xl p-5 shadow-md border-l-4 transition-all hover:shadow-lg" style="border-left-color: ' + primaryColor + '">' +
                        '<div class="flex items-start gap-4">' +
                        '<div class="w-12 h-12 rounded-full flex items-center justify-center flex-shrink-0" style="background: ' + primaryColor + '20">' +
                        '<i class="bx ' + methodIcon + ' text-2xl" style="color: ' + primaryColor + '"></i>' +
                        '</div>' +
                        '<div class="flex-1">' +
                        '<div class="flex items-center justify-between flex-wrap gap-2">' +
                        '<h3 class="font-semibold text-lg">' + methodName + '</h3>' +
                        '<span class="text-xs px-2 py-1 rounded-full ' + activeClass + '">' + activeText + '</span>' +
                        '</div>' +
                        '<p class="text-sm text-gray-500 mt-1">' + methodDesc + '</p>' +
                        detailsHtml +
                        '</div></div></div>'
                    );
                }
                methodsHtml = methodsArray.join('');
            }
            
            var html = '';
            html += '<div class="max-w-2xl mx-auto px-4 py-8">';
            html += '<div class="text-center mb-8">';
            html += '<div class="inline-flex items-center justify-center w-16 h-16 rounded-full mb-4" style="background: ' + primaryColor + '20">';
            html += '<i class="bx bx-credit-card text-3xl" style="color: ' + primaryColor + '"></i>';
            html += '</div>';
            html += '<h1 class="text-2xl font-bold" style="color: ' + primaryColor + '">Payment Methods Preview</h1>';
            html += '<p class="text-gray-500 text-sm mt-2">This is how your payment options will appear to customers</p>';
            html += '<p class="text-xs text-gray-400 mt-1">' + paymentMethods.length + ' payment method(s) configured</p>';
            html += '</div>';
            html += '<div class="space-y-4">' + methodsHtml + '</div>';
            html += '<div class="mt-8 p-4 bg-yellow-50 dark:bg-yellow-900/20 rounded-xl text-center text-sm text-yellow-700">';
            html += '<i class="bx bx-info-circle"></i> Customers will see these payment options during checkout';
            html += '</div></div>';
            
            var container = document.getElementById('store-content');
            if (container) {
                container.innerHTML = html;
                applyTheme(settings);
                showToast('Payment methods preview updated', 'success');
            }
        }

        // دوال مساعدة لطرق الدفع
        function getMethodIcon(type) {
            var icons = {
                paypal: 'bxl-paypal',
                stripe: 'bx-credit-card',
                vodafone: 'bx-mobile-alt',
                instapay: 'bx-transfer-alt',
                bank: 'bx-bank'
            };
            return icons[type] || 'bx-money';
        }

        function getMethodName(type) {
            var names = {
                paypal: 'PayPal',
                stripe: 'Credit Card',
                vodafone: 'Vodafone Cash',
                instapay: 'InstaPay',
                bank: 'Bank Transfer'
            };
            return names[type] || type;
        }

        function getMethodDescription(type) {
            var descriptions = {
                paypal: 'Secure online payment via PayPal',
                stripe: 'Pay with credit or debit card',
                vodafone: 'Mobile wallet payment',
                instapay: 'Instant bank transfer',
                bank: 'Traditional bank transfer'
            };
            return descriptions[type] || '';
        }



        // ============================================
        // 🆕 SHORTCODES PROCESSING FOR PREVIEW
        // ============================================
        
        async function parseShortcodes(content, storeId) {
            if (!content || typeof content !== 'string') return content;
            if (!content.includes('[')) return content;
            
            try {
                const userToken = localStorage.getItem('userToken');
                const headers = {
                    'Content-Type': 'application/json'
                };
                if (userToken) {
                    headers['Authorization'] = 'Bearer ' + userToken;
                }
                
                const response = await fetch(window.location.origin + '/api/store/shortcodes/parse', {
                    method: 'POST',
                    headers: headers,
                    body: JSON.stringify({ content: content, storeId: storeId })
                });
                
                const data = await response.json();
                return data.parsedContent || content;
            } catch (error) {
                console.error('Error parsing shortcodes:', error);
                return content;
            }
        }
        
        // ============================================
        // 🆕 LOAD PAGE WITH SHORTCODES (للصفحات)
        // ============================================
        
        async function loadPreviewPage(slug, storeId) {
            try {
                const userToken = localStorage.getItem('userToken');
                const headers = {};
                if (userToken) {
                    headers['Authorization'] = 'Bearer ' + userToken;
                }
                
                const response = await fetch('/api/store/preview/page/' + slug, {
                    headers: headers
                });
                
                if (!response.ok) throw new Error('Page not found');
                
                const data = await response.json();
                const page = data.page;
                
                // معالجة Shortcodes في محتوى الصفحة
                let processedContent = page.content || '';
                if (processedContent.includes('[')) {
                    processedContent = await parseShortcodes(processedContent, storeId);
                }
                
                return {
                    ...page,
                    content: processedContent
                };
            } catch (error) {
                console.error('Error loading preview page:', error);
                return null;
            }
        }
        
        // ============================================
        // 🆕 RENDER PAGE WITH CSS/JS (للمعاينة)
        // ============================================
        
        function renderPreviewPage(page, settings) {
            const container = document.getElementById('store-content');
            if (!container) return;
            
            // إزالة أي CSS/JS مخصص سابق
            const oldStyle = document.getElementById('page-preview-style');
            if (oldStyle) oldStyle.remove();
            const oldScript = document.getElementById('page-preview-script');
            if (oldScript) oldScript.remove();
            
            const primaryColor = settings.primaryColor || '#8b5cf6';
            const escapedTitle = escapeHtml(page.title);
            const pageContent = page.content || '<p class="text-gray-500">No content available.</p>';
            
            // استخدام concatenation بدلاً من template literals
            var htmlContent = '<div class="max-w-4xl mx-auto p-6">' +
                '<div class="bg-white dark:bg-gray-800 rounded-2xl shadow-lg overflow-hidden">' +
                '<div class="p-6">' +
                '<h1 class="text-2xl md:text-3xl font-bold mb-4 text-gray-800 dark:text-white" style="color: ' + primaryColor + '">' + escapedTitle + '</h1>' +
                '<div class="page-content-wrapper prose max-w-none dark:prose-invert">' +
                pageContent +
                '</div>' +
                '</div>' +
                '</div>' +
                '</div>';
            
            container.innerHTML = htmlContent;
            
            // تطبيق CSS المخصص للصفحة
            if (page.css && page.css.trim()) {
                var style = document.createElement('style');
                style.id = 'page-preview-style';
                style.textContent = page.css;
                document.head.appendChild(style);
            }
            
            // تطبيق JS المخصص للصفحة
            if (page.js && page.js.trim()) {
                try {
                    var script = document.createElement('script');
                    script.id = 'page-preview-script';
                    script.textContent = page.js;
                    document.body.appendChild(script);
                } catch(e) {
                    console.error('Page preview JS error:', e);
                }
            }
            
            applyTheme(settings);
        }
        
        // ============================================
        // 🆕 RENDER THEME PREVIEW
        // ============================================
        
        async function renderThemePreview(storeId) {
            try {
                const userToken = localStorage.getItem('userToken');
                const headers = {};
                if (userToken) {
                    headers['Authorization'] = 'Bearer ' + userToken;
                }
                
                const response = await fetch('/api/store/theme/preview', {
                    headers: headers
                });
                
                if (response.ok) {
                    const data = await response.json();
                    if (data.hasCustomTheme) {
                        showToast('Previewing custom theme: ' + (data.theme.name || ''), 'info');
                        
                        // تطبيق الـ Header المخصص
                        if (data.theme.customTemplates && data.theme.customTemplates.header) {
                            const header = document.querySelector('.store-header');
                            if (header) {
                                const customHeader = document.createElement('div');
                                customHeader.className = 'custom-header-preview';
                                customHeader.innerHTML = data.theme.customTemplates.header;
                                header.parentNode.insertBefore(customHeader, header);
                                header.style.display = 'none';
                            }
                        }
                        
                        // تطبيق الـ Footer المخصص
                        if (data.theme.customTemplates && data.theme.customTemplates.footer) {
                            const footer = document.querySelector('.store-footer');
                            if (footer) {
                                const customFooter = document.createElement('div');
                                customFooter.className = 'custom-footer-preview';
                                customFooter.innerHTML = data.theme.customTemplates.footer;
                                footer.parentNode.insertBefore(customFooter, footer);
                                footer.style.display = 'none';
                            }
                        }
                    }
                }
            } catch (error) {
                console.error('Error loading theme preview:', error);
            }
        }
        
        // ============================================
        // 🆕 UPDATE PREVIEW BASED ON ACTIVE TAB
        // ============================================
        
        let currentPreviewMode = 'store'; // store, products, payment, page, theme
        
        function updatePreviewBasedOnTab(tabName, storeId, settings, products, sections, paymentMethods, pageSlug) {
            console.log('Updating preview for tab:', tabName);
            
            switch(tabName) {
                case 'products':
                    currentPreviewMode = 'products';
                    renderProductsOnly(settings, products);
                    break;
                    
                case 'payment':
                    currentPreviewMode = 'payment';
                    renderPaymentMethodsPreview(settings, paymentMethods);
                    break;
                    
                case 'pages':
                    currentPreviewMode = 'pages';
                    if (pageSlug) {
                        loadPreviewPage(pageSlug, storeId).then(function(page) {
                            if (page) {
                                renderPreviewPage(page, settings);
                            } else {
                                renderStore(settings, products, sections);
                            }
                        });
                    } else {
                        renderStore(settings, products, sections);
                    }
                    break;
                    
                case 'theme':
                    currentPreviewMode = 'theme';
                    renderStore(settings, products, sections);
                    renderThemePreview(storeId);
                    break;
                    
                case 'design':
                case 'basic':
                case 'shortcodes':
                default:
                    currentPreviewMode = 'store';
                    renderStore(settings, products, sections);
                    break;
            }
        }


    </script>
</body>
</html>
        `;
        
        res.setHeader('Content-Type', 'text/html');
        res.send(html);
        
    } catch (error) {
        console.error('Preview page error:', error);
        res.status(500).send(`
            <!DOCTYPE html>
            <html>
            <head><title>Preview Error</title></head>
            <body style="font-family: system-ui; text-align: center; padding: 50px;">
                <div style="max-width: 500px; margin: 0 auto;">
                    <i class='bx bx-error-circle' style="font-size: 64px; color: #ef4444;"></i>
                    <h2 style="margin: 20px 0 10px;">Preview Unavailable</h2>
                    <p style="color: #6b7280;">${error.message}</p>
                    <button onclick="location.reload()" style="margin-top: 20px; padding: 10px 24px; background: #8b5cf6; color: white; border: none; border-radius: 8px; cursor: pointer;">Retry</button>
                </div>
            </body>
            </html>
        `);
    }
});
// ============================================
// GET /api/store/preview - جلب بيانات المعاينة (للمالك فقط) - النسخة الآمنة
// ============================================
app.get('/api/store/preview', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;
        
        // 1️⃣ جلب إعدادات المتجر
        let storeSettings = await StoreSettings.findOne({ userId }).lean();
        if (!storeSettings) {
            storeSettings = new StoreSettings({ userId });
            await storeSettings.save();
            storeSettings = storeSettings.toObject();
        }
        
        // 2️⃣ جلب المنتجات النشطة
        let products = [];
        try {
            products = await Product.find({ 
                userId, 
                isActive: true 
            })
            .select('title description price type images tags salesCount averageRating reviews deliveryTime')
            .sort({ createdAt: -1 })
            .limit(50)
            .lean();
        } catch (err) {
            console.error('Products fetch error:', err);
            products = [];
        }
        
        // 3️⃣ جلب الأقسام (مع fallback آمن)
        let sections = [];
        try {
            if (storeSettings.pageBuilder && storeSettings.pageBuilder.sections) {
                if (Array.isArray(storeSettings.pageBuilder.sections)) {
                    sections = storeSettings.pageBuilder.sections;
                } else if (typeof storeSettings.pageBuilder.sections === 'object') {
                    sections = Object.values(storeSettings.pageBuilder.sections);
                }
            }
            
            // لو لسة مفيش أقسام، استخدم الأقسام الافتراضية
            if (!sections || sections.length === 0) {
                sections = [
                    { 
                        id: 'hero', 
                        type: 'hero', 
                        enabled: true, 
                        order: 1, 
                        content: { 
                            title: `Welcome to ${storeSettings.storeName || 'My Store'}`, 
                            subtitle: '', 
                            buttonText: 'Shop Now', 
                            buttonLink: '#products' 
                        } 
                    },
                    { 
                        id: 'products', 
                        type: 'products', 
                        enabled: true, 
                        order: 2, 
                        title: 'All Products', 
                        layout: 'grid', 
                        limit: 12 
                    }
                ];
            }
        } catch (err) {
            console.error('Sections error:', err);
            sections = [
                { id: 'products', type: 'products', enabled: true, order: 1, title: 'Products', layout: 'grid', limit: 12, content: {} }
            ];
        }
        
        // 4️⃣ جلب صفحات المتجر
        let customPages = [];
        try {
            customPages = await Page.find({ storeId: userId, isEnabled: true })
                .sort({ order: 1 })
                .select('slug title type order')
                .lean();
        } catch (err) {
            customPages = [];
        }
        
        const defaultPages = [
            { slug: 'products', title: 'Products', type: 'default', isEnabled: true, order: 1 },
            { slug: 'about', title: 'About Us', type: 'default', isEnabled: true, order: 2 },
            { slug: 'contact', title: 'Contact', type: 'default', isEnabled: true, order: 3 }
        ];
        
        const pages = [...defaultPages, ...customPages];
        
        // 5️⃣ جلب بيانات المستخدم
        let user = null;
        try {
            user = await User.findById(userId).select('username profile.nickname profile.avatar email').lean();
        } catch (err) {
            user = { username: 'user', email: '', profile: {} };
        }
        
        // 6️⃣ تحويل المنتجات لصيغة آمنة
        const safeProducts = (products || []).map(p => ({
            _id: p._id,
            title: p.title || 'Product',
            description: p.description || '',
            price: p.price || 0,
            type: p.type || 'digital',
            images: (p.images && Array.isArray(p.images)) ? p.images : [],
            tags: (p.tags && Array.isArray(p.tags)) ? p.tags : [],
            salesCount: p.salesCount || 0,
            averageRating: p.averageRating || 0,
            reviewsCount: (p.reviews && p.reviews.length) || 0,
            deliveryTime: p.deliveryTime || null
        }));
        
        // 7️⃣ تحويل الأقسام لصيغة آمنة
        const safeSections = sections.map(section => ({
            id: section.id || section._id || `section_${Date.now()}_${Math.random()}`,
            type: section.type || 'html',
            enabled: section.enabled !== false,
            order: typeof section.order === 'number' ? section.order : 0,
            title: section.title || null,
            limit: section.limit || null,
            layout: section.layout || null,
            content: section.content || {}
        }));
        
        // 8️⃣ إرسال الرد
        res.json({
            success: true,
            store: {
                id: userId,
                username: user?.username || 'user',
                nickname: user?.profile?.nickname || null,
                avatar: user?.profile?.avatar || null,
                storeName: storeSettings.storeName || user?.profile?.nickname || user?.username || 'My Store',
                storeLogo: storeSettings.storeLogo || null,
                storeBanner: storeSettings.storeBanner || null,
                storeDescription: storeSettings.storeDescription || '',
                contactEmail: storeSettings.contactEmail || user?.email || '',
                currency: storeSettings.currency || 'USD',
                currencySymbol: storeSettings.currencySymbol || '$',
                enabled: storeSettings.enabled !== false,
                productViewType: storeSettings.productViewType || 'modal'
            },
            settings: {
                primaryColor: storeSettings.primaryColor || '#3b82f6',
                secondaryColor: storeSettings.secondaryColor || '#8b5cf6',
                fontFamily: storeSettings.fontFamily || 'Inter, sans-serif',
                borderRadius: storeSettings.borderRadius || 16,
                shadowType: storeSettings.shadowType || 'md',
                animationType: storeSettings.animationType || 'lift',
                glassEffect: storeSettings.glassEffect || false,
                backgroundType: storeSettings.backgroundType || 'default',
                backgroundValue: storeSettings.backgroundValue || '',
                customCss: storeSettings.customCss || ''
            },
            pages: pages.map(page => ({
                _id: page._id,
                slug: page.slug,
                title: page.title,
                type: page.type,
                isEnabled: page.isEnabled !== false,
                order: page.order || 0
            })),
            products: safeProducts,
            sections: safeSections
        });
        
    } catch (error) {
        console.error('Preview API error:', error);
        // ✅ في حالة أي خطأ، ارجع بيانات افتراضية
        res.status(200).json({
            success: true,
            store: {
                id: req.user.userId,
                username: 'user',
                nickname: null,
                avatar: null,
                storeName: 'My Store',
                storeLogo: null,
                storeBanner: null,
                storeDescription: '',
                contactEmail: '',
                currency: 'USD',
                currencySymbol: '$',
                enabled: true,
                productViewType: 'modal'
            },
            settings: {
                primaryColor: '#3b82f6',
                secondaryColor: '#8b5cf6',
                fontFamily: 'Inter, sans-serif',
                borderRadius: 16,
                shadowType: 'md',
                animationType: 'lift',
                glassEffect: false,
                backgroundType: 'default',
                backgroundValue: '',
                customCss: ''
            },
            pages: [
                { slug: 'products', title: 'Products', type: 'default', isEnabled: true, order: 1 },
                { slug: 'about', title: 'About Us', type: 'default', isEnabled: true, order: 2 },
                { slug: 'contact', title: 'Contact', type: 'default', isEnabled: true, order: 3 }
            ],
            products: [],
            sections: [
                { id: 'products', type: 'products', enabled: true, order: 1, title: 'Products', layout: 'grid', limit: 12, content: {} }
            ]
        });
    }
});
// GET /api/store/preview-data - Modified to support nickname
app.get('/api/store/preview-data', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;
        
        // جلب إعدادات المتجر
        let storeSettings = await StoreSettings.findOne({ userId });
        if (!storeSettings) {
            storeSettings = new StoreSettings({ userId });
            await storeSettings.save();
        }
        
        // جلب المنتجات النشطة (كل المنتجات، مش محدودة)
        const products = await Product.find({ 
            userId, 
            isActive: true 
        }).sort({ createdAt: -1 });
        
        // جلب الأقسام مع ترتيبها
        let sections = storeSettings.pageBuilder?.sections || [];
        if (sections.length === 0) {
            sections = getDefaultSections();
        }
        
        // جلب إعدادات التصميم
        const designSettings = storeSettings.designSettings || {};
        
        // جلب بيانات المستخدم
        const user = await User.findById(userId).select('profile.nickname username');
        
        res.json({
            success: true,
            settings: {
                storeName: storeSettings.storeName || user?.profile?.nickname || user?.username || 'My Store',
                storeDescription: storeSettings.storeDescription || '',
                storeLogo: storeSettings.storeLogo || '',
                storeBanner: storeSettings.storeBanner || '',
                primaryColor: designSettings.primaryColor || storeSettings.primaryColor || '#3b82f6',
                secondaryColor: designSettings.secondaryColor || storeSettings.secondaryColor || '#8b5cf6',
                fontFamily: designSettings.fontFamily || storeSettings.fontFamily || 'Inter, sans-serif',
                borderRadius: designSettings.borderRadius || storeSettings.borderRadius || 16,
                shadowType: designSettings.shadowType || storeSettings.shadowType || 'md',
                animationType: designSettings.animationType || storeSettings.animationType || 'lift',
                glassEffect: designSettings.glassEffect || storeSettings.glassEffect || false,
                backgroundType: designSettings.backgroundType || storeSettings.backgroundType || 'default',
                backgroundValue: designSettings.backgroundValue || storeSettings.backgroundValue || '',
                zoomLevel: designSettings.zoomLevel || 100,
                customCss: designSettings.customCss || '',
                currency: storeSettings.currency || 'USD',
                currencySymbol: storeSettings.currencySymbol || '$',
                storeEnabled: storeSettings.enabled || false,
                nickname: user?.profile?.nickname || user?.username
            },
            products: products.map(p => ({
                _id: p._id,
                title: p.title,
                description: p.description,
                price: p.price,
                type: p.type,
                images: p.images || [],
                isActive: p.isActive,
                salesCount: p.salesCount || 0
            })),
            sections: sections.map(s => ({
                ...s,
                enabled: s.enabled !== false
            }))
        });
        
    } catch (error) {
        console.error('Preview data error:', error);
        res.status(500).json({ error: 'Failed to load preview data' });
    }
});

function getDefaultSections() {
    return [
        { 
            id: 'hero', 
            type: 'hero', 
            enabled: true, 
            order: 1, 
            content: { 
                title: 'Welcome to my store', 
                subtitle: '', 
                buttonText: 'Shop Now', 
                buttonLink: '#products' 
            } 
        },
        { 
            id: 'featured', 
            type: 'featured', 
            enabled: true, 
            order: 2, 
            title: 'Featured Products', 
            limit: 6 
        },
        { 
            id: 'products', 
            type: 'products', 
            enabled: true, 
            order: 3, 
            title: 'All Products', 
            layout: 'grid',
            limit: 12
        },
        { 
            id: 'categories', 
            type: 'categories', 
            enabled: true, 
            order: 4, 
            title: 'Categories' 
        },
        { 
            id: 'testimonials', 
            type: 'testimonials', 
            enabled: false, 
            order: 5, 
            title: 'What Customers Say',
            limit: 6,
            content: {
                items: [
                    { text: "Amazing products! Highly recommend this store.", author: "Sarah Johnson", role: "Verified Buyer", rating: 5 },
                    { text: "Great quality and fast delivery. Will shop again!", author: "Michael Chen", role: "Repeat Customer", rating: 5 },
                    { text: "The support team is very helpful. 10/10 experience.", author: "Emily Davis", role: "Happy Customer", rating: 5 }
                ]
            }
        },
        { 
            id: 'faq', 
            type: 'faq', 
            enabled: false, 
            order: 6, 
            title: 'Frequently Asked Questions',
            content: {
                items: [
                    { question: "How do I download my purchase?", answer: "After payment confirmation, you'll receive a download link via email and in your order history." },
                    { question: "What is your refund policy?", answer: "We offer a 30-day money-back guarantee on all digital products." },
                    { question: "How long does delivery take?", answer: "For digital products, delivery is instant. For services, delivery time varies." }
                ]
            }
        },
        { 
            id: 'contact', 
            type: 'contact', 
            enabled: false, 
            order: 7, 
            title: 'Contact Me',
            content: {
                email: '',
                phone: ''
            }
        }
    ];
}
// POST /api/store/preview/update - تحديث بيانات المعاينة (لإرسالها للـ iframe)
app.post('/api/store/preview/update', authenticateToken, async (req, res) => {
    try {
        const { settings, sections } = req.body;
        
        // ✅ بناء كائن التحديث بشكل صحيح مع الحقول الجديدة
        const updateData = {};
        
        // تحديث إعدادات المتجر الأساسية
        if (settings) {
            updateData.storeName = settings.storeName || '';
            updateData.storeDescription = settings.storeDescription || '';
            updateData.storeLogo = settings.storeLogo || '';
            updateData.storeBanner = settings.storeBanner || '';
            updateData.currency = settings.currency || 'USD';
            
            // رمز العملة
            const currencySymbols = {
                'USD': '$', 'EUR': '€', 'GBP': '£', 'EGP': 'ج.م', 'SAR': '﷼', 'AED': 'د.إ'
            };
            updateData.currencySymbol = currencySymbols[settings.currency] || '$';
            
            // 🎨 إعدادات التصميم (الحقول الجديدة)
            if (settings.primaryColor !== undefined) updateData.primaryColor = settings.primaryColor;
            if (settings.secondaryColor !== undefined) updateData.secondaryColor = settings.secondaryColor;
            if (settings.fontFamily !== undefined) updateData.fontFamily = settings.fontFamily;
            if (settings.borderRadius !== undefined) updateData.borderRadius = settings.borderRadius;
            if (settings.shadowType !== undefined) updateData.shadowType = settings.shadowType;
            if (settings.animationType !== undefined) updateData.animationType = settings.animationType;
            if (settings.glassEffect !== undefined) updateData.glassEffect = settings.glassEffect;
            if (settings.backgroundType !== undefined) updateData.backgroundType = settings.backgroundType;
            if (settings.backgroundValue !== undefined) updateData.backgroundValue = settings.backgroundValue;
            if (settings.customCss !== undefined) updateData.customCss = settings.customCss;
            
            // zoomLevel - إذا كنت تريد إضافته للموديل
            if (settings.zoomLevel !== undefined) updateData.zoomLevel = settings.zoomLevel;
            
            // طرق الدفع إذا وجدت
            if (settings.paymentMethods !== undefined) updateData.paymentMethods = settings.paymentMethods;
            
            // روابط التواصل الاجتماعي
            if (settings.socialLinks !== undefined) updateData.socialLinks = settings.socialLinks;
        }
        
        // تحديث الأقسام
        if (sections !== undefined) {
            updateData['pageBuilder.sections'] = sections;
        }
        
        updateData.updatedAt = Date.now();
        
        // ✅ تنفيذ التحديث
        const updatedSettings = await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            updateData,
            { upsert: true, new: true }
        );
        
        console.log('✅ Preview settings updated for user:', req.user.userId);
        console.log('📦 Updated fields:', Object.keys(updateData));
        
        res.json({ 
            success: true, 
            settings: updatedSettings,
            message: 'Preview settings saved successfully'
        });
        
    } catch (error) {
        console.error('Preview update error:', error);
        res.status(500).json({ error: 'Failed to update preview: ' + error.message });
    }
});

// ============================================
// 🎯 STORE PREVIEW ENDPOINTS - FIX
// ============================================

// GET /api/store/preview/products - جلب جميع منتجات المتجر للمعاينة
app.get('/api/store/preview/products', authenticateToken, async (req, res) => {
    try {
        const products = await Product.find({ 
            userId: req.user.userId, 
            isActive: true 
        }).sort({ createdAt: -1 }).limit(50);
        
        res.json({
            success: true,
            products: products.map(p => ({
                _id: p._id,
                title: p.title,
                description: p.description,
                price: p.price,
                type: p.type,
                images: p.images || [],
                isActive: p.isActive,
                salesCount: p.salesCount || 0
            }))
        });
        
    } catch (error) {
        console.error('Error fetching preview products:', error);
        res.status(500).json({ error: 'Failed to fetch products' });
    }
});

// GET /api/store/preview/settings - جلب إعدادات المتجر للمعاينة
app.get('/api/store/preview/settings', authenticateToken, async (req, res) => {
    try {
        let storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        if (!storeSettings) {
            storeSettings = new StoreSettings({ userId: req.user.userId });
            await storeSettings.save();
        }
        
        const designSettings = storeSettings.designSettings || {};
        
        res.json({
            success: true,
            settings: {
                storeName: storeSettings.storeName || '',
                storeDescription: storeSettings.storeDescription || '',
                storeLogo: storeSettings.storeLogo || '',
                storeBanner: storeSettings.storeBanner || '',
                primaryColor: designSettings.primaryColor || storeSettings.primaryColor || '#3b82f6',
                secondaryColor: designSettings.secondaryColor || storeSettings.secondaryColor || '#8b5cf6',
                fontFamily: designSettings.fontFamily || storeSettings.fontFamily || 'Inter, sans-serif',
                borderRadius: designSettings.borderRadius || storeSettings.borderRadius || 16,
                shadowType: designSettings.shadowType || storeSettings.shadowType || 'md',
                animationType: designSettings.animationType || storeSettings.animationType || 'lift',
                glassEffect: designSettings.glassEffect || storeSettings.glassEffect || false,
                backgroundType: designSettings.backgroundType || storeSettings.backgroundType || 'default',
                backgroundValue: designSettings.backgroundValue || storeSettings.backgroundValue || '',
                zoomLevel: designSettings.zoomLevel || 100,
                customCss: designSettings.customCss || '',
                currency: storeSettings.currency || 'USD',
                currencySymbol: storeSettings.currencySymbol || '$',
                storeEnabled: storeSettings.enabled || false
            }
        });
        
    } catch (error) {
        console.error('Error fetching preview settings:', error);
        res.status(500).json({ error: 'Failed to load settings' });
    }
});

// GET /api/store/preview/sections - جلب أقسام المتجر للمعاينة
app.get('/api/store/preview/sections', authenticateToken, async (req, res) => {
    try {
        let storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        if (!storeSettings) {
            storeSettings = new StoreSettings({ userId: req.user.userId });
            await storeSettings.save();
        }
        
        let sections = storeSettings.pageBuilder?.sections || [];
        if (sections.length === 0) {
            sections = [
                { id: 'hero', type: 'hero', enabled: true, order: 1, content: { title: 'Welcome to my store', subtitle: '', buttonText: 'Shop Now', buttonLink: '#products' } },
                { id: 'featured', type: 'featured', enabled: true, order: 2, title: 'Featured Products', limit: 6 },
                { id: 'products', type: 'products', enabled: true, order: 3, title: 'All Products', layout: 'grid' },
                { id: 'categories', type: 'categories', enabled: true, order: 4, title: 'Categories' }
            ];
        }
        
        res.json({ success: true, sections });
        
    } catch (error) {
        console.error('Error fetching preview sections:', error);
        res.status(500).json({ error: 'Failed to load sections' });
    }
});

// ============================================
// 🎯 PRODUCT PREVIEW PAGE
// ============================================

// ============================================
// GET /api/store/preview/pages - جلب صفحات المتجر للمعاينة (للمالك فقط)
// ============================================
app.get('/api/store/preview/pages', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;
        
        // الصفحات الافتراضية
        const defaultPages = [
            { slug: 'products', title: 'Products', type: 'default', isEnabled: true, order: 1 },
            { slug: 'about', title: 'About Us', type: 'default', isEnabled: true, order: 2 },
            { slug: 'contact', title: 'Contact', type: 'default', isEnabled: true, order: 3 }
        ];
        
        // الصفحات المخصصة من قاعدة البيانات
        const customPages = await Page.find({ storeId: userId, isEnabled: true })
            .sort({ order: 1 })
            .select('slug title type order');
        
        res.json({
            success: true,
            pages: [...defaultPages, ...customPages]
        });
        
    } catch (error) {
        console.error('Error fetching preview pages:', error);
        res.status(500).json({ error: 'Failed to fetch pages' });
    }
});


// ============================================
// GET /api/store/preview/follow-status - حالة متابعة المتجر للمعاينة (للمالك فقط)
// ============================================
app.get('/api/store/preview/follow-status', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;
        const followersCount = await StoreFollow.countDocuments({ storeId: userId });
        
        res.json({ 
            success: true, 
            followersCount,
            isFollowing: false  // لا يمكن للمالك متابعة متجره بنفسه
        });
        
    } catch (error) {
        console.error('Error fetching preview follow status:', error);
        res.json({ success: true, followersCount: 0, isFollowing: false });
    }
});

// ============================================
// POST /api/store/reset-template - إزالة القالب المطبق والعودة للوضع الافتراضي
// ============================================
app.post('/api/store/reset-template', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;
        
        // إزالة appliedTemplate من StoreSettings
        await StoreSettings.findOneAndUpdate(
            { userId },
            { 
                $unset: { appliedTemplate: 1 },
                $set: { updatedAt: Date.now() }
            }
        );
        
        // إعادة تعيين القالب النشط إلى الافتراضي
        await StoreTheme.findOneAndUpdate(
            { userId },
            { 
                $set: { 
                    isActive: false,
                    updatedAt: Date.now()
                }
            }
        );
        
        // إنشاء قالب افتراضي جديد
        const defaultTheme = new StoreTheme({ userId });
        await defaultTheme.save();
        
        console.log(`✅ Template reset for user ${userId}`);
        
        res.json({
            success: true,
            message: 'Template reset successfully. Store restored to default layout.'
        });
        
    } catch (error) {
        console.error('Error resetting template:', error);
        res.status(500).json({ error: 'Failed to reset template' });
    }
});
// ============================================
// GET /api/store/preview/page/:slug - جلب صفحة معاينة (للمالك فقط)
// ============================================
app.get('/api/store/preview/page/:slug', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;
        const { slug } = req.params;
        
        // جلب إعدادات المتجر
        const storeSettings = await StoreSettings.findOne({ userId });
        if (!storeSettings) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        // جلب بيانات المستخدم
        const user = await User.findById(userId).select('username profile.nickname profile.avatar email');
        
        // الصفحات الافتراضية
        if (slug === 'about') {
            return res.json({
                success: true,
                page: {
                    slug: 'about',
                    title: 'About Us',
                    content: storeSettings?.storeDescription || 'Welcome to our store! We offer the best products and services.',
                    type: 'default',
                    seo: {
                        title: `About ${storeSettings?.storeName || user.profile?.nickname || user.username} | MGZon Store`,
                        description: storeSettings?.storeDescription?.substring(0, 160) || 'Learn more about our store and what we offer.'
                    }
                }
            });
        }
        
        if (slug === 'contact') {
            return res.json({
                success: true,
                page: {
                    slug: 'contact',
                    title: 'Contact Us',
                    content: `
                        <div class="contact-info space-y-4">
                            <div class="flex items-center gap-3">
                                <i class='bx bx-envelope text-2xl text-blue-500'></i>
                                <div>
                                    <p class="font-medium">Email</p>
                                    <a href="mailto:${storeSettings?.contactEmail || user.email}" class="text-blue-600 hover:underline">${storeSettings?.contactEmail || user.email}</a>
                                </div>
                            </div>
                            ${storeSettings?.socialLinks?.instagram ? `
                            <div class="flex items-center gap-3">
                                <i class='bx bxl-instagram text-2xl text-pink-500'></i>
                                <div>
                                    <p class="font-medium">Instagram</p>
                                    <a href="${storeSettings.socialLinks.instagram}" target="_blank" class="text-blue-600 hover:underline">${storeSettings.socialLinks.instagram.split('/').pop()}</a>
                                </div>
                            </div>
                            ` : ''}
                            ${storeSettings?.socialLinks?.facebook ? `
                            <div class="flex items-center gap-3">
                                <i class='bx bxl-facebook text-2xl text-blue-600'></i>
                                <div>
                                    <p class="font-medium">Facebook</p>
                                    <a href="${storeSettings.socialLinks.facebook}" target="_blank" class="text-blue-600 hover:underline">Facebook Page</a>
                                </div>
                            </div>
                            ` : ''}
                            ${storeSettings?.socialLinks?.twitter ? `
                            <div class="flex items-center gap-3">
                                <i class='bx bxl-twitter text-2xl text-sky-500'></i>
                                <div>
                                    <p class="font-medium">Twitter</p>
                                    <a href="${storeSettings.socialLinks.twitter}" target="_blank" class="text-blue-600 hover:underline">${storeSettings.socialLinks.twitter.split('/').pop()}</a>
                                </div>
                            </div>
                            ` : ''}
                        </div>
                        <div class="mt-8">
                            <form id="store-contact-form" class="space-y-4">
                                <input type="text" id="contact-name" placeholder="Your Name" class="w-full p-3 border rounded-lg">
                                <input type="email" id="contact-email" placeholder="Your Email" class="w-full p-3 border rounded-lg">
                                <textarea id="contact-message" rows="4" placeholder="Your Message" class="w-full p-3 border rounded-lg"></textarea>
                                <button type="submit" class="btn-primary px-6 py-3 rounded-lg">Send Message</button>
                            </form>
                        </div>
                    `,
                    type: 'default',
                    seo: {
                        title: `Contact ${storeSettings?.storeName || user.profile?.nickname || user.username} | MGZon Store`,
                        description: `Get in touch with ${storeSettings?.storeName || user.profile?.nickname || user.username}. Send us a message and we'll get back to you soon.`
                    }
                }
            });
        }
        
        // ✅ الصفحات المخصصة (اللي المستخدم يضيفها)
        const page = await Page.findOne({ storeId: userId, slug, isEnabled: true });
        if (!page) {
            return res.status(404).json({ error: 'Page not found' });
        }
        
        res.json({
            success: true,
            page: {
                slug: page.slug,
                title: page.title,
                content: page.content || '<p>No content available.</p>',
                type: page.type,
                seo: page.seo || {}
            }
        });
        
    } catch (error) {
        console.error('Error fetching preview page:', error);
        res.status(500).json({ error: 'Failed to fetch page' });
    }
});


// GET /shop/preview/product/:productId - صفحة معاينة المنتج
app.get('/shop/preview/product/:productId', authenticateToken, async (req, res) => {
    try {
        const productId = req.params.productId;
        
        // جلب المنتج من قاعدة البيانات
        const product = await Product.findOne({ 
            _id: productId, 
            userId: req.user.userId 
        });
        
        if (!product) {
            return res.status(404).send(`
                <!DOCTYPE html>
                <html>
                <head><title>Product Not Found</title></head>
                <body style="font-family: system-ui; text-align: center; padding: 50px;">
                    <i class='bx bx-package' style="font-size: 64px; color: #ef4444;"></i>
                    <h2 style="margin: 20px 0 10px;">Product Not Found</h2>
                    <p style="color: #6b7280;">The product you're looking for doesn't exist.</p>
                    <button onclick="window.parent.postMessage({ type: 'close-product-preview' }, '*')" style="margin-top: 20px; padding: 10px 24px; background: #8b5cf6; color: white; border: none; border-radius: 8px; cursor: pointer;">Close Preview</button>
                </body>
                </html>
            `);
        }
        
        // جلب إعدادات المتجر
        let storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        if (!storeSettings) {
            storeSettings = new StoreSettings({ userId: req.user.userId });
            await storeSettings.save();
        }
        
        const designSettings = storeSettings.designSettings || {};
        
        const html = `
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Preview: ${escapeHtml(product.title)} - MGZon Store</title>
    <script src="https://cdn.tailwindcss.com"></script>
    <link href="https://cdn.jsdelivr.net/npm/boxicons@2.1.4/css/boxicons.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Poppins:wght@400;500;600;700&family=Roboto:wght@400;500;700&display=swap" rel="stylesheet">
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        
        body {
            font-family: '${designSettings.fontFamily || 'Inter'}', sans-serif;
            background: ${designSettings.backgroundColor || '#f9fafb'};
            min-height: 100vh;
        }
        
        .preview-badge {
            position: fixed;
            bottom: 20px;
            right: 20px;
            background: linear-gradient(135deg, #8b5cf6, #6366f1);
            color: white;
            padding: 8px 16px;
            border-radius: 9999px;
            font-size: 12px;
            font-weight: 500;
            z-index: 9999;
            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
            cursor: pointer;
        }
        
        .close-btn {
            position: fixed;
            top: 20px;
            right: 20px;
            background: white;
            color: #1f2937;
            width: 40px;
            height: 40px;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            cursor: pointer;
            z-index: 9999;
            box-shadow: 0 2px 8px rgba(0,0,0,0.15);
            transition: all 0.2s;
        }
        
        .close-btn:hover {
            transform: scale(1.1);
            background: #f3f4f6;
        }
        
        .product-image {
            transition: transform 0.3s ease;
            cursor: zoom-in;
        }
        
        .product-image:hover {
            transform: scale(1.02);
        }
        
        .quantity-btn {
            transition: all 0.2s;
            cursor: pointer;
        }
        
        .quantity-btn:hover {
            background: #e5e7eb;
        }
        
        /* Custom scrollbar */
        ::-webkit-scrollbar { width: 6px; }
        ::-webkit-scrollbar-track { background: #f1f1f1; }
        ::-webkit-scrollbar-thumb { background: #cbd5e1; border-radius: 3px; }
        ::-webkit-scrollbar-thumb:hover { background: #8b5cf6; }
        
        @keyframes fadeIn {
            from { opacity: 0; transform: translateY(20px); }
            to { opacity: 1; transform: translateY(0); }
        }
        
        .product-container {
            animation: fadeIn 0.4s ease-out;
        }
    </style>
</head>
<body>
    <div class="close-btn" onclick="closePreview()">
        <i class='bx bx-x text-2xl'></i>
    </div>
    
    <div class="max-w-6xl mx-auto px-4 py-8 product-container">
        <!-- Product Details -->
        <div class="bg-white dark:bg-gray-800 rounded-2xl shadow-lg overflow-hidden">
            <div class="grid grid-cols-1 md:grid-cols-2 gap-8 p-6 md:p-8">
                <!-- Product Images -->
                <div class="space-y-4">
                    <div class="bg-gray-100 dark:bg-gray-700 rounded-2xl overflow-hidden">
                        <img id="main-image" src="${escapeHtml(product.images?.[0] || '/assets/img/default-product.png')}" 
                             alt="${escapeHtml(product.title)}" 
                             class="product-image w-full h-80 md:h-96 object-cover"
                             onerror="this.src='/assets/img/default-product.png'">
                    </div>
                    ${product.images && product.images.length > 1 ? `
                        <div class="flex gap-3 overflow-x-auto pb-2">
                            ${product.images.map((img, idx) => `
                                <div class="w-20 h-20 rounded-lg overflow-hidden cursor-pointer border-2 ${idx === 0 ? 'border-purple-500' : 'border-transparent'}" 
                                     onclick="changeImage('${escapeHtml(img)}', this)">
                                    <img src="${escapeHtml(img)}" class="w-full h-full object-cover" onerror="this.src='/assets/img/default-product.png'">
                                </div>
                            `).join('')}
                        </div>
                    ` : ''}
                </div>
                
                <!-- Product Info -->
                <div class="space-y-4">
                    <!-- Type Badge -->
                    <div>
                        <span class="inline-flex items-center gap-1 px-3 py-1 rounded-full text-sm font-medium
                            ${product.type === 'digital' ? 'bg-blue-100 text-blue-700' : 
                              product.type === 'project' ? 'bg-green-100 text-green-700' : 
                              'bg-purple-100 text-purple-700'}">
                            <i class='bx ${product.type === 'digital' ? 'bx-download' : 
                                      product.type === 'project' ? 'bx-code-alt' : 
                                      'bx-briefcase'}'></i>
                            ${product.type === 'digital' ? 'Digital Product' : 
                              product.type === 'project' ? 'Project' : 'Service'}
                        </span>
                    </div>
                    
                    <!-- Title -->
                    <h1 class="text-2xl md:text-3xl font-bold text-gray-800 dark:text-white">${escapeHtml(product.title)}</h1>
                    
                    <!-- Rating -->
                    <div class="flex items-center gap-2">
                        <div class="flex text-yellow-400">
                            ${Array(5).fill().map((_, i) => 
                                `<i class='bx ${i < Math.floor(product.averageRating || 0) ? 'bxs-star' : (i < (product.averageRating || 0) ? 'bxs-star-half' : 'bx-star')}'></i>`
                            ).join('')}
                        </div>
                        <span class="text-sm text-gray-500">(${product.reviews?.length || 0} reviews)</span>
                    </div>
                    
                    <!-- Price -->
                    <div class="border-t border-b py-4">
                        <div class="flex items-baseline gap-2">
                            <span class="text-3xl font-bold" style="color: ${designSettings.primaryColor || '#8b5cf6'}">
                                ${product.price} ${storeSettings.currencySymbol || '$'}
                            </span>
                            ${product.oldPrice ? `
                                <span class="text-lg text-gray-400 line-through">${product.oldPrice} ${storeSettings.currencySymbol || '$'}</span>
                                <span class="text-sm text-green-500">Save ${Math.round(((product.oldPrice - product.price) / product.oldPrice) * 100)}%</span>
                            ` : ''}
                        </div>
                        ${product.type === 'digital' ? `
                            <p class="text-sm text-green-600 mt-1 flex items-center gap-1">
                                <i class='bx bx-check-circle'></i> Instant delivery after payment
                            </p>
                        ` : product.type === 'service' && product.deliveryTime ? `
                            <p class="text-sm text-gray-500 mt-1 flex items-center gap-1">
                                <i class='bx bx-time'></i> Delivery: ${escapeHtml(product.deliveryTime)}
                            </p>
                        ` : ''}
                    </div>
                    
                    <!-- Description -->
                    <div>
                        <h3 class="font-semibold text-gray-700 dark:text-gray-300 mb-2">Description</h3>
                        <div class="text-gray-600 dark:text-gray-400 whitespace-pre-wrap leading-relaxed">
                            ${escapeHtml(product.description)}
                        </div>
                    </div>
                    
                    <!-- Tags -->
                    ${product.tags && product.tags.length > 0 ? `
                        <div>
                            <h3 class="font-semibold text-gray-700 dark:text-gray-300 mb-2">Tags</h3>
                            <div class="flex flex-wrap gap-2">
                                ${product.tags.map(tag => `
                                    <span class="px-2 py-1 bg-gray-100 dark:bg-gray-700 rounded-full text-xs">#${escapeHtml(tag)}</span>
                                `).join('')}
                            </div>
                        </div>
                    ` : ''}
                    
                    <!-- Quantity (for services/products that need quantity) -->
                    ${product.type === 'service' ? `
                        <div>
                            <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">Quantity</label>
                            <div class="flex items-center gap-3">
                                <div class="flex items-center border rounded-lg">
                                    <button class="quantity-btn px-3 py-2 border-r" onclick="updateQuantity(-1)">-</button>
                                    <input type="number" id="quantity" value="1" min="1" max="99" class="w-16 text-center border-0 focus:ring-0">
                                    <button class="quantity-btn px-3 py-2 border-l" onclick="updateQuantity(1)">+</button>
                                </div>
                                <span class="text-sm text-gray-500">Available</span>
                            </div>
                        </div>
                    ` : ''}
                    
                    <!-- Buy Button -->
                    <div class="pt-4 space-y-3">
                        <button id="buy-now-btn" 
                                class="w-full py-3 rounded-xl font-semibold transition-all transform hover:scale-[1.02] active:scale-[0.98]"
                                style="background: ${designSettings.primaryColor || '#8b5cf6'}; color: white;">
                            <i class='bx bx-cart-add mr-2'></i>
                            ${product.type === 'digital' ? 'Buy & Download Now' : 
                              product.type === 'service' ? 'Purchase Service' : 
                              'Buy Now'}
                        </button>
                        <button id="test-payment-btn" 
                                class="w-full py-2 rounded-lg text-sm border transition hover:bg-gray-50"
                                style="border-color: ${designSettings.primaryColor || '#8b5cf6'}; color: ${designSettings.primaryColor || '#8b5cf6'}">
                            <i class='bx bx-credit-card mr-1'></i> Test Payment Flow
                        </button>
                    </div>
                    
                    <!-- Store Info -->
                    <div class="pt-4 border-t text-center text-sm text-gray-500">
                        <p>Sold by <strong>${escapeHtml(storeSettings.storeName || 'Store Owner')}</strong></p>
                        <p class="text-xs mt-1">100% secure payment | Money-back guarantee</p>
                    </div>
                </div>
            </div>
        </div>
        
        <!-- Related Products (for future enhancement) -->
        <div id="related-products" class="mt-8">
            <!-- سيتم إضافة منتجات ذات صلة لاحقاً -->
        </div>
    </div>
    
    <div class="preview-badge" onclick="showInfo()">
        <i class='bx bx-show-alt mr-1'></i> Product Preview Mode
    </div>
    
    <script>
        const primaryColor = '${designSettings.primaryColor || '#8b5cf6'}';
        const productId = '${productId}';
        const productPrice = ${product.price};
        const currencySymbol = '${storeSettings.currencySymbol || '$'}';
        
        // Change main image on thumbnail click
        function changeImage(src, element) {
            document.getElementById('main-image').src = src;
            document.querySelectorAll('.border-purple-500').forEach(el => {
                el.classList.remove('border-purple-500');
                el.classList.add('border-transparent');
            });
            element.classList.remove('border-transparent');
            element.classList.add('border-purple-500');
        }
        
        // Update quantity
        function updateQuantity(delta) {
            const input = document.getElementById('quantity');
            let value = parseInt(input.value) || 1;
            value = Math.max(1, Math.min(99, value + delta));
            input.value = value;
        }
        
        // Close preview and notify parent
        function closePreview() {
            window.parent.postMessage({ type: 'close-product-preview' }, '*');
        }
        
        // Show info toast
        function showInfo() {
            showToast('This is a preview. Changes will appear when you save your product.', 'info');
        }
        
        // Toast notification
        function showToast(message, type = 'success') {
            let toast = document.getElementById('preview-toast');
            if (!toast) {
                toast = document.createElement('div');
                toast.id = 'preview-toast';
                toast.className = 'fixed bottom-24 right-4 bg-gray-800 text-white px-4 py-2 rounded-lg text-sm z-[10000] transition-opacity duration-300 opacity-0';
                toast.style.backgroundColor = type === 'error' ? '#ef4444' : '#1f2937';
                document.body.appendChild(toast);
            }
            toast.innerHTML = message;
            toast.classList.remove('opacity-0');
            toast.classList.add('opacity-100');
            setTimeout(() => {
                toast.classList.remove('opacity-100');
                toast.classList.add('opacity-0');
            }, 3000);
        }
        
        // Buy button click
        document.getElementById('buy-now-btn')?.addEventListener('click', () => {
            const quantity = parseInt(document.getElementById('quantity')?.value || 1);
            const total = productPrice * quantity;
            showToast(\`Demo: Would add \${quantity} item(s) to cart. Total: \${total} \${currencySymbol}\`, 'info');
            
            // Send to parent for actual cart update
            window.parent.postMessage({
                type: 'add-to-cart',
                productId: productId,
                quantity: quantity
            }, '*');
        });
        
        // Test payment button
        document.getElementById('test-payment-btn')?.addEventListener('click', () => {
            showToast('This is a demo payment flow. In production, you would be redirected to checkout.', 'info');
            
            window.parent.postMessage({
                type: 'test-checkout',
                productId: productId,
                productPrice: productPrice,
                productTitle: '${escapeHtml(product.title)}'
            }, '*');
        });
        
        // Handle keyboard shortcuts
        document.addEventListener('keydown', (e) => {
            if (e.key === 'Escape') {
                closePreview();
            }
        });
        
        // Notify parent that preview is ready
        window.parent.postMessage({ type: 'product-preview-ready', productId: productId }, '*');
        
        // Apply theme colors from parent
        window.addEventListener('message', (event) => {
            if (event.data?.type === 'apply-theme' && event.data.colors) {
                const style = document.createElement('style');
                style.textContent = \`
                    .btn-primary { background: \${event.data.colors.primary} !important; }
                    .text-primary { color: \${event.data.colors.primary} !important; }
                    .border-primary { border-color: \${event.data.colors.primary} !important; }
                \`;
                document.head.appendChild(style);
            }
        });
    </script>
</body>
</html>
        `;
        
        res.setHeader('Content-Type', 'text/html');
        res.send(html);
        
    } catch (error) {
        console.error('Product preview error:', error);
        res.status(500).send(`
            <!DOCTYPE html>
            <html>
            <head><title>Preview Error</title></head>
            <body style="font-family: system-ui; text-align: center; padding: 50px;">
                <i class='bx bx-error-circle' style="font-size: 64px; color: #ef4444;"></i>
                <h2 style="margin: 20px 0 10px;">Preview Error</h2>
                <p style="color: #6b7280;">${escapeHtml(error.message)}</p>
                <button onclick="window.parent.postMessage({ type: 'close-product-preview' }, '*')" style="margin-top: 20px; padding: 10px 24px; background: #8b5cf6; color: white; border: none; border-radius: 8px; cursor: pointer;">Close</button>
            </body>
            </html>
        `);
    }
});

// GET /api/store/preview/product/:productId - جلب منتج واحد للمعاينة
app.get('/api/store/preview/product/:productId', authenticateToken, async (req, res) => {
    try {
        const product = await Product.findOne({ 
            _id: req.params.productId, 
            userId: req.user.userId 
        });
        
        if (!product) {
            return res.status(404).json({ error: 'Product not found' });
        }
        
        res.json({
            success: true,
            product: {
                _id: product._id,
                title: product.title,
                description: product.description,
                price: product.price,
                type: product.type,
                images: product.images || [],
                tags: product.tags || [],
                deliveryTime: product.deliveryTime,
                fileUrl: product.fileUrl,
                averageRating: product.averageRating || 0,
                reviewsCount: product.reviews?.length || 0,
                salesCount: product.salesCount || 0,
                isActive: product.isActive
            }
        });
        
    } catch (error) {
        console.error('Error fetching product preview:', error);
        res.status(500).json({ error: 'Failed to load product' });
    }
});


// ============================================
// 🏪 PUBLIC STORE ENDPOINTS (للمستخدمين العاديين)
// ============================================



// ========== APIs مخصصة لصاحب المتجر (مع توكن) ==========

// GET /api/store/my/pages - جلب صفحات المتجر (للمالك) مع كامل البيانات
app.get('/api/store/my/pages', authenticateToken, async (req, res) => {
    try {
        const userId = req.user.userId;
        
        const customPages = await Page.find({ storeId: userId })
            .sort({ order: 1 });
        
        const defaultPages = [
            { 
                slug: 'products', 
                title: 'Products', 
                type: 'default', 
                isDefault: true,
                isEnabled: true, 
                order: 1,
                canEdit: false,
                canDelete: false,
                canToggle: false,
                visibility: 'public',
                content: '',
                css: '',
                js: ''
            },
            { 
                slug: 'about', 
                title: 'About Us', 
                type: 'default', 
                isDefault: true,
                isEnabled: true, 
                order: 2,
                canEdit: true,
                canDelete: false,
                canToggle: true,
                visibility: 'public',
                content: '',
                css: '',
                js: ''
            },
            { 
                slug: 'contact', 
                title: 'Contact', 
                type: 'default', 
                isDefault: true,
                isEnabled: true, 
                order: 3,
                canEdit: true,
                canDelete: false,
                canToggle: true,
                visibility: 'public',
                content: '',
                css: '',
                js: ''
            }
        ];
        
        let allPages = [...defaultPages];
        
        for (const customPage of customPages) {
            const existingIndex = allPages.findIndex(p => p.slug === customPage.slug);
            const hasShortcodes = customPage.content && customPage.content.includes('[');
            
            if (existingIndex !== -1) {
                allPages[existingIndex] = {
                    ...allPages[existingIndex],
                    _id: customPage._id,
                    content: customPage.content || '',
                    css: customPage.css || '',
                    js: customPage.js || '',
                    seo: customPage.seo || {},
                    uploadedFile: customPage.uploadedFile,
                    canEdit: true,
                    canDelete: false,
                    canToggle: true,
                    hasShortcodes: hasShortcodes
                };
            } else {
                allPages.push({
                    _id: customPage._id,
                    slug: customPage.slug,
                    title: customPage.title,
                    content: customPage.content || '',
                    css: customPage.css || '',
                    js: customPage.js || '',
                    type: customPage.type,
                    isEnabled: customPage.isEnabled,
                    order: customPage.order,
                    seo: customPage.seo || {},
                    uploadedFile: customPage.uploadedFile,
                    canEdit: true,
                    canDelete: true,
                    canToggle: true,
                    hasShortcodes: hasShortcodes
                });
            }
        }
        
        allPages.sort((a, b) => (a.order || 0) - (b.order || 0));
        
        const storeSettings = await StoreSettings.findOne({ userId });
        const user = await User.findById(userId).select('profile.nickname username');
        const nickname = storeSettings?.storeName || user?.profile?.nickname || user?.username;
        
        // ✅ جلب الـ Shortcodes المتاحة للمستخدم
        const availableShortcodes = await StoreShortcode.find({ 
            userId: userId, 
            isActive: true 
        }).select('name displayName description parameters');
        
        const builtinShortcodes = StoreShortcode.getBuiltinShortcodes();
        
        res.json({ 
            success: true, 
            pages: allPages,
            storeNickname: nickname || 'store',
            shortcodes: {
                available: availableShortcodes.map(sc => ({
                    name: sc.name,
                    displayName: sc.displayName,
                    description: sc.description,
                    example: `[${sc.name}${sc.parameters?.length ? ' limit="6"' : ''}]`,
                    parameters: sc.parameters
                })),
                builtin: builtinShortcodes.map(sc => ({
                    name: sc.name,
                    displayName: sc.displayName,
                    description: sc.description,
                    example: `[${sc.name}${sc.parameters?.length ? ' limit="6"' : ''}]`
                }))
            }
        });
    } catch (error) {
        console.error('Error fetching my pages:', error);
        res.status(500).json({ error: 'Failed to fetch pages' });
    }
});


// POST /api/store/my/pages - إنشاء صفحة جديدة
app.post('/api/store/my/pages', authenticateToken, async (req, res) => {
    try {
        const { slug, title, content, seo, order } = req.body;
        
        // التحقق من وجود slug
        if (!slug || !title) {
            return res.status(400).json({ error: 'Slug and title are required' });
        }
        
        // التحقق من عدم وجود slug مكرر
        const existingPage = await Page.findOne({ storeId: req.user.userId, slug });
        if (existingPage) {
            return res.status(400).json({ error: 'Page with this slug already exists' });
        }
        
        const page = new Page({
            storeId: req.user.userId,
            slug: slug.toLowerCase().replace(/[^a-z0-9-]/g, '-'),
            title,
            content: content || '',
            type: 'custom',
            isEnabled: true,
            order: order || 0,
            seo: seo || {}
        });
        
        await page.save();
        
        res.status(201).json({ success: true, page });
    } catch (error) {
        console.error('Error creating page:', error);
        res.status(500).json({ error: 'Failed to create page' });
    }
});



// ============================================
// POST /api/store/my/pages/preview - معاينة صفحة (كاملة ومتطابقة مع المتجر)
// ============================================
app.post('/api/store/my/pages/preview', authenticateToken, async (req, res) => {
    try {
        const { title, content, css, js } = req.body;
        
        // ✅ جلب إعدادات المتجر للمستخدم الحالي
        const storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        const user = await User.findById(req.user.userId);
        
        const nickname = user?.profile?.nickname || user?.username || 'store';
        const storeName = storeSettings?.storeName || nickname;
        const storeLogo = storeSettings?.storeLogo || '';
        const storeBanner = storeSettings?.storeBanner || '';
        
        // ✅ إعدادات التصميم
        const primaryColor = storeSettings?.primaryColor || '#3b82f6';
        const secondaryColor = storeSettings?.secondaryColor || '#8b5cf6';
        const fontFamily = storeSettings?.fontFamily || 'Inter, sans-serif';
        const borderRadius = storeSettings?.borderRadius || 16;
        const shadowType = storeSettings?.shadowType || 'md';
        const animationType = storeSettings?.animationType || 'lift';
        const glassEffect = storeSettings?.glassEffect || false;
        const backgroundType = storeSettings?.backgroundType || 'default';
        const backgroundValue = storeSettings?.backgroundValue || '';
        const customCss = storeSettings?.customCss || '';
        
        // ✅ تنظيف المحتوى من الأكواد الضارة
        const cleanContent = content?.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '') || '<p class="text-gray-500">No content yet.</p>';
        const cleanCss = css?.replace(/expression\(/gi, '').replace(/behavior\s*:/gi, '') || '';
        const cleanJs = js?.replace(/document\.write/gi, '').replace(/eval\(/gi, '') || '';
        
        // ✅ بناء خلفية الصفحة
        let backgroundStyle = '';
        if (backgroundType === 'gradient' && backgroundValue) {
            backgroundStyle = `background: ${backgroundValue}; background-attachment: fixed;`;
        } else if (backgroundType === 'image' && backgroundValue) {
            backgroundStyle = `background: url(${backgroundValue}) center/cover fixed;`;
        } else if (backgroundType === 'dots') {
            backgroundStyle = `background-image: radial-gradient(circle, #cbd5e1 1px, transparent 1px); background-size: 24px 24px;`;
        } else if (backgroundType === 'grid') {
            backgroundStyle = `background-image: linear-gradient(to right, #e5e7eb 1px, transparent 1px), linear-gradient(to bottom, #e5e7eb 1px, transparent 1px); background-size: 24px 24px;`;
        } else if (backgroundType === 'cross') {
            backgroundStyle = `background-image: linear-gradient(45deg, #cbd5e1 1px, transparent 1px), linear-gradient(-45deg, #cbd5e1 1px, transparent 1px); background-size: 24px 24px;`;
        } else {
            backgroundStyle = 'background: #f9fafb;';
        }
        
        // ✅ تأثير الظل
        const shadowMap = {
            none: 'none',
            sm: '0 1px 2px 0 rgba(0,0,0,0.05)',
            md: '0 4px 6px -1px rgba(0,0,0,0.1)',
            lg: '0 10px 15px -3px rgba(0,0,0,0.1)',
            xl: '0 20px 25px -5px rgba(0,0,0,0.1)'
        };
        const shadowValue = shadowMap[shadowType] || shadowMap.md;
        
        // ✅ تأثير التحويم
        const hoverClass = animationType === 'lift' ? 'hover-lift' : 
                          animationType === 'scale' ? 'hover-scale' : 
                          animationType === 'glow' ? 'hover-glow' : '';
        
        const glassClass = glassEffect ? 'glass-effect' : '';
        
        const html = `<!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
            <title>${escapeHtml(title || 'Preview')} - ${escapeHtml(storeName)}</title>
            
            <!-- Tailwind CSS -->
            <script src="https://cdn.tailwindcss.com"></script>
            <link href="https://cdn.jsdelivr.net/npm/boxicons@2.1.4/css/boxicons.min.css" rel="stylesheet">
            <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=Poppins:wght@400;500;600;700&family=Roboto:wght@400;500;700&family=Playfair+Display:wght@400;500;600;700&display=swap" rel="stylesheet">
            
            <style>
                /* Store Theme Variables */
                :root {
                    --primary-color: ${primaryColor};
                    --secondary-color: ${secondaryColor};
                    --border-radius: ${borderRadius}px;
                    --shadow-value: ${shadowValue};
                }
                
                /* Reset & Base Styles */
                * {
                    margin: 0;
                    padding: 0;
                    box-sizing: border-box;
                }
                
                body {
                    font-family: '${fontFamily.replace(/'/g, '')}', 'Inter', sans-serif;
                    min-height: 100vh;
                    transition: all 0.2s ease;
                    ${backgroundStyle}
                }
                
                body.dark {
                    background: #000000;
                }
                
                body.dark .bg-white {
                    background-color: #1f2937 !important;
                }
                
                body.dark .text-gray-600 {
                    color: #9ca3af !important;
                }
                
                body.dark .border {
                    border-color: #374151 !important;
                }
                
                body.dark .bg-gray-50 {
                    background-color: #111827 !important;
                }
                
                body.dark .bg-gray-100 {
                    background-color: #374151 !important;
                }
                
                /* Glass Effect */
                .glass-effect {
                    background: rgba(255, 255, 255, 0.1);
                    backdrop-filter: blur(10px);
                    border: 1px solid rgba(255, 255, 255, 0.2);
                }
                
                body.dark .glass-effect {
                    background: rgba(0, 0, 0, 0.3);
                }
                
                /* Hover Effects */
                .hover-lift:hover {
                    transform: translateY(-4px);
                    transition: transform 0.2s ease;
                }
                
                .hover-scale:hover {
                    transform: scale(1.02);
                    transition: transform 0.2s ease;
                }
                
                .hover-glow:hover {
                    box-shadow: 0 0 15px rgba(139, 92, 246, 0.3);
                    transition: box-shadow 0.2s ease;
                }
                
                /* Border Radius */
                .rounded-card {
                    border-radius: ${borderRadius}px;
                }
                
                .preview-container {
                    max-width: 1200px;
                    margin: 0 auto;
                    padding: 20px;
                }
                
                /* Fade In Animation */
                @keyframes fadeInPreview {
                    from { opacity: 0; transform: translateY(10px); }
                    to { opacity: 1; transform: translateY(0); }
                }
                
                .preview-container {
                    animation: fadeInPreview 0.3s ease-out;
                }
                
                /* Store Custom CSS */
                ${customCss}
                
                /* Page Custom CSS */
                ${cleanCss}
            </style>
            
            <style>
                /* Dark mode helper */
                body.dark .text-gray-600 { color: #9ca3af !important; }
                body.dark .border { border-color: #374151 !important; }
                body.dark .bg-gray-50 { background-color: #111827 !important; }
                body.dark .hover\\:bg-gray-50:hover { background-color: #1f2937 !important; }
                
                /* Button primary */
                .btn-primary {
                    background-color: ${primaryColor};
                    transition: opacity 0.2s;
                }
                .btn-primary:hover {
                    opacity: 0.9;
                }
                
                /* Text primary */
                .text-primary {
                    color: ${primaryColor};
                }
                
                /* Border primary */
                .border-primary {
                    border-color: ${primaryColor};
                }
            </style>
        </head>
        <body class="preview-theme">
            <!-- Store Header -->
            <header class="fixed top-0 w-full bg-white dark:bg-gray-800 shadow-md z-50 transition-colors">
                <nav class="max-w-7xl mx-auto px-4 py-3 flex justify-between items-center">
                    <a href="/shop/${nickname}" class="text-xl font-bold flex items-center gap-2">
                        ${storeLogo ? `<img src="${storeLogo}" class="w-8 h-8 rounded-full object-cover" onerror="this.src='/assets/img/default-store.png'">` : ''}
                        <span style="color: ${primaryColor}">${escapeHtml(storeName)}</span>
                    </a>
                    <div class="flex items-center gap-4">
                        <a href="/shop/${nickname}" class="text-gray-600 dark:text-gray-300 hover:text-blue-500 transition">Store</a>
                        <a href="/" class="text-gray-600 dark:text-gray-300 hover:text-blue-500 transition">Home</a>
                        <button id="preview-theme-toggle" class="text-gray-600 dark:text-gray-300 hover:text-blue-500 transition p-2 rounded-full">
                            <i class='bx bx-moon text-xl'></i>
                        </button>
                    </div>
                </nav>
            </header>
            
            <!-- Store Banner (if exists) -->
            ${storeBanner ? `
            <div class="relative h-32 md:h-48 overflow-hidden mt-16">
                <img src="${storeBanner}" alt="Store Banner" class="w-full h-full object-cover" onerror="this.src='/assets/img/default-banner.jpg'">
                <div class="absolute inset-0 bg-gradient-to-t from-black/50 to-transparent"></div>
            </div>
            ` : '<div class="h-16"></div>'}
            
            <!-- Page Content -->
            <main class="pb-12 px-4 mt-4">
                <div class="preview-container">
                    <div class="bg-white dark:bg-gray-800 rounded-card shadow-sm p-6 ${glassClass} ${hoverClass}" style="box-shadow: var(--shadow-value);">
                        ${cleanContent}
                    </div>
                </div>
            </main>
            
            <!-- Store Footer -->
            <footer class="bg-white dark:bg-gray-800 border-t dark:border-gray-700 py-6 text-center text-sm text-gray-500">
                <p>© ${new Date().getFullYear()} ${escapeHtml(storeName)}. All rights reserved.</p>
                <p class="text-xs mt-1">Powered by MGZon</p>
            </footer>
            
            <script>
                // Theme toggle for preview
                (function() {
                    const savedTheme = localStorage.getItem('preview_theme') || 'light';
                    if (savedTheme === 'dark') {
                        document.body.classList.add('dark');
                    }
                    
                    const themeToggle = document.getElementById('preview-theme-toggle');
                    if (themeToggle) {
                        // Update icon based on current theme
                        const icon = themeToggle.querySelector('i');
                        if (icon) {
                            icon.className = document.body.classList.contains('dark') ? 'bx bx-sun text-xl' : 'bx bx-moon text-xl';
                        }
                        
                        themeToggle.addEventListener('click', () => {
                            document.body.classList.toggle('dark');
                            const isDark = document.body.classList.contains('dark');
                            localStorage.setItem('preview_theme', isDark ? 'dark' : 'light');
                            
                            // Update icon
                            if (icon) {
                                icon.className = isDark ? 'bx bx-sun text-xl' : 'bx bx-moon text-xl';
                            }
                        });
                    }
                })();
                
                // Page Custom JavaScript
                try {
                    ${cleanJs}
                } catch(e) {
                    console.error('Preview JS error:', e);
                }
            </script>
        </body>
        </html>`;
        
        res.setHeader('Content-Type', 'text/html');
        res.send(html);
        
    } catch (error) {
        console.error('Preview generation error:', error);
        res.status(500).json({ error: 'Failed to generate preview: ' + error.message });
    }
});

// ============================================
// 4. Page Statistics
// ============================================
app.get('/api/store/my/pages/stats', authenticateToken, async (req, res) => {
    try {
        const pages = await Page.find({ storeId: req.user.userId })
            .select('title slug type stats content')
            .sort({ 'stats.views': -1 });
        
        const totalViews = pages.reduce((sum, p) => sum + (p.stats?.views || 0), 0);
        
        // ✅ حساب عدد الصفحات التي تحتوي على Shortcodes
        let pagesWithShortcodes = 0;
        let totalShortcodesUsed = 0;
        
        for (const page of pages) {
            if (page.content && page.content.includes('[')) {
                pagesWithShortcodes++;
                // حساب عدد الـ Shortcodes في الصفحة
                const matches = page.content.match(/\[(\w+)(?:\s+[^\]]*)?\]/g);
                if (matches) {
                    totalShortcodesUsed += matches.length;
                }
            }
        }
        
        // ✅ جلب أكثر الـ Shortcodes استخداماً
        const shortcodeStats = await StoreShortcode.aggregate([
            { $match: { userId: req.user.userId } },
            { $project: { name: 1, 'stats.usageCount': 1 } },
            { $sort: { 'stats.usageCount': -1 } },
            { $limit: 5 }
        ]);
        
        res.json({
            success: true,
            stats: {
                totalPages: pages.length,
                totalViews: totalViews,
                pagesWithShortcodes: pagesWithShortcodes,
                totalShortcodesUsed: totalShortcodesUsed,
                mostViewed: pages.slice(0, 5).map(p => ({
                    _id: p._id,
                    title: p.title,
                    slug: p.slug,
                    type: p.type,
                    views: p.stats?.views || 0,
                    hasShortcodes: !!(p.content && p.content.includes('['))
                })),
                pages: pages.map(p => ({
                    _id: p._id,
                    title: p.title,
                    slug: p.slug,
                    type: p.type,
                    views: p.stats?.views || 0,
                    uniqueViews: p.stats?.uniqueViews || 0,
                    hasShortcodes: !!(p.content && p.content.includes('['))
                })),
                topShortcodes: shortcodeStats
            }
        });
    } catch (error) {
        console.error('Error fetching page stats:', error);
        res.status(500).json({ error: 'Failed to fetch stats' });
    }
});


// ============================================
// POST /api/store/my/pages/upload - رفع ملف HTML (محدث بالكامل)
// يدعم: استخراج SEO، CSS، JS، Shortcodes، ومعالجة الصور
// ============================================
app.post('/api/store/my/pages/upload', authenticateToken, uploadHTML.single('file'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ error: 'No file uploaded' });
        }
        
        const file = req.file;
        let fileContent = file.buffer.toString('utf8');
        
        // ✅ التحقق من حجم الملف (حد أقصى 5MB للـ HTML)
        if (file.size > 5 * 1024 * 1024) {
            return res.status(400).json({ error: 'File size must be less than 5MB' });
        }
        
        // ============================================
        // ✅ 1. استخراج title (حد أقصى 100 حرف)
        // ============================================
        let title = file.originalname.replace(/\.(html|htm)$/i, '');
        const titleMatch = fileContent.match(/<title>(.*?)<\/title>/i);
        if (titleMatch) {
            title = titleMatch[1].trim();
        }
        if (title.length > 100) {
            title = title.substring(0, 97) + '...';
        }
        
        // ============================================
        // ✅ 2. استخراج meta description
        // ============================================
        let description = '';
        const descMatch = fileContent.match(/<meta\s+name=["']description["']\s+content=["'](.*?)["']/i);
        if (descMatch) {
            description = descMatch[1].trim();
            if (description.length > 160) {
                description = description.substring(0, 157) + '...';
            }
        }
        
        // ============================================
        // ✅ 3. استخراج meta keywords
        // ============================================
        let keywords = '';
        const keywordsMatch = fileContent.match(/<meta\s+name=["']keywords["']\s+content=["'](.*?)["']/i);
        if (keywordsMatch) {
            keywords = keywordsMatch[1].trim();
            if (keywords.length > 200) {
                keywords = keywords.substring(0, 197) + '...';
            }
        }
        
        // ============================================
        // ✅ 4. استخراج Open Graph meta tags
        // ============================================
        let ogImage = '';
        let ogTitle = '';
        let ogDescription = '';
        
        const ogImageMatch = fileContent.match(/<meta\s+property=["']og:image["']\s+content=["'](.*?)["']/i);
        if (ogImageMatch) ogImage = ogImageMatch[1].trim();
        
        const ogTitleMatch = fileContent.match(/<meta\s+property=["']og:title["']\s+content=["'](.*?)["']/i);
        if (ogTitleMatch) ogTitle = ogTitleMatch[1].trim();
        
        const ogDescMatch = fileContent.match(/<meta\s+property=["']og:description["']\s+content=["'](.*?)["']/i);
        if (ogDescMatch) ogDescription = ogDescMatch[1].trim();
        
        // ============================================
        // ✅ 5. استخراج CSS
        // ============================================
        let extractedCss = '';
        
        // من <style> tags
        const styleMatches = fileContent.match(/<style[^>]*>([\s\S]*?)<\/style>/gi);
        if (styleMatches) {
            extractedCss = styleMatches.map(s => s.replace(/<\/?style[^>]*>/gi, '')).join('\n');
        }
        
        // من <link rel="stylesheet">
        const linkMatches = fileContent.match(/<link[^>]*rel=["']stylesheet["'][^>]*href=["']([^"']+)["'][^>]*>/gi);
        if (linkMatches) {
            for (const link of linkMatches) {
                const hrefMatch = link.match(/href=["']([^"']+)["']/i);
                if (hrefMatch && !hrefMatch[1].startsWith('http')) {
                    // روابط داخلية فقط، نتجاهل الـ CDN
                    extractedCss += `/* External: ${hrefMatch[1]} */\n`;
                }
            }
        }
        
        // ============================================
        // ✅ 6. استخراج JavaScript
        // ============================================
        let extractedJs = '';
        const scriptMatches = fileContent.match(/<script[^>]*>([\s\S]*?)<\/script>/gi);
        if (scriptMatches) {
            for (const script of scriptMatches) {
                // تجاهل script src (روابط خارجية)
                if (!script.includes('src=')) {
                    let jsContent = script.replace(/<\/?script[^>]*>/gi, '');
                    // ✅ إزالة الكود الخطير
                    jsContent = jsContent.replace(/document\.write/gi, '');
                    jsContent = jsContent.replace(/eval\(/gi, '');
                    jsContent = jsContent.replace(/Function\(/gi, '');
                    extractedJs += jsContent + '\n';
                }
            }
        }
        
        // ============================================
        // ✅ 7. استخراج HTML content (من body)
        // ============================================
        let extractedHtml = '';
        
        const bodyMatch = fileContent.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
        if (bodyMatch) {
            extractedHtml = bodyMatch[1];
        } else {
            const htmlMatch = fileContent.match(/<html[^>]*>([\s\S]*?)<\/html>/i);
            if (htmlMatch) {
                let fullHtml = htmlMatch[1];
                extractedHtml = fullHtml.replace(/<head[^>]*>[\s\S]*?<\/head>/i, '');
            } else {
                extractedHtml = fileContent;
            }
        }
        
        // ✅ تنقية المحتوى من الـ XSS والأكواد الضارة
        extractedHtml = extractedHtml
            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
            .replace(/<iframe\b[^>]*>/gi, '')
            .replace(/<object\b[^>]*>/gi, '')
            .replace(/<embed\b[^>]*>/gi, '')
            .replace(/\s(on\w+)=("[^"]*"|'[^']*'|[^\s>]+)/gi, '')
            .replace(/javascript:/gi, '')
            .replace(/vbscript:/gi, '');
        
        // ✅ كشف وجود Shortcodes في المحتوى
        const hasShortcodes = /\[(\w+)(?:\s+[^\]]*)?\]/.test(extractedHtml);
        const shortcodesFound = [];
        const shortcodeMatches = extractedHtml.match(/\[(\w+)(?:\s+[^\]]*)?\]/g);
        if (shortcodeMatches) {
            const uniqueShortcodes = [...new Set(shortcodeMatches.map(m => {
                const match = m.match(/\[(\w+)/);
                return match ? match[1] : null;
            }).filter(Boolean))];
            shortcodesFound.push(...uniqueShortcodes);
        }
        
        // ============================================
        // ✅ 8. استخراج slug من اسم الملف
        // ============================================
        let slug = file.originalname
            .replace(/\.(html|htm)$/i, '')
            .toLowerCase()
            .replace(/[^a-z0-9-]/g, '-')
            .replace(/-+/g, '-')
            .replace(/^-|-$/g, '');
        
        if (!slug) slug = 'page';
        if (slug.length > 50) slug = slug.substring(0, 50);
        
        // ✅ التأكد من عدم وجود slug مكرر
        let finalSlug = slug;
        let counter = 1;
        while (await Page.findOne({ storeId: req.user.userId, slug: finalSlug })) {
            finalSlug = `${slug}-${counter}`;
            counter++;
        }
        
        // ============================================
        // ✅ 9. معالجة الصور في المحتوى (تحويل الروابط النسبية إلى مطلقة)
        // ============================================
        // نترك الصور كما هي لأنها ستُعرض من نفس المجال
        
        // ============================================
        // ✅ 10. حفظ الصفحة في قاعدة البيانات
        // ============================================
        const page = new Page({
            storeId: req.user.userId,
            slug: finalSlug,
            title: title,
            content: extractedHtml,
            css: extractedCss,
            js: extractedJs,
            type: 'uploaded',
            isEnabled: true,
            order: await Page.countDocuments({ storeId: req.user.userId }),
            uploadedFile: {
                filename: finalSlug,
                originalName: file.originalname,
                fileSize: file.size,
                mimeType: file.mimetype,
                uploadedAt: new Date()
            },
            seo: {
                title: title.length > 70 ? title.substring(0, 67) + '...' : title,
                description: description,
                keywords: keywords,
                ogImage: ogImage,
                noindex: false,
                nofollow: false
            }
        });
        
        await page.save();
        
        // ✅ تهيئة Shortcodes للمستخدم إذا لم تكن موجودة
        if (hasShortcodes) {
            await ShortcodeService.initializeUserShortcodes(req.user.userId);
        }
        
        console.log(`✅ Page uploaded: ${finalSlug} by user ${req.user.userId}`);
        if (hasShortcodes) {
            console.log(`📝 Shortcodes detected: ${shortcodesFound.join(', ')}`);
        }
        
        // ============================================
        // ✅ 11. إرسال الرد مع معلومات إضافية
        // ============================================
        res.status(201).json({ 
            success: true, 
            page: {
                _id: page._id,
                slug: page.slug,
                title: page.title,
                type: page.type,
                hasShortcodes: hasShortcodes,
                shortcodesFound: shortcodesFound,
                contentLength: extractedHtml.length,
                cssLength: extractedCss.length,
                jsLength: extractedJs.length
            },
            message: `${file.originalname} uploaded successfully!${hasShortcodes ? ' Shortcodes detected and will be processed dynamically.' : ''}`,
            tips: hasShortcodes ? [
                '📝 Shortcodes detected! They will be processed when the page is viewed.',
                '💡 You can use shortcodes like [products limit="6"] to display products dynamically.',
                '🔧 Edit the page to see all available shortcodes.'
            ] : [
                '💡 You can add shortcodes like [products limit="6"] to display products dynamically.',
                '🔧 Go to the page editor to add interactive elements.'
            ]
        });
        
    } catch (error) {
        console.error('Error uploading page:', error);
        
        // ✅ معالجة أخطاء التحقق من الصحة
        if (error.name === 'ValidationError') {
            const errors = Object.values(error.errors).map(e => e.message);
            return res.status(400).json({ 
                error: 'Validation failed', 
                details: errors,
                message: errors[0]
            });
        }
        
        // ✅ معالجة أخطاء MongoDB
        if (error.code === 11000) {
            return res.status(409).json({ 
                error: 'Duplicate page slug', 
                message: 'A page with this URL already exists. Please rename your file.'
            });
        }
        
        res.status(500).json({ 
            error: 'Failed to upload page', 
            message: error.message,
            details: process.env.NODE_ENV === 'development' ? error.stack : undefined
        });
    }
});



// POST /api/store/my/pages/upload-zip - رفع ملف ZIP ذكي (Optimized)
app.post(
  '/api/store/my/pages/upload-zip',
  authenticateToken,
  uploadHTML.single('file'),
  async (req, res) => {
    try {
      if (!req.file) {
        return res.status(400).json({ error: 'No file uploaded' });
      }

      const file = req.file;

      if (!file.originalname.endsWith('.zip')) {
        return res.status(400).json({ error: 'Only ZIP files are allowed' });
      }

      const zip = new AdmZip(file.buffer);
      const zipEntries = zip.getEntries();

      const createdPages = [];
      const extractedFiles = {
        htmlFiles: [],
        cssFiles: [],
        jsFiles: [],
        imageFiles: [],
        otherFiles: []
      };

      // ============================================
      // 1️⃣ تصنيف الملفات
      // ============================================
      for (const entry of zipEntries) {
        if (entry.isDirectory) continue;

        const fileName = entry.entryName;
        const ext = fileName.split('.').pop().toLowerCase();
        const content = entry.getData();

        if (ext === 'html' || ext === 'htm') {
          extractedFiles.htmlFiles.push({
            name: fileName,
            content: content.toString('utf8'),
            size: content.length
          });
        } else if (ext === 'css') {
          extractedFiles.cssFiles.push({
            name: fileName,
            content: content.toString('utf8'),
            size: content.length
          });
        } else if (ext === 'js') {
          extractedFiles.jsFiles.push({
            name: fileName,
            content: content.toString('utf8'),
            size: content.length
          });
        } else if (['jpg','jpeg','png','gif','svg','webp'].includes(ext)) {
          extractedFiles.imageFiles.push({
            name: fileName,
            content,
            ext
          });
        }
      }

      // ============================================
      // 🔥 تجهيز slugs مرة واحدة (مهم جداً للأداء)
      // ============================================
      const existingPages = await Page.find(
        { storeId: req.user.userId },
        { slug: 1 }
      );

      const existingSlugs = new Set(existingPages.map(p => p.slug));

      const generateUniqueSlug = (base) => {
        let slug = base;
        let counter = 1;
        while (existingSlugs.has(slug)) {
          slug = `${base}-${counter++}`;
        }
        existingSlugs.add(slug);
        return slug;
      };

      // ============================================
      // ⚡ رفع الصور بالتوازي (أهم تحسين)
      // ============================================
      const uploadedImages = await Promise.all(
        extractedFiles.imageFiles.map(async (img) => {
          try {
            const b64 = img.content.toString('base64');
            const dataURI = `data:image/${img.ext};base64,${b64}`;

            const result = await cloudinary.uploader.upload(dataURI, {
              folder: `StorePages/${req.user.userId}/images`,
              public_id: img.name.replace(/[^a-z0-9.-]/gi, '-'),
              resource_type: 'image'
            });

            return {
              name: img.name,
              url: result.secure_url
            };
          } catch (err) {
            console.error('Image upload failed:', err.message);
            return null;
          }
        })
      );

      const validImages = uploadedImages.filter(Boolean);

      // ============================================
      // 2️⃣ سيناريو ملف واحد
      // ============================================
      if (
        extractedFiles.htmlFiles.length === 1 &&
        (extractedFiles.cssFiles.length || extractedFiles.jsFiles.length)
      ) {
        const htmlFile = extractedFiles.htmlFiles[0];

        const css = extractedFiles.cssFiles.map(c => c.content).join('\n');
        const js = extractedFiles.jsFiles.map(j => j.content).join('\n');

        const title =
          (htmlFile.content.match(/<title>(.*?)<\/title>/i)?.[1]) ||
          htmlFile.name.replace(/\.html$/i, '');

        const body =
          htmlFile.content.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] ||
          htmlFile.content;

        const slug = generateUniqueSlug(
          htmlFile.name.replace(/\.html$/i, '').toLowerCase().replace(/[^a-z0-9-]/g, '-')
        );

        const page = new Page({
          storeId: req.user.userId,
          slug,
          title: title.substring(0, 100),
          content: body,
          css,
          js,
          type: 'uploaded',
          isEnabled: true,
          order: existingPages.length
        });

        await page.save();
        createdPages.push({ slug: page.slug, title: page.title });
      }

      // ============================================
      // 3️⃣ عدة صفحات HTML
      // ============================================
      else if (extractedFiles.htmlFiles.length > 1) {
        for (const htmlFile of extractedFiles.htmlFiles) {
          const base = htmlFile.name.replace(/\.html$/i, '');

          const css = extractedFiles.cssFiles
            .filter(c => c.name.includes(base))
            .map(c => c.content)
            .join('\n');

          const js = extractedFiles.jsFiles
            .filter(j => j.name.includes(base))
            .map(j => j.content)
            .join('\n');

          const title =
            (htmlFile.content.match(/<title>(.*?)<\/title>/i)?.[1]) ||
            base;

          const body =
            htmlFile.content.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] ||
            htmlFile.content;

          const slug = generateUniqueSlug(
            base.toLowerCase().replace(/[^a-z0-9-]/g, '-')
          );

          const page = new Page({
            storeId: req.user.userId,
            slug,
            title: title.substring(0, 100),
            content: body,
            css,
            js,
            type: 'uploaded',
            isEnabled: true,
            order: existingPages.length
          });

          await page.save();
          createdPages.push({ slug: page.slug, title: page.title });
        }
      }

      // ============================================
      // 4️⃣ CSS / JS فقط
      // ============================================
      else {
        for (const css of extractedFiles.cssFiles) {
          const base = css.name.replace(/\.css$/i, '');
          const slug = generateUniqueSlug(base.toLowerCase());

          const page = new Page({
            storeId: req.user.userId,
            slug,
            title: base,
            content: `<pre>${css.content.slice(0, 1000)}</pre>`,
            css: css.content,
            js: '',
            type: 'uploaded',
            isEnabled: true,
            order: existingPages.length
          });

          await page.save();
          createdPages.push({ slug: page.slug, title: page.title });
        }

        for (const js of extractedFiles.jsFiles) {
          const base = js.name.replace(/\.js$/i, '');
          const slug = generateUniqueSlug(base.toLowerCase());

          const page = new Page({
            storeId: req.user.userId,
            slug,
            title: base,
            content: `<pre>${js.content.slice(0, 1000)}</pre>`,
            css: '',
            js: js.content,
            type: 'uploaded',
            isEnabled: true,
            order: existingPages.length
          });

          await page.save();
          createdPages.push({ slug: page.slug, title: page.title });
        }
      }

      // ============================================
      // 5️⃣ response
      // ============================================
      return res.status(201).json({
        success: true,
        pages: createdPages,
        summary: {
          totalPages: createdPages.length,
          htmlFiles: extractedFiles.htmlFiles.length,
          cssFiles: extractedFiles.cssFiles.length,
          jsFiles: extractedFiles.jsFiles.length,
          imagesUploaded: validImages.length
        }
      });

    } catch (error) {
      console.error('ZIP upload error:', error);
      return res.status(500).json({
        error: 'Failed to process ZIP',
        details: error.message
      });
    }
  }
);

// PUT /api/store/my/pages/reorder - تحديث ترتيب الصفحات (Drag & Drop)
app.put('/api/store/my/pages/reorder', authenticateToken, async (req, res) => {
    try {
        const { pages } = req.body; // [{ id: 'pageId', slug: 'slug', order: 0 }]
        
        if (!pages || !Array.isArray(pages)) {
            return res.status(400).json({ error: 'Invalid pages data' });
        }
        
        // ✅ تحديث ترتيب الصفحات المخصصة في قاعدة البيانات
        for (const page of pages) {
            if (page.id && page.id !== 'products' && page.id !== 'about' && page.id !== 'contact') {
                // صفحة مخصصة
                await Page.findOneAndUpdate(
                    { _id: page.id, storeId: req.user.userId },
                    { order: page.order, updatedAt: Date.now() }
                );
            } else if (page.id === 'about' || page.id === 'contact') {
                // صفحة افتراضية - نخزن ترتيبها في StoreSettings
                const existingPage = await Page.findOne({ storeId: req.user.userId, slug: page.id });
                if (existingPage) {
                    await Page.findOneAndUpdate(
                        { _id: existingPage._id },
                        { order: page.order }
                    );
                } else {
                    // إنشاء سجل للصفحة الافتراضية
                    await Page.create({
                        storeId: req.user.userId,
                        slug: page.id,
                        title: page.id === 'about' ? 'About Us' : 'Contact Us',
                        type: 'custom',
                        isDefault: true,
                        order: page.order,
                        isEnabled: true
                    });
                }
            }
        }
        
        // ✅ تخزين ترتيب صفحة products في StoreSettings
        const productsOrder = pages.find(p => p.id === 'products');
        if (productsOrder) {
            await StoreSettings.findOneAndUpdate(
                { userId: req.user.userId },
                { 'pagesOrder.products': productsOrder.order }
            );
        }
        
        res.json({ success: true, message: 'Pages reordered successfully' });
    } catch (error) {
        console.error('Error reordering pages:', error);
        res.status(500).json({ error: 'Failed to reorder pages' });
    }
});



// PUT /api/store/my/pages/:pageId - تحديث صفحة (مع دعم CSS/JS)
app.put('/api/store/my/pages/:pageId', authenticateToken, async (req, res) => {
    try {
        const { 
            title, content, css, js, isEnabled, order, seo, 
            visibility, settings, slug, processShortcodes 
        } = req.body;
        
        const existingPage = await Page.findOne({ _id: req.params.pageId, storeId: req.user.userId });
        
        if (!existingPage) {
            if (req.params.pageId === 'about' || req.params.pageId === 'contact') {
                const newPage = new Page({
                    storeId: req.user.userId,
                    slug: req.params.pageId,
                    title: title || (req.params.pageId === 'about' ? 'About Us' : 'Contact Us'),
                    content: content || '',
                    css: css || '',
                    js: js || '',
                    type: 'custom',
                    isDefault: true,
                    isEnabled: isEnabled !== undefined ? isEnabled : true,
                    order: order || 0,
                    seo: seo || {},
                    visibility: visibility || 'public',
                    settings: settings || {}
                });
                await newPage.save();
                
                // ✅ تهيئة Shortcodes للمستخدم
                await ShortcodeService.initializeUserShortcodes(req.user.userId);
                
                return res.json({ success: true, page: newPage });
            }
            return res.status(404).json({ error: 'Page not found' });
        }
        
        // ✅ إذا تم طلب معالجة Shortcodes في المحتوى قبل الحفظ
        let processedContent = content !== undefined ? content : existingPage.content;
        
        if (processShortcodes === 'true' && processedContent && processedContent.includes('[')) {
            const userToken = req.headers.authorization?.split(' ')[1];
            processedContent = await ShortcodeService.parseShortcodes(
                processedContent, 
                req.user.userId, 
                { userToken }
            );
            console.log(`📝 Shortcodes processed in page ${existingPage.slug} before saving`);
        }
        
        const updateData = {
            title: title || existingPage.title,
            content: processedContent,
            css: css !== undefined ? css : existingPage.css,
            js: js !== undefined ? js : existingPage.js,
            isEnabled: isEnabled !== undefined ? isEnabled : existingPage.isEnabled,
            order: order !== undefined ? order : existingPage.order,
            seo: seo || existingPage.seo,
            visibility: visibility || existingPage.visibility,
            settings: settings || existingPage.settings,
            updatedAt: Date.now()
        };
        
        if (!existingPage.isDefault && slug) {
            updateData.slug = slug.toLowerCase().replace(/[^a-z0-9-]/g, '-');
        }
        
        const page = await Page.findOneAndUpdate(
            { _id: req.params.pageId, storeId: req.user.userId },
            updateData,
            { new: true }
        );
        
        res.json({ 
            success: true, 
            page,
            shortcodesProcessed: processShortcodes === 'true'
        });
    } catch (error) {
        console.error('Error updating page:', error);
        res.status(500).json({ error: 'Failed to update page' });
    }
});


// GET /api/store/my/pages/:pageId - جلب صفحة محددة (موجود وشغال)
app.get('/api/store/my/pages/:pageId', authenticateToken, async (req, res) => {
    try {
        const page = await Page.findOne({ _id: req.params.pageId, storeId: req.user.userId });
        
        if (!page) {
            return res.status(404).json({ error: 'Page not found' });
        }
        
        res.json({
            success: true,
            page: {
                _id: page._id,
                slug: page.slug,
                title: page.title,
                content: page.content || '',
                css: page.css || '',
                js: page.js || '',
                type: page.type,
                isEnabled: page.isEnabled,
                order: page.order,
                seo: page.seo || {},
                uploadedFile: page.uploadedFile
            }
        });
    } catch (error) {
        console.error('Error fetching page:', error);
        res.status(500).json({ error: 'Failed to fetch page' });
    }
});

// DELETE /api/store/my/pages/:pageId - حذف صفحة
app.delete('/api/store/my/pages/:pageId', authenticateToken, async (req, res) => {
    try {
        const page = await Page.findOne({ _id: req.params.pageId, storeId: req.user.userId });
        
        if (!page) {
            return res.status(404).json({ error: 'Page not found' });
        }
        
        // حذف ملف Cloudinary إذا وجد
        if (page.type === 'uploaded' && page.uploadedFile?.fileUrl) {
            try {
                const publicId = page.uploadedFile.filename;
                await cloudinary.uploader.destroy(`StorePages/${req.user.userId}/${publicId}`, {
                    resource_type: 'raw'
                });
            } catch (cloudError) {
                console.error('Cloudinary deletion error:', cloudError);
            }
        }
        
        await Page.findByIdAndDelete(req.params.pageId);
        
        res.json({ success: true });
    } catch (error) {
        console.error('Error deleting page:', error);
        res.status(500).json({ error: 'Failed to delete page' });
    }
});



// POST /api/store/my/pages/:pageId/duplicate - نسخ صفحة
app.post('/api/store/my/pages/:pageId/duplicate', authenticateToken, async (req, res) => {
    try {
        const originalPage = await Page.findOne({ _id: req.params.pageId, storeId: req.user.userId });
        
        if (!originalPage) {
            return res.status(404).json({ error: 'Page not found' });
        }
        
        const newSlug = `${originalPage.slug}-copy`;
        const newTitle = `${originalPage.title} (Copy)`;
        
        // التأكد من عدم وجود slug مكرر
        let finalSlug = newSlug;
        let counter = 1;
        while (await Page.findOne({ storeId: req.user.userId, slug: finalSlug })) {
            counter++;
            finalSlug = `${newSlug}-${counter}`;
        }
        
        const duplicatedPage = new Page({
            storeId: req.user.userId,
            slug: finalSlug,
            title: newTitle,
            content: originalPage.content,
            css: originalPage.css,
            js: originalPage.js,
            type: 'custom',
            isEnabled: false, // نسخة غير مفعلة افتراضياً
            order: await Page.countDocuments({ storeId: req.user.userId }),
            seo: originalPage.seo,
            visibility: originalPage.visibility,
            settings: originalPage.settings
        });
        
        await duplicatedPage.save();
        
        res.status(201).json({ success: true, page: duplicatedPage });
    } catch (error) {
        console.error('Error duplicating page:', error);
        res.status(500).json({ error: 'Failed to duplicate page' });
    }
});


// GET /api/store/my/pages/:pageId/export - تصدير صفحة كملف HTML
app.get('/api/store/my/pages/:pageId/export', authenticateToken, async (req, res) => {
    try {
        const page = await Page.findOne({ _id: req.params.pageId, storeId: req.user.userId });
        
        if (!page) {
            return res.status(404).json({ error: 'Page not found' });
        }
        
        const user = await User.findById(req.user.userId);
        const storeSettings = await StoreSettings.findOne({ userId: req.user.userId });
        
        const html = `<!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>${escapeHtml(page.title)} - ${escapeHtml(storeSettings?.storeName || user?.username)}</title>
            <meta name="description" content="${escapeHtml(page.seo?.description || '')}">
            <meta name="keywords" content="${escapeHtml(page.seo?.keywords || '')}">
            <style>
                /* Store Theme */
                :root {
                    --primary-color: ${storeSettings?.primaryColor || '#3b82f6'};
                    --secondary-color: ${storeSettings?.secondaryColor || '#8b5cf6'};
                    --border-radius: ${storeSettings?.borderRadius || 16}px;
                }
                
                * { margin: 0; padding: 0; box-sizing: border-box; }
                body { font-family: 'Inter', sans-serif; background: #f9fafb; }
                .container { max-width: 1200px; margin: 0 auto; padding: 20px; }
                
                /* Page Custom CSS */
                ${page.css || ''}
            </style>
            <script src="https://cdn.tailwindcss.com"></script>
            <link href="https://cdn.jsdelivr.net/npm/boxicons@2.1.4/css/boxicons.min.css" rel="stylesheet">
        </head>
        <body>
            <div class="container">
                ${page.content || '<p class="text-gray-500">No content available.</p>'}
            </div>
            <script>
                ${page.js || ''}
            </script>
        </body>
        </html>`;
        
        res.setHeader('Content-Type', 'text/html');
        res.setHeader('Content-Disposition', `attachment; filename="${page.slug}.html"`);
        res.send(html);
    } catch (error) {
        console.error('Error exporting page:', error);
        res.status(500).json({ error: 'Failed to export page' });
    }
});


// GET /api/store/orders/:orderId - جلب طلب محدد
app.get('/api/store/orders/:orderId', authenticateToken, async (req, res) => {
    try {
        const order = await Order.findById(req.params.orderId)
            .populate('buyerId', 'username email profile.nickname')
            .populate('sellerId', 'username profile.nickname');
        
        if (!order) {
            return res.status(404).json({ error: 'Order not found' });
        }
        
        // التحقق من أن المستخدم هو المشتري أو البائع
        if (order.buyerId._id.toString() !== req.user.userId && 
            order.sellerId._id.toString() !== req.user.userId) {
            return res.status(403).json({ error: 'Unauthorized' });
        }
        
        // جلب إعدادات المتجر للـ currency symbol
        const storeSettings = await StoreSettings.findOne({ userId: order.sellerId });
        
        res.json({
            ...order.toObject(),
            currencySymbol: storeSettings?.currencySymbol || '$'
        });
    } catch (error) {
        console.error('Error fetching order:', error);
        res.status(500).json({ error: 'Failed to fetch order' });
    }
});

// PUT /api/store/orders/:orderId/status - تحديث حالة الطلب
app.put('/api/store/orders/:orderId/status', authenticateToken, async (req, res) => {
    try {
        const { status, sellerNotes } = req.body;
        
        const order = await Order.findOneAndUpdate(
            { _id: req.params.orderId, sellerId: req.user.userId },
            { 
                status, 
                sellerNotes: sellerNotes || '',
                ...(status === 'completed' ? { deliveredAt: Date.now() } : {}),
                updatedAt: Date.now()
            },
            { new: true }
        );
        
        if (!order) {
            return res.status(404).json({ error: 'Order not found' });
        }
        
        // إذا تم إكمال الطلب، أضف للإيرادات
        if (status === 'completed') {
            await Earnings.findOneAndUpdate(
                { userId: req.user.userId },
                { 
                    $inc: { totalSales: 1, totalEarnings: order.totalAmount, lifetimeEarnings: order.totalAmount },
                    $push: { 
                        transactions: { 
                            orderId: order._id, 
                            amount: order.totalAmount, 
                            type: 'sale', 
                            status: 'completed',
                            createdAt: Date.now()
                        } 
                    }
                },
                { upsert: true }
            );
            
            // تحديث إحصائيات الشهر
            const currentMonth = new Date().toISOString().slice(0, 7);
            await Earnings.findOneAndUpdate(
                { userId: req.user.userId },
                { 
                    $inc: { 
                        'monthlyStats.$[elem].sales': 1,
                        'monthlyStats.$[elem].earnings': order.totalAmount
                    }
                },
                { 
                    arrayFilters: [{ 'elem.month': currentMonth }],
                    upsert: true
                }
            );
        }
        
        res.json({ success: true, order });
    } catch (error) {
        console.error('Error updating order status:', error);
        res.status(500).json({ error: 'Failed to update order status' });
    }
});


// POST /api/store/orders/:orderId/download - تحميل ملفات المنتج (للمنتجات الرقمية)
app.post('/api/store/orders/:orderId/download/:productId', authenticateToken, async (req, res) => {
    try {
        const order = await Order.findById(req.params.orderId);
        
        if (!order) {
            return res.status(404).json({ error: 'Order not found' });
        }
        
        // التحقق من أن المستخدم هو المشتري والطلب مكتمل
        if (order.buyerId.toString() !== req.user.userId || order.status !== 'completed') {
            return res.status(403).json({ error: 'Unauthorized or order not completed' });
        }
        
        const product = order.items.find(i => i.productId.toString() === req.params.productId);
        if (!product || !product.fileUrl) {
            return res.status(404).json({ error: 'File not found' });
        }
        
        // تحديث عدد مرات التحميل
        await Order.findByIdAndUpdate(req.params.orderId, {
            $inc: { 'items.$[item].downloadCount': 1 }
        }, {
            arrayFilters: [{ 'item.productId': req.params.productId }]
        });
        
        // إعادة رابط التحميل (أو إعادة توجيه)
        res.json({ downloadUrl: product.fileUrl });
    } catch (error) {
        console.error('Error downloading file:', error);
        res.status(500).json({ error: 'Failed to download file' });
    }
});


// ============================================
// POST /api/store/orders/:orderId/upload - رفع ملف لمنتج في الطلب
// ============================================
app.post('/api/store/orders/:orderId/upload', authenticateToken, upload.single('file'), async (req, res) => {
    try {
        const { orderId } = req.params;
        const { productId } = req.body;
        
        // 1. التحقق من وجود الطلب وأن البائع هو صاحبه
        const order = await Order.findOne({ _id: orderId, sellerId: req.user.userId });
        if (!order) {
            return res.status(404).json({ error: 'Order not found or unauthorized' });
        }
        
        // 2. التحقق من وجود ملف مرفوع
        if (!req.file) {
            return res.status(400).json({ error: 'No file uploaded' });
        }
        
        // 3. التحقق من وجود المنتج في الطلب
        const item = order.items.find(i => i.productId.toString() === productId);
        if (!item) {
            return res.status(404).json({ error: 'Product not found in this order' });
        }
        
        // 4. التحقق من صيغة الملف (نفس الـ upload العادي)
        const allowedTypes = [
            'image/jpeg', 'image/png', 'image/jpg', 'image/webp',
            'application/pdf', 'application/zip',
            'text/plain', 'text/csv',
            'application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
            'application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
            'application/vnd.ms-powerpoint', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
        ];
        
        // التحقق من الامتداد كبديل
        const ext = '.' + req.file.originalname.split('.').pop().toLowerCase();
        const allowedExtensions = ['.jpg', '.jpeg', '.png', '.webp', '.pdf', '.zip', '.txt', '.csv', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx'];
        
        if (!allowedTypes.includes(req.file.mimetype) && !allowedExtensions.includes(ext)) {
            return res.status(400).json({ 
                error: 'File type not allowed. Allowed: images, PDF, ZIP, DOC, XLS, PPT, TXT, CSV' 
            });
        }
        
        // 5. التحقق من الحجم (حد أقصى 20MB للملفات الكبيرة)
        if (req.file.size > 20 * 1024 * 1024) {
            return res.status(400).json({ error: 'File size must be less than 20MB' });
        }
        
        // 6. رفع الملف إلى Cloudinary
        let fileUrl = req.file.path; // في حالة استخدام Cloudinary storage مباشرة
        
        // إذا كان الملف مخزن في الذاكرة (memoryStorage)، نرفعه يدوياً
        if (!fileUrl && req.file.buffer) {
            try {
                // تحديد المجلد الفرعي حسب نوع الملف
                let folder = `Orders/${req.user.userId}/${orderId}/files`;
                
                // رفع الملف إلى Cloudinary
                const result = await new Promise((resolve, reject) => {
                    const uploadStream = cloudinary.uploader.upload_stream(
                        {
                            folder: folder,
                            resource_type: 'auto',
                            public_id: `${Date.now()}_${req.file.originalname.replace(/[^a-zA-Z0-9.-]/g, '_')}`,
                            allowed_formats: ['jpg', 'jpeg', 'png', 'webp', 'pdf', 'zip', 'txt', 'csv', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx']
                        },
                        (error, result) => {
                            if (error) reject(error);
                            else resolve(result);
                        }
                    );
                    uploadStream.end(req.file.buffer);
                });
                
                fileUrl = result.secure_url;
            } catch (cloudinaryError) {
                console.error('Cloudinary upload error:', cloudinaryError);
                return res.status(500).json({ error: 'Failed to upload file to cloud storage' });
            }
        }
        
        // 7. التحقق من وجود URL بعد الرفع
        if (!fileUrl) {
            return res.status(500).json({ error: 'Upload failed - no URL returned' });
        }
        
        // 8. تحديث المنتج في الطلب
        item.fileUrl = fileUrl;
        item.fileName = req.file.originalname;
        item.fileSize = req.file.size;
        item.fileType = req.file.mimetype;
        item.uploadedAt = new Date();
        
        await order.save();
        
        // 9. تحديث إحصائيات المنتج الأصلي (اختياري)
        try {
            await Product.findByIdAndUpdate(productId, {
                $set: { fileUrl: fileUrl }
            });
        } catch (e) {
            console.log('Could not update product fileUrl:', e.message);
        }
        
        // 10. إرسال إشعار للمشتري (اختياري)
        try {
            const buyer = await User.findById(order.buyerId);
            if (buyer) {
                await sendStoreEmailWithBrevo(
                    buyer.email,
                    `📥 File uploaded for order #${order.orderNumber}`,
                    `
                    <h2>File Uploaded! 📥</h2>
                    <p>Your order #${order.orderNumber} now has a file available for:</p>
                    <p><strong>${item.title}</strong></p>
                    <p>File: ${req.file.originalname}</p>
                    <a href="${FRONTEND_URL}/my-orders.html" style="background: #3b82f6; color: white; padding: 10px 20px; border-radius: 8px; text-decoration: none;">
                        View Order
                    </a>
                    `,
                    `File uploaded for order #${order.orderNumber}`
                );
            }
        } catch (emailError) {
            console.log('Failed to send email notification:', emailError.message);
        }
        
        // 11. إرسال إشعار Socket.IO للمشتري
        const io = req.app.get('io');
        if (io) {
            io.to(`user_${order.buyerId}`).emit('file_uploaded', {
                orderId: order._id,
                orderNumber: order.orderNumber,
                productTitle: item.title,
                fileName: req.file.originalname
            });
        }
        
        res.json({ 
            success: true, 
            message: 'File uploaded successfully!',
            fileUrl: fileUrl,
            fileName: req.file.originalname,
            fileSize: req.file.size
        });
        
    } catch (error) {
        console.error('Error uploading file:', error);
        
        if (error instanceof multer.MulterError) {
            return res.status(400).json({ error: `Upload error: ${error.message}` });
        }
        
        res.status(500).json({ error: 'Failed to upload file: ' + error.message });
    }
});

// ============================================
// PUT /api/store/orders/:orderId/file-url - إضافة رابط تحميل يدوي
// ============================================
app.put('/api/store/orders/:orderId/file-url', authenticateToken, async (req, res) => {
    try {
        const { orderId } = req.params;
        const { productId, fileUrl, fileName } = req.body;
        
        // 1. التحقق من وجود الطلب وأن البائع هو صاحبه
        const order = await Order.findOne({ _id: orderId, sellerId: req.user.userId });
        if (!order) {
            return res.status(404).json({ error: 'Order not found or unauthorized' });
        }
        
        // 2. التحقق من وجود المنتج في الطلب
        const item = order.items.find(i => i.productId.toString() === productId);
        if (!item) {
            return res.status(404).json({ error: 'Product not found in this order' });
        }
        
        // 3. التحقق من صحة الرابط
        if (!fileUrl || !fileUrl.startsWith('http://') && !fileUrl.startsWith('https://')) {
            return res.status(400).json({ error: 'Invalid file URL. Must start with http:// or https://' });
        }
        
        // 4. تحديث المنتج في الطلب
        item.fileUrl = fileUrl;
        item.fileName = fileName || item.title + '.file';
        item.fileType = 'link';
        item.uploadedAt = new Date();
        
        await order.save();
        
        // 5. إرسال إشعار للمشتري
        try {
            const buyer = await User.findById(order.buyerId);
            if (buyer) {
                await sendStoreEmailWithBrevo(
                    buyer.email,
                    `📥 Download link added for order #${order.orderNumber}`,
                    `
                    <h2>Download Link Added! 📥</h2>
                    <p>Your order #${order.orderNumber} now has a download link for:</p>
                    <p><strong>${item.title}</strong></p>
                    <p>Click the button below to download:</p>
                    <a href="${fileUrl}" style="background: #10b981; color: white; padding: 10px 20px; border-radius: 8px; text-decoration: none;">
                        📥 Download Now
                    </a>
                    <br><br>
                    <a href="${FRONTEND_URL}/my-orders.html" style="background: #3b82f6; color: white; padding: 10px 20px; border-radius: 8px; text-decoration: none;">
                        View Order
                    </a>
                    `,
                    `Download link added for order #${order.orderNumber}`
                );
            }
        } catch (emailError) {
            console.log('Failed to send email notification:', emailError.message);
        }
        
        // 6. إرسال إشعار Socket.IO للمشتري
        const io = req.app.get('io');
        if (io) {
            io.to(`user_${order.buyerId}`).emit('file_url_added', {
                orderId: order._id,
                orderNumber: order.orderNumber,
                productTitle: item.title,
                fileUrl: fileUrl
            });
        }
        
        res.json({ 
            success: true, 
            message: 'File URL added successfully!',
            fileUrl: fileUrl
        });
        
    } catch (error) {
        console.error('Error adding file URL:', error);
        res.status(500).json({ error: 'Failed to add file URL: ' + error.message });
    }
});
// POST /api/store/orders/:orderId/cancel - إلغاء طلب
app.post('/api/store/orders/:orderId/cancel', authenticateToken, async (req, res) => {
    try {
        const order = await Order.findOne({ _id: req.params.orderId, buyerId: req.user.userId });
        if (!order) return res.status(404).json({ error: 'Order not found' });
        if (order.status !== 'pending') {
            return res.status(400).json({ error: 'Cannot cancel order in current status' });
        }
        
        order.status = 'cancelled';
        order.cancelledAt = new Date();
        order.cancellationReason = req.body.reason || 'Cancelled by user';
        await order.save();
        
        res.json({ success: true });
    } catch (error) {
        res.status(500).json({ error: 'Failed to cancel order' });
    }
});


// PUT /api/store/products/:productId - تحديث منتج
app.put('/api/store/products/:productId', authenticateToken, async (req, res) => {
    try {
        const { title, description, price, isActive, deliveryTime, tags, images } = req.body;
        
        // ============================================
        // ✅ جلب المنتج الحالي أولاً للتحقق من النوع
        // ============================================
        const existingProduct = await Product.findOne({ 
            _id: req.params.productId, 
            userId: req.user.userId 
        });
        
        if (!existingProduct) {
            return res.status(404).json({ error: 'Product not found' });
        }
        
        // ============================================
        // ✅ التحقق من الاشتراك والحدود (نفس الـ POST)
        // ============================================
        
        // 1. التحقق من وجود اشتراك نشط
        const activeSubscription = await UserSubscription.findOne({
            userId: req.user.userId,
            status: 'active'
        }).populate('planId');
        
        if (!activeSubscription) {
            return res.status(403).json({ 
                success: false,
                error: 'You need an active subscription to manage products. Please subscribe first.',
                redirect: '/subscription.html',
                code: 'NO_SUBSCRIPTION'
            });
        }
        
        // 2. التحقق من أن الخطة تدعم إنشاء منتجات
        const plan = activeSubscription.planId;
        if (!plan || !plan.features || !plan.features.storeEnabled) {
            return res.status(403).json({ 
                success: false,
                error: 'Your current plan does not allow managing products. Please upgrade your plan.',
                redirect: '/subscription.html',
                code: 'STORE_NOT_IN_PLAN'
            });
        }
        
        // 3. التحقق من حدود المنتجات الكلية (لحالة تغيير isActive من false إلى true)
        const oldType = existingProduct.type;
        const newType = req.body.type || existingProduct.type;
        
        // إذا كان المنتج غير نشط وسوف يصبح نشطاً، تحقق من الحدود
        if (!existingProduct.isActive && isActive === true) {
            const currentActiveCount = await Product.countDocuments({ 
                userId: req.user.userId, 
                isActive: true 
            });
            
            const maxProducts = plan.features.maxProducts || 0;
            if (maxProducts > 0 && currentActiveCount >= maxProducts) {
                return res.status(403).json({ 
                    success: false,
                    error: `Your plan allows up to ${maxProducts} active products. You have reached the limit. Please upgrade to add more products.`,
                    redirect: '/subscription.html',
                    code: 'PRODUCT_LIMIT_REACHED',
                    currentLimit: maxProducts,
                    currentCount: currentActiveCount
                });
            }
        }
        
        // 4. إذا تغير نوع المنتج، تحقق من حدود النوع الجديد
        if (oldType !== newType) {
            if (newType === 'digital') {
                const maxDigital = plan.features.maxDigitalProducts || 0;
                const currentDigital = await Product.countDocuments({ 
                    userId: req.user.userId, 
                    type: 'digital',
                    isActive: true 
                });
                if (maxDigital > 0 && currentDigital >= maxDigital) {
                    return res.status(403).json({ 
                        error: `Your plan allows up to ${maxDigital} digital products. Please upgrade to add more.`,
                        redirect: '/subscription.html'
                    });
                }
            } else if (newType === 'project') {
                const maxProjects = plan.features.maxProjects || 0;
                const currentProjects = await Product.countDocuments({ 
                    userId: req.user.userId, 
                    type: 'project',
                    isActive: true 
                });
                if (maxProjects > 0 && currentProjects >= maxProjects) {
                    return res.status(403).json({ 
                        error: `Your plan allows up to ${maxProjects} projects. Please upgrade to add more.`,
                        redirect: '/subscription.html'
                    });
                }
            } else if (newType === 'service') {
                const maxServices = plan.features.maxServices || 0;
                const currentServices = await Product.countDocuments({ 
                    userId: req.user.userId, 
                    type: 'service',
                    isActive: true 
                });
                if (maxServices > 0 && currentServices >= maxServices) {
                    return res.status(403).json({ 
                        error: `Your plan allows up to ${maxServices} services. Please upgrade to add more.`,
                        redirect: '/subscription.html'
                    });
                }
            }
        }
        
        // 5. التحقق من صلاحية الاشتراك (لم تنتهي)
        const now = new Date();
        if (activeSubscription.endDate && new Date(activeSubscription.endDate) < now) {
            activeSubscription.status = 'expired';
            await activeSubscription.save();
            return res.status(403).json({ 
                error: 'Your subscription has expired. Please renew to manage products.',
                redirect: '/subscription.html',
                code: 'SUBSCRIPTION_EXPIRED'
            });
        }
        
        // ============================================
        // ✅ تحديث المنتج (الكود الموجود)
        // ============================================
        const product = await Product.findOneAndUpdate(
            { _id: req.params.productId, userId: req.user.userId },
            {
                title,
                description,
                price: parseFloat(price),
                isActive,
                deliveryTime,
                tags: tags ? (Array.isArray(tags) ? tags : JSON.parse(tags)) : [],
                images: images ? (Array.isArray(images) ? images : JSON.parse(images)) : [],
                updatedAt: Date.now()
            },
            { new: true }
        );
        
        if (!product) {
            return res.status(404).json({ error: 'Product not found' });
        }
        
        res.json({ success: true, product });
        
    } catch (error) {
        console.error('Error updating product:', error);
        res.status(500).json({ error: 'Failed to update product' });
    }
});

// DELETE /api/store/products/:productId - حذف منتج مع تحديث إحصائيات المتجر
app.delete('/api/store/products/:productId', authenticateToken, async (req, res) => {
    try {
        // جلب المنتج قبل الحذف عشان نعرف userId بتاعه
        const product = await Product.findOne({ _id: req.params.productId, userId: req.user.userId });
        
        if (!product) {
            return res.status(404).json({ error: 'Product not found' });
        }
        
        // ✅ حذف المنتج
        await Product.findOneAndDelete({ _id: req.params.productId, userId: req.user.userId });
        
        // ✅ تحديث عدد المنتجات في المتجر (تخفيض 1)
        await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { $inc: { productsCount: -1 }, updatedAt: Date.now() }
        );
        
        // ✅ إعادة حساب متوسط التقييم للمتجر (لأن المنتج المحذوف كان عنده تقييمات)
        const allProducts = await Product.find({ 
            userId: req.user.userId, 
            isActive: true,
            'reviews.0': { $exists: true }
        });
        
        let totalRating = 0;
        let totalReviews = 0;
        
        for (const p of allProducts) {
            for (const review of p.reviews) {
                totalRating += review.rating;
                totalReviews++;
            }
        }
        
        const storeAvgRating = totalReviews > 0 ? totalRating / totalReviews : 0;
        
        await StoreSettings.findOneAndUpdate(
            { userId: req.user.userId },
            { averageRating: storeAvgRating, updatedAt: Date.now() }
        );
        
        console.log(`✅ Product deleted: ${product.title}, store updated - productsCount: -1, new averageRating: ${storeAvgRating.toFixed(2)}`);
        
        res.json({ success: true, message: 'Product deleted successfully' });
        
    } catch (error) {
        console.error('Error deleting product:', error);
        res.status(500).json({ error: 'Failed to delete product' });
    }
});

// POST /api/store/products/:productId/review - إضافة تقييم مع تحديث إحصائيات المتجر
app.post('/api/store/products/:productId/review', authenticateToken, async (req, res) => {
    try {
        const { rating, comment } = req.body;
        const productId = req.params.productId;
        
        // ✅ التحقق من صحة البيانات
        const ratingNum = parseInt(rating);
        if (isNaN(ratingNum) || ratingNum < 1 || ratingNum > 5) {
            return res.status(400).json({ error: 'Rating must be between 1 and 5' });
        }
        
        if (comment && comment.length > 500) {
            return res.status(400).json({ error: 'Comment cannot exceed 500 characters' });
        }
        
        // ✅ التحقق من أن المستخدم اشترى المنتج بالفعل
        const hasPurchased = await Order.findOne({
            buyerId: req.user.userId,
            'items.productId': productId,
            status: 'completed'
        });
        
        if (!hasPurchased) {
            return res.status(403).json({ error: 'You can only review products you have purchased' });
        }
        
        // ✅ جلب المنتج
        const product = await Product.findById(productId);
        if (!product) {
            return res.status(404).json({ error: 'Product not found' });
        }
        
        // ✅ التحقق من عدم وجود تقييم سابق
        const existingReview = product.reviews.find(r => r.userId.toString() === req.user.userId);
        if (existingReview) {
            return res.status(400).json({ error: 'You have already reviewed this product' });
        }
        
        // ✅ إضافة التقييم
        product.reviews.push({
            userId: req.user.userId,
            rating: ratingNum,
            comment: comment || '',
            createdAt: new Date()
        });
        
        // ✅ تحديث متوسط تقييم المنتج
        const totalRatings = product.reviews.length;
        const sumRatings = product.reviews.reduce((sum, r) => sum + r.rating, 0);
        product.averageRating = sumRatings / totalRatings;
        
        await product.save();
        
        // ✅ إعادة حساب متوسط تقييم المتجر بالكامل (لجميع منتجات المتجر)
        const allProducts = await Product.find({ 
            userId: product.userId, 
            isActive: true,
            'reviews.0': { $exists: true }
        });
        
        let totalStoreRating = 0;
        let totalStoreReviews = 0;
        
        for (const p of allProducts) {
            for (const review of p.reviews) {
                totalStoreRating += review.rating;
                totalStoreReviews++;
            }
        }
        
        const storeAvgRating = totalStoreReviews > 0 ? totalStoreRating / totalStoreReviews : 0;
        
        await StoreSettings.findOneAndUpdate(
            { userId: product.userId },
            { averageRating: storeAvgRating, updatedAt: Date.now() }
        );
        
        console.log(`✅ Review added for product ${product.title} - Rating: ${ratingNum}, Store average: ${storeAvgRating.toFixed(2)}`);
        
        // ✅ إشعار لصاحب المنتج
        await sendStoreNotification(
            product.userId,
            'product_review',
            `${req.user.username} rated your product "${product.title}" ${ratingNum} stars`,
            `/shop/${req.user.username}/product/${productId}`,
            req.user.userId
        );
        
        res.json({ 
            success: true, 
            product,
            message: 'Review added successfully',
            storeAverageRating: storeAvgRating
        });
        
    } catch (error) {
        console.error('Error adding review:', error);
        res.status(500).json({ error: 'Failed to add review' });
    }
});

// GET /api/store/products/:productId/reviews - جلب تقييمات المنتج
app.get('/api/store/products/:productId/reviews', async (req, res) => {
    try {
        const product = await Product.findById(req.params.productId)
            .select('reviews averageRating totalReviews')
            .populate('reviews.userId', 'username profile.nickname profile.avatar');
        
        if (!product) {
            return res.status(404).json({ error: 'Product not found' });
        }
        
        res.json({ 
            success: true, 
            averageRating: product.averageRating,
            totalReviews: product.reviews.length,
            reviews: product.reviews.sort((a, b) => b.createdAt - a.createdAt)
        });
    } catch (error) {
        console.error('Error fetching reviews:', error);
        res.status(500).json({ error: 'Failed to fetch reviews' });
    }
});


// ============================================
// STORE FOLLOW SYSTEM
// ============================================

// POST /api/store/:storeId/follow - متابعة/إلغاء متابعة متجر مع تحديث الإحصائيات
app.post('/api/store/:storeId/follow', authenticateToken, async (req, res) => {
    try {
        const storeId = req.params.storeId;
        
        // التحقق من وجود المتجر
        const store = await User.findById(storeId);
        if (!store || !store.profile.storeEnabled) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        // منع المتابعة الذاتية
        if (storeId === req.user.userId) {
            return res.status(400).json({ error: 'You cannot follow your own store' });
        }
        
        const existingFollow = await StoreFollow.findOne({
            userId: req.user.userId,
            storeId
        });
        
        let isFollowing;
        let followersCount;
        
        if (existingFollow) {
            // ✅ إلغاء المتابعة
            await existingFollow.deleteOne();
            isFollowing = false;
            
            // ✅ تحديث عدد المتابعين في المتجر (تخفيض 1)
            await StoreSettings.findOneAndUpdate(
                { userId: storeId },
                { $inc: { followersCount: -1 }, updatedAt: Date.now() }
            );
            
            console.log(`✅ User ${req.user.username} unfollowed store ${store.profile?.nickname || store.username}`);
            
        } else {
            // ✅ متابعة
            await StoreFollow.create({
                userId: req.user.userId,
                storeId
            });
            isFollowing = true;
            
            // ✅ تحديث عدد المتابعين في المتجر (زيادة 1)
            await StoreSettings.findOneAndUpdate(
                { userId: storeId },
                { $inc: { followersCount: 1 }, updatedAt: Date.now() }
            );
            
            // ✅ إشعار لصاحب المتجر
            await sendStoreNotification(
                storeId,
                'store_follow',
                `${req.user.username} started following your store`,
                `/shop/${store.profile?.nickname || store.username}`,
                req.user.userId
            );
            
            console.log(`✅ User ${req.user.username} followed store ${store.profile?.nickname || store.username}`);
        }
        
        // ✅ جلب عدد المتابعين الجديد
        followersCount = await StoreFollow.countDocuments({ storeId });
        
        res.json({ 
            success: true, 
            isFollowing, 
            followersCount,
            message: isFollowing ? 'Store followed successfully' : 'Store unfollowed successfully'
        });
        
    } catch (error) {
        console.error('Error toggling store follow:', error);
        res.status(500).json({ error: 'Failed to toggle store follow' });
    }
});

// GET /api/store/:storeId/followers - جلب متابعي المتجر
app.get('/api/store/:storeId/followers', async (req, res) => {
    try {
        const followers = await StoreFollow.find({ storeId: req.params.storeId })
            .populate('userId', 'username profile.nickname profile.avatar')
            .limit(20);
        
        res.json({ success: true, followers });
    } catch (error) {
        console.error('Error fetching followers:', error);
        res.status(500).json({ error: 'Failed to fetch followers' });
    }
});

// GET /api/store/:storeId/follow-status - جلب حالة متابعة المتجر
app.get('/api/store/:storeId/follow-status', authenticateToken, async (req, res) => {
    try {
        const storeId = req.params.storeId;
        const isFollowing = await StoreFollow.exists({ userId: req.user.userId, storeId });
        const followersCount = await StoreFollow.countDocuments({ storeId });
        
        res.json({ success: true, isFollowing: !!isFollowing, followersCount });
    } catch (error) {
        res.status(500).json({ error: 'Failed to fetch follow status' });
    }
});


// ============================================
// GET /api/store/:username/full-template - جلب رابط القالب الكامل للمتجر
// ============================================
app.get('/api/store/:username/full-template', async (req, res) => {
    try {
        const { username } = req.params;

        // 1. البحث عن المستخدم
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${username}$`, $options: 'i' } },
                { username: { $regex: `^${username}$`, $options: 'i' } }
            ]
        });

        if (!user) {
            return res.status(404).json({ error: 'Store not found' });
        }

        // 2. جلب إعدادات المتجر
        const storeSettings = await StoreSettings.findOne({ userId: user._id });

        // 3. التحقق من وجود قالب كامل مطبق
        const appliedTemplate = storeSettings?.appliedTemplate;
        const templateUrl = appliedTemplate?.templateUrl;

        if (!templateUrl) {
            // لا يوجد قالب كامل مطبق، استخدم HTML الافتراضي (الموجود حالياً)
            return res.json({
                hasFullTemplate: false,
                message: 'No full template applied. Using default layout.'
            });
        }

        // 4. إرجاد رابط القالب الكامل
        console.log(`✅ Returning full template URL for ${username}: ${templateUrl}`);

        res.json({
            hasFullTemplate: true,
            templateUrl: templateUrl,
            templateInfo: {
                name: appliedTemplate.name,
                slug: appliedTemplate.slug,
                appliedAt: appliedTemplate.appliedAt
            }
        });

    } catch (error) {
        console.error('Error fetching full template:', error);
        res.status(500).json({ error: 'Failed to fetch full template' });
    }
});

// GET /api/store/:username/products - جلب منتجات متجر معين (للزوار) - UPDATED with filters
app.get('/api/store/:username/products', async (req, res) => {
    try {
        const { tags, exclude, limit = 50, viewed, parseShortcodes = 'true' } = req.query;
        
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${req.params.username}$`, $options: 'i' } },
                { username: { $regex: `^${req.params.username}$`, $options: 'i' } }
            ]
        });
        
        if (!user) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        const storeSettings = await StoreSettings.findOne({ userId: user._id });
        if (!storeSettings || !storeSettings.enabled) {
            return res.status(403).json({ error: 'Store is not active' });
        }
        
        let query = { userId: user._id, isActive: true };
        
        if (tags && tags.length > 0) {
            const tagsArray = Array.isArray(tags) ? tags : [tags];
            query.tags = { $in: tagsArray };
        }
        
        if (exclude && exclude !== '') {
            query._id = { $ne: exclude };
        }
        
        if (viewed && viewed.length > 0) {
            const viewedArray = Array.isArray(viewed) ? viewed : [viewed];
            query._id = { $nin: viewedArray };
            if (exclude && exclude !== '') {
                query._id = { $nin: [...viewedArray, exclude] };
            }
        }
        
        const products = await Product.find(query)
            .select('title description price type images tags salesCount averageRating reviews deliveryTime')
            .sort({ createdAt: -1 })
            .limit(parseInt(limit) || 50);
        
        // ✅ جلب الـ Shortcodes المتاحة للمتجر (لمعالجة وصف المنتجات)
        const availableShortcodes = await StoreShortcode.find({ 
            userId: user._id, 
            isActive: true 
        }).select('name');
        
        const shortcodeNames = availableShortcodes.map(s => s.name);
        
        const formattedProducts = await Promise.all(products.map(async (p) => {
            let avgRating = p.averageRating || 0;
            if (p.reviews && p.reviews.length > 0 && !avgRating) {
                const sum = p.reviews.reduce((acc, rev) => acc + rev.rating, 0);
                avgRating = sum / p.reviews.length;
            }
            
            let description = p.description || '';
            
            // ✅ معالجة Shortcodes في وصف المنتج إذا وجدت
            if (parseShortcodes === 'true' && description && description.includes('[')) {
                const userToken = req.headers.authorization?.split(' ')[1];
                description = await ShortcodeService.parseShortcodes(
                    description, 
                    user._id, 
                    { userToken }
                );
            }
            
            return {
                _id: p._id,
                title: p.title,
                description: description,
                price: p.price,
                type: p.type,
                images: p.images || [],
                tags: p.tags || [],
                salesCount: p.salesCount || 0,
                averageRating: avgRating,
                reviewsCount: p.reviews?.length || 0,
                deliveryTime: p.deliveryTime || null,
                isActive: p.isActive,
                createdAt: p.createdAt,
                updatedAt: p.updatedAt
            };
        }));
        
        res.json({ 
            success: true, 
            products: formattedProducts, 
            storeSettings: {
                storeName: storeSettings.storeName || user.profile?.nickname || user.username,
                storeLogo: storeSettings.storeLogo,
                storeBanner: storeSettings.storeBanner,
                storeDescription: storeSettings.storeDescription,
                currency: storeSettings.currency,
                currencySymbol: storeSettings.currencySymbol,
                primaryColor: storeSettings.primaryColor,
                secondaryColor: storeSettings.secondaryColor
            },
            // ✅ إضافة الـ Shortcodes المتاحة للاستخدام في وصف المنتجات
            availableShortcodes: shortcodeNames
        });
        
    } catch (error) {
        console.error('Error fetching store products:', error);
        res.status(500).json({ error: 'Failed to fetch products' });
    }
});



// ============================================
// GET /api/store/:username/analytics - جلب تحليلات المتجر (للمالك فقط)
// ============================================
app.get('/api/store/:username/analytics', authenticateToken, async (req, res) => {
    try {
        const { username } = req.params;
        
        // البحث عن المستخدم
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${username}$`, $options: 'i' } },
                { username: { $regex: `^${username}$`, $options: 'i' } }
            ]
        });
        
        if (!user) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        // التحقق من أن المستخدم هو صاحب المتجر
        if (user._id.toString() !== req.user.userId) {
            return res.status(403).json({ error: 'Unauthorized' });
        }
        
        // ============================================
        // 📊 1. جلب التحليلات من ProfileAnalytics
        // ============================================
        let analytics = await ProfileAnalytics.findOne({ userId: user._id });
        
        if (!analytics) {
            analytics = {
                totalViews: 0,
                uniqueViews: 0,
                profileViews: [],
                dailyStats: {},
                monthlyStats: {},
                referralSources: {}
            };
        }
        
        // ============================================
        // 📊 2. إحصائيات الطلبات والإيرادات
        // ============================================
        const ordersStats = await Order.aggregate([
            { $match: { sellerId: user._id } },
            { $group: {
                _id: null,
                totalOrders: { $sum: 1 },
                completedOrders: { $sum: { $cond: [{ $eq: ['$status', 'completed'] }, 1, 0] } },
                totalRevenue: { $sum: { $cond: [{ $eq: ['$status', 'completed'] }, '$totalAmount', 0] } },
                pendingOrders: { $sum: { $cond: [{ $eq: ['$status', 'pending'] }, 1, 0] } }
            }}
        ]);
        
        // ============================================
        // 📊 3. إحصائيات المنتجات
        // ============================================
        const productsStats = await Product.aggregate([
            { $match: { userId: user._id } },
            { $group: {
                _id: '$type',
                count: { $sum: 1 },
                totalSales: { $sum: '$salesCount' }
            }}
        ]);
        
        // ============================================
        // 📊 4. إحصائيات المتابعين
        // ============================================
        const followersCount = await StoreFollow.countDocuments({ storeId: user._id });
        
        // ============================================
        // 📊 5. المنتجات الأكثر مبيعاً
        // ============================================
        const topProducts = await Product.find({ 
            userId: user._id, 
            isActive: true,
            salesCount: { $gt: 0 }
        })
        .sort({ salesCount: -1 })
        .limit(5)
        .select('title salesCount price images');
        
        // ============================================
        // 📊 6. آخر 7 أيام من الإحصائيات
        // ============================================
        const last7Days = [];
        for (let i = 6; i >= 0; i--) {
            const date = new Date();
            date.setDate(date.getDate() - i);
            const dateStr = date.toISOString().split('T')[0];
            last7Days.push({
                date: dateStr,
                views: analytics.dailyStats?.[dateStr]?.views || 0,
                uniqueViews: analytics.dailyStats?.[dateStr]?.uniqueViews || 0,
                orders: analytics.dailyStats?.[dateStr]?.orders || 0,
                revenue: analytics.dailyStats?.[dateStr]?.revenue || 0
            });
        }
        
        // ============================================
        // 📊 7. آخر 6 أشهر من الإحصائيات
        // ============================================
        const last6Months = [];
        for (let i = 5; i >= 0; i--) {
            const date = new Date();
            date.setMonth(date.getMonth() - i);
            const monthStr = date.toISOString().slice(0, 7);
            last6Months.push({
                month: monthStr,
                views: analytics.monthlyStats?.[monthStr]?.views || 0,
                uniqueViews: analytics.monthlyStats?.[monthStr]?.uniqueViews || 0,
                orders: analytics.monthlyStats?.[monthStr]?.orders || 0,
                revenue: analytics.monthlyStats?.[monthStr]?.revenue || 0
            });
        }
        
        // ============================================
        // 📊 8. مصادر الزوار
        // ============================================
        const referralSources = analytics.referralSources || {
            direct: 0,
            google: 0,
            facebook: 0,
            twitter: 0,
            linkedin: 0,
            instagram: 0,
            github: 0,
            mgzon: 0,
            search: 0,
            other: 0
        };
        
        // ============================================
        // ✅ إرسال الرد
        // ============================================
        res.json({
            success: true,
            analytics: {
                // إحصائيات عامة
                totalViews: analytics.totalViews || 0,
                uniqueViews: analytics.uniqueViews || 0,
                followersCount: followersCount,
                
                // إحصائيات الطلبات
                orders: {
                    total: ordersStats[0]?.totalOrders || 0,
                    completed: ordersStats[0]?.completedOrders || 0,
                    pending: ordersStats[0]?.pendingOrders || 0,
                    totalRevenue: ordersStats[0]?.totalRevenue || 0
                },
                
                // إحصائيات المنتجات
                products: {
                    total: await Product.countDocuments({ userId: user._id, isActive: true }),
                    digital: productsStats.find(p => p._id === 'digital')?.count || 0,
                    projects: productsStats.find(p => p._id === 'project')?.count || 0,
                    services: productsStats.find(p => p._id === 'service')?.count || 0,
                    totalSales: productsStats.reduce((sum, p) => sum + p.totalSales, 0)
                },
                
                // المنتجات الأكثر مبيعاً
                topProducts: topProducts.map(p => ({
                    _id: p._id,
                    title: p.title,
                    salesCount: p.salesCount,
                    price: p.price,
                    image: p.images?.[0] || null
                })),
                
                // الإحصائيات الزمنية
                last7Days: last7Days,
                last6Months: last6Months,
                
                // مصادر الزوار
                referralSources: referralSources,
                
                // آخر المشاهدات
                recentViews: analytics.profileViews?.slice(-10).reverse().map(view => ({
                    viewerName: view.viewerName || 'Guest',
                    deviceType: view.deviceType || 'unknown',
                    browser: view.browser || 'unknown',
                    timestamp: view.timestamp,
                    referer: view.referer || 'direct'
                })) || []
            }
        });
        
    } catch (error) {
        console.error('Error fetching store analytics:', error);
        res.status(500).json({ error: 'Failed to fetch analytics' });
    }
});


// ============================================
// 🗂️ STORE PAGES API ENDPOINTS
// ============================================

// ============================================
// ✅ GET /api/store/:username/:slug - جلب صفحة (مع معالجة Shortcodes)
// ============================================
app.get('/api/store/:username/:slug', async (req, res) => {
    try {
        const { username, slug } = req.params;
        
        if (slug === 'follow-status' || slug === 'products' || slug === 'analytics' || slug === 'page') {
            return res.status(404).json({ error: 'Not found' });
        }
        
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${username}$`, $options: 'i' } },
                { username: { $regex: `^${username}$`, $options: 'i' } }
            ]
        });
        
        if (!user) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        const page = await Page.findOne({ storeId: user._id, slug: slug, isEnabled: true });
        if (!page) {
            return res.status(404).json({ error: 'Page not found' });
        }
        
        const storeSettings = await StoreSettings.findOne({ userId: user._id });
        const theme = await StoreTheme.findOne({ userId: user._id });
        
        // ✅ معالجة الـ Shortcodes في المحتوى
        const userToken = req.headers.authorization?.split(' ')[1];
        const parsedContent = await ShortcodeService.parseShortcodes(
            page.content || '', 
            user._id, 
            { userToken }
        );
        
        res.json({
            success: true,
            page: {
                _id: page._id,
                slug: page.slug,
                title: page.title,
                content: parsedContent,  // ✅ استخدام المحتوى المعالج
                css: page.css || '',
                js: page.js || '',
                seo: page.seo || {}
            },
            storeSettings: {
                storeName: storeSettings?.storeName || user.username,
                primaryColor: theme?.colors?.primary || storeSettings?.primaryColor || '#3b82f6',
                secondaryColor: theme?.colors?.secondary || storeSettings?.secondaryColor || '#8b5cf6',
                currencySymbol: storeSettings?.currencySymbol || '$'
            }
        });
        
    } catch (error) {
        console.error('Error serving page:', error);
        res.status(500).json({ error: 'Failed to load page' });
    }
});




// ============================================
// GET /api/store/:username/page/:slug - جلب صفحة معينة مع CSS/JS و SEO
// ============================================
app.get('/api/store/:username/page/:slug', async (req, res) => {
    try {
        const { username, slug } = req.params;

        // ============================================
        // 1) Find User
        // ============================================
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${username}$`, $options: 'i' } },
                { username: { $regex: `^${username}$`, $options: 'i' } }
            ]
        });

        if (!user) {
            return res.status(404).json({ error: 'Store not found' });
        }

        // ============================================
        // 2) Store Settings + Theme
        // ============================================
        const storeSettings = await StoreSettings.findOne({ userId: user._id });
        if (!storeSettings || !storeSettings.enabled) {
            return res.status(403).json({ error: 'Store is not active' });
        }

        const theme = await StoreTheme.findOne({ userId: user._id });

        // ============================================
        // 3) Find Page
        // ============================================
        let page = await Page.findOne({
            storeId: user._id,
            slug,
            isEnabled: true
        });

        // ============================================
        // 4) Default Pages
        // ============================================
        if (!page) {

            if (slug === 'about') {
                return res.json({
                    success: true,
                    page: {
                        slug: 'about',
                        title: 'About Us',
                        content: storeSettings?.storeDescription || 'Welcome to our store! We offer the best products and services.',
                        css: storeSettings?.customCss || '',
                        js: '',
                        type: 'default',
                        isDefault: true,
                        canEdit: true,
                        isOwner: req.user?.userId === user._id.toString(),
                        seo: {
                            title: `About ${storeSettings?.storeName || user.profile?.nickname || user.username} | MGZon Store`,
                            description: storeSettings?.storeDescription?.substring(0, 160) || 'Learn more about our store.',
                            noindex: false,
                            nofollow: false
                        },
                        visibility: 'public',
                        settings: {
                            showInNav: true,
                            showInFooter: false,
                            openInNewTab: false
                        }
                    }
                });
            }

            if (slug === 'contact') {
                return res.json({
                    success: true,
                    page: {
                        slug: 'contact',
                        title: 'Contact Us',
                        content: generateContactContent(storeSettings, user),
                        css: '',
                        js: '',
                        type: 'default',
                        isDefault: true,
                        canEdit: true,
                        isOwner: req.user?.userId === user._id.toString(),
                        seo: {
                            title: `Contact ${storeSettings?.storeName || user.profile?.nickname || user.username} | MGZon Store`,
                            description: `Get in touch with ${storeSettings?.storeName || user.profile?.nickname || user.username}.`,
                            noindex: false,
                            nofollow: false
                        },
                        visibility: 'public',
                        settings: {
                            showInNav: true,
                            showInFooter: false,
                            openInNewTab: false
                        }
                    }
                });
            }

            return res.status(404).json({ error: 'Page not found' });
        }

        // ============================================
        // 5) Permissions
        // ============================================
        const isOwner = req.user?.userId === user._id.toString();
        const isLoggedIn = !!req.user?.userId;

        if (page.visibility === 'only-owner' && !isOwner) {
            return res.status(403).json({ error: 'This page is private' });
        }

        if (page.visibility === 'logged-in' && !isLoggedIn) {
            return res.status(401).json({ error: 'Please login to view this page' });
        }

        // ============================================
        // 6) Shortcodes Processing (NEW FEATURE)
        // ============================================
        const userToken = req.headers.authorization?.split(' ')[1];

        let processedContent = page.content || '';

        try {
            processedContent = await ShortcodeService.parseShortcodes(
                processedContent,
                user._id,
                { userToken }
            );
        } catch (err) {
            console.error('Shortcode error:', err);
        }

        // ============================================
        // 7) XSS Protection (safe sanitize)
        // ============================================
        const sanitizedContent = processedContent
            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
            .replace(/\s(on\w+)=("[^"]*"|'[^']*'|[^\s>]+)/gi, '');

        const sanitizedCss = page.css
            ?.replace(/expression\(/gi, '')
            ?.replace(/behavior\s*:/gi, '')
            ?.replace(/javascript\s*:/gi, '') || '';

        const sanitizedJs = page.js
            ?.replace(/document\.write/gi, '')
            ?.replace(/eval\(/gi, '') || '';

        // ============================================
        // 8) Views increment (non-blocking)
        // ============================================
        const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
        page.incrementViews(ip, req.user?.userId)
            .catch(err => console.error('Error incrementing views:', err));

        // ============================================
        // 9) SEO
        // ============================================
        const seoTitle = page.seo?.title || page.title;
        const seoDescription =
            page.seo?.description ||
            page.content?.replace(/<[^>]*>/g, '').substring(0, 160) ||
            '';

        // ============================================
        // 10) Response
        // ============================================
        res.json({
            success: true,
            page: {
                _id: page._id,
                slug: page.slug,
                title: page.title,
                content: sanitizedContent,
                css: sanitizedCss,
                js: sanitizedJs,
                type: page.type,
                isDefault: page.isDefault || false,
                isEnabled: page.isEnabled,
                order: page.order,

                canEdit: !page.isDefault || (page.isDefault && slug !== 'products'),
                isOwner,

                seo: {
                    title: seoTitle,
                    description: seoDescription,
                    keywords: page.seo?.keywords || '',
                    ogImage: page.seo?.ogImage || null,
                    noindex: page.seo?.noindex || false,
                    nofollow: page.seo?.nofollow || false
                },

                visibility: page.visibility,

                settings: {
                    showInNav: page.settings?.showInNav !== false,
                    showInFooter: page.settings?.showInFooter || false,
                    openInNewTab: page.settings?.openInNewTab || false,
                    requireAuth: page.settings?.requireAuth || false
                },

                stats: {
                    views: page.stats?.views || 0,
                    uniqueViews: page.stats?.uniqueViews || 0,
                    lastViewedAt: page.stats?.lastViewedAt
                },

                uploadedFile: page.uploadedFile ? {
                    filename: page.uploadedFile.filename,
                    originalName: page.uploadedFile.originalName,
                    fileSize: page.uploadedFile.fileSize,
                    uploadedAt: page.uploadedFile.uploadedAt
                } : null,

                createdAt: page.createdAt,
                updatedAt: page.updatedAt
            },

            // ============================================
            // 11) Extra frontend data (THEME + SETTINGS)
            // ============================================
            storeSettings: {
                storeName: storeSettings?.storeName || user.username,
                primaryColor: theme?.colors?.primary || storeSettings?.primaryColor || '#3b82f6',
                secondaryColor: theme?.colors?.secondary || storeSettings?.secondaryColor || '#8b5cf6',
                currencySymbol: storeSettings?.currencySymbol || '$'
            }
        });

    } catch (error) {
        console.error('Error fetching page:', error);
        res.status(500).json({ error: 'Failed to fetch page' });
    }
});

// GET /api/store/:username/follow-status - حالة متابعة المتجر (عام)
app.get('/api/store/:username/follow-status', async (req, res) => {
    try {
        const { username } = req.params;
        
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${username}$`, $options: 'i' } },
                { username: { $regex: `^${username}$`, $options: 'i' } }
            ]
        });
        
        if (!user) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        const followersCount = await StoreFollow.countDocuments({ storeId: user._id });
        
        // إذا كان المستخدم مسجل دخول، نجيب حالة المتابعة
        let isFollowing = false;
        if (req.user && req.user.userId) {
            isFollowing = await StoreFollow.exists({ 
                userId: req.user.userId, 
                storeId: user._id 
            });
        }
        
        res.json({ 
            success: true, 
            followersCount,
            isFollowing: !!isFollowing
        });
        
    } catch (error) {
        console.error('Error fetching follow status:', error);
        res.status(500).json({ error: 'Failed to fetch follow status' });
    }
});




// ============================================
// GET /api/store/:username/pages - جلب صفحات المتجر (محدث مع دعم القالب المطبق)
// ============================================
app.get('/api/store/:username/pages', async (req, res) => {
    try {
        const { username } = req.params;

        // البحث عن المستخدم بالـ nickname أو username
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${username}$`, $options: 'i' } },
                { username: { $regex: `^${username}$`, $options: 'i' } }
            ]
        });

        if (!user) {
            return res.status(404).json({ error: 'Store not found' });
        }

        const storeSettings = await StoreSettings.findOne({ userId: user._id });
        
        // ✅ جلب القالب المطبق
        const appliedTemplate = storeSettings?.appliedTemplate || null;

        // جلب الـ Shortcodes المتاحة للمتجر
        const availableShortcodes = await StoreShortcode.find({ 
            userId: user._id, 
            isActive: true 
        }).select('name displayName type parameters settings');

        // الصفحات الافتراضية
        const defaultPages = [
            { slug: 'products', title: 'Products', type: 'default', isEnabled: true, order: 1, stats: { views: 0 } },
            { slug: 'about', title: 'About Us', type: 'default', isEnabled: true, order: 2, stats: { views: 0 } },
            { slug: 'contact', title: 'Contact', type: 'default', isEnabled: true, order: 3, stats: { views: 0 } }
        ];

        // الصفحات المخصصة من قاعدة البيانات
        const customPages = await Page.find({ storeId: user._id, isEnabled: true })
            .sort({ order: 1 })
            .select('slug title type order stats content');

        // معالجة Shortcodes داخل المحتوى لكل صفحة
        const processedPages = await Promise.all(
            [...defaultPages, ...customPages].map(async (p) => {
                let processedContent = p.content || '';
                try {
                    processedContent = await ShortcodeService.parseShortcodes(
                        processedContent,
                        user._id
                    );
                } catch (err) {
                    console.error(`Shortcode error for page ${p.slug}:`, err);
                }
                return {
                    _id: p._id || null,
                    slug: p.slug,
                    title: p.title,
                    type: p.type,
                    order: p.order,
                    views: p.stats?.views || 0,
                    content: processedContent
                };
            })
        );

        res.json({
            success: true,
            pages: processedPages,
            storeSettings: {
                storeName: storeSettings?.storeName || user.profile?.nickname || user.username,
                storeLogo: storeSettings?.storeLogo,
                contactEmail: storeSettings?.contactEmail || user.email,
                // ✅ إضافة القالب المطبق
                appliedTemplate: appliedTemplate ? {
                    slug: appliedTemplate.slug,
                    name: appliedTemplate.name,
                    appliedAt: appliedTemplate.appliedAt,
                    hasFullTemplate: appliedTemplate.hasFullTemplate || false
                } : null
            },
            // Shortcodes المتاحة للمتجر
            availableShortcodes: availableShortcodes.map(sc => ({
                name: sc.name,
                displayName: sc.displayName,
                example: `[${sc.name}${sc.parameters?.length ? ' limit="6"' : ''}]`,
                parameters: sc.parameters
            })),
            // Shortcodes المدمجة في النظام
            builtinShortcodes: StoreShortcode.getBuiltinShortcodes().map(sc => ({
                name: sc.name,
                displayName: sc.displayName,
                description: sc.description,
                example: `[${sc.name}${sc.parameters?.length ? ' limit="6"' : ''}]`
            }))
        });

    } catch (error) {
        console.error('Error fetching store pages:', error);
        res.status(500).json({ error: 'Failed to fetch pages' });
    }
});

// ============================================
// GET /api/store/:username - جلب معلومات متجر عام (محدث مع دعم القالب المطبق)
// ============================================
app.get('/api/store/:username', async (req, res) => {
    try {
        const { username } = req.params;
        
        // البحث عن المستخدم
        const user = await User.findOne({
            $or: [
                { 'profile.nickname': { $regex: `^${username}$`, $options: 'i' } },
                { username: { $regex: `^${username}$`, $options: 'i' } }
            ]
        });
        
        if (!user) {
            return res.status(404).json({ error: 'Store not found' });
        }
        
        // جلب إعدادات المتجر
        const storeSettings = await StoreSettings.findOne({ userId: user._id });
        if (!storeSettings || !storeSettings.enabled) {
            return res.status(403).json({ error: 'Store is not active' });
        }
        
        // ✅ جلب القالب (Theme)
        const theme = await StoreTheme.findOne({ userId: user._id });
        
        // ✅ جلب القالب المطبق
        const appliedTemplate = storeSettings.appliedTemplate || null;
        
        // ============================================
        // ✅ جلب صفحات المتجر مع معالجة Shortcodes
        // ============================================
        
        const customPages = await Page.find({ storeId: user._id, isEnabled: true })
            .sort({ order: 1 })
            .select('slug title type order content css js seo');
        
        const customPagesMap = new Map();
        for (const page of customPages) {
            customPagesMap.set(page.slug, page);
        }
        
        const defaultPagesData = [
            { 
                slug: 'products', 
                title: 'Products', 
                type: 'default', 
                isEnabled: true, 
                order: storeSettings.pagesOrder?.products || 1,
                canEdit: false,
                isCustomized: false
            },
            { 
                slug: 'about', 
                title: 'About Us', 
                type: 'default', 
                isEnabled: true, 
                order: storeSettings.pagesOrder?.about || 2,
                canEdit: true,
                isCustomized: false
            },
            { 
                slug: 'contact', 
                title: 'Contact', 
                type: 'default', 
                isEnabled: true, 
                order: storeSettings.pagesOrder?.contact || 3,
                canEdit: true,
                isCustomized: false
            }
        ];
        
        // ✅ معالجة Shortcodes في محتوى الصفحات المخصصة
        const userToken = req.headers.authorization?.split(' ')[1];
        const pages = [];
        
        for (const defaultPage of defaultPagesData) {
            const customizedPage = customPagesMap.get(defaultPage.slug);
            
            if (customizedPage) {
                // ✅ معالجة Shortcodes في محتوى الصفحة المخصصة
                let parsedContent = customizedPage.content;
                if (parsedContent && parsedContent.includes('[')) {
                    parsedContent = await ShortcodeService.parseShortcodes(
                        parsedContent, 
                        user._id, 
                        { userToken }
                    );
                }
                
                pages.push({
                    _id: customizedPage._id,
                    slug: customizedPage.slug,
                    title: customizedPage.title || defaultPage.title,
                    type: customizedPage.type,
                    isEnabled: customizedPage.isEnabled,
                    order: customizedPage.order,
                    content: parsedContent,
                    css: customizedPage.css,
                    js: customizedPage.js,
                    seo: customizedPage.seo,
                    canEdit: true,
                    isCustomized: true
                });
            } else {
                pages.push({
                    slug: defaultPage.slug,
                    title: defaultPage.title,
                    type: defaultPage.type,
                    isEnabled: defaultPage.isEnabled,
                    order: defaultPage.order,
                    content: null,
                    canEdit: defaultPage.canEdit,
                    isCustomized: false
                });
            }
        }
        
        for (const customPage of customPages) {
            if (!defaultPagesData.some(p => p.slug === customPage.slug)) {
                let parsedContent = customPage.content;
                if (parsedContent && parsedContent.includes('[')) {
                    parsedContent = await ShortcodeService.parseShortcodes(
                        parsedContent, 
                        user._id, 
                        { userToken }
                    );
                }
                
                pages.push({
                    _id: customPage._id,
                    slug: customPage.slug,
                    title: customPage.title,
                    type: customPage.type,
                    isEnabled: customPage.isEnabled,
                    order: customPage.order,
                    content: parsedContent,
                    css: customPage.css,
                    js: customPage.js,
                    seo: customPage.seo,
                    canEdit: true,
                    isCustomized: true
                });
            }
        }
        
        pages.sort((a, b) => (a.order || 0) - (b.order || 0));
        
        // ============================================
        // ✅ جلب المنتجات النشطة
        // ============================================
        const products = await Product.find({ 
            userId: user._id, 
            isActive: true 
        })
        .select('title description price type images tags salesCount averageRating reviews deliveryTime')
        .sort({ createdAt: -1 })
        .limit(50);
        
        const rawSections = storeSettings.pageBuilder?.sections || [];

        // ترتيب الأقسام حسب order
        const sections = rawSections
            .map(section => ({
                id: section.id,
                type: section.type,
                enabled: section.enabled !== false,
                order: section.order || 0,
                title: section.title || null,
                limit: section.limit || null,
                layout: section.layout || null,
                content: section.content || {}
            }))
            .sort((a, b) => (a.order || 0) - (b.order || 0));
        
        const totalSales = await Order.aggregate([
            { $match: { sellerId: user._id, status: 'completed' } },
            { $group: { _id: null, total: { $sum: '$totalAmount' } } }
        ]);
        
        const productsCount = await Product.countDocuments({ userId: user._id, isActive: true });
        const followersCount = await StoreFollow.countDocuments({ storeId: user._id });
        
        // ✅ جلب الـ Shortcodes المتاحة للمتجر
        const availableShortcodes = await StoreShortcode.find({ 
            userId: user._id, 
            isActive: true 
        }).select('name displayName type');
        
        // ============================================
        // ✅ إرسال الرد مع دعم appliedTemplate
        // ============================================
        res.json({
            success: true,
            store: {
                id: user._id,
                username: user.username,
                nickname: user.profile?.nickname,
                avatar: user.profile?.avatar,
                storeName: storeSettings.storeName || user.profile?.nickname || user.username,
                storeLogo: storeSettings.storeLogo || null,
                storeBanner: storeSettings.storeBanner || null,
                storeDescription: storeSettings.storeDescription || '',
                contactEmail: storeSettings.contactEmail || '',
                productViewType: storeSettings.productViewType || 'modal',
                currency: storeSettings.currency || 'USD',
                currencySymbol: storeSettings.currencySymbol || '$',
                enabled: storeSettings.enabled,
                productsCount: productsCount,
                followersCount: followersCount,
                totalSales: totalSales[0]?.total || 0
            },
            settings: {
                primaryColor: theme?.colors?.primary || storeSettings.primaryColor || '#3b82f6',
                secondaryColor: theme?.colors?.secondary || storeSettings.secondaryColor || '#8b5cf6',
                fontFamily: theme?.typography?.fontFamily || storeSettings.fontFamily || 'Inter, sans-serif',
                borderRadius: storeSettings.borderRadius || 16,
                shadowType: storeSettings.shadowType || 'md',
                animationType: storeSettings.animationType || 'lift',
                glassEffect: storeSettings.glassEffect || false,
                backgroundType: storeSettings.backgroundType || 'default',
                backgroundValue: storeSettings.backgroundValue || '',
                currentBackground: storeSettings.currentBackground || {
                    url: storeSettings.backgroundValue || '',
                    type: storeSettings.backgroundType || 'default'
                },

                layoutTemplate: storeSettings.layoutSettings?.layoutTemplate || 'default',
                customCss: storeSettings.customCss || '',
                // ✅ إضافة إعدادات القالب
                theme: theme ? {
                    layout: theme.layout,
                    hasCustomHeader: !!theme.customTemplates?.header,
                    hasCustomFooter: !!theme.customTemplates?.footer,
                    hasUploadedTheme: !!theme.uploadedTheme?.fileUrl
                } : null,
                // ✅ إضافة القالب المطبق
                appliedTemplate: appliedTemplate ? {
                    slug: appliedTemplate.slug,
                    name: appliedTemplate.name,
                    appliedAt: appliedTemplate.appliedAt,
                    hasFullTemplate: appliedTemplate.hasFullTemplate || false,
                    path: appliedTemplate.path
                } : null
            },
            pages: pages.map(page => ({
                _id: page._id,
                slug: page.slug,
                title: page.title,
                type: page.type,
                isEnabled: page.isEnabled,
                order: page.order,
                canEdit: page.canEdit,
                isCustomized: page.isCustomized,
                hasContent: !!page.content,
                hasCss: !!page.css,
                hasJs: !!page.js
            })),
            products: products.map(p => {
                let avgRating = p.averageRating || 0;
                if (p.reviews && p.reviews.length > 0 && !avgRating) {
                    const sum = p.reviews.reduce((acc, rev) => acc + rev.rating, 0);
                    avgRating = sum / p.reviews.length;
                }
                
                return {
                    _id: p._id,
                    title: p.title,
                    description: p.description,
                    price: p.price,
                    type: p.type,
                    images: p.images || [],
                    tags: p.tags || [],
                    salesCount: p.salesCount || 0,
                    averageRating: avgRating,
                    reviewsCount: p.reviews?.length || 0,
                    deliveryTime: p.deliveryTime || null
                };
            }),
            sections: sections.map(section => ({
                id: section.id,
                type: section.type,
                enabled: section.enabled !== false,
                order: section.order || 0,
                title: section.title || null,
                limit: section.limit || null,
                layout: section.layout || null,
                content: section.content || {}
            })),
            // ✅ إضافة الـ Shortcodes المتاحة
            availableShortcodes: availableShortcodes.map(sc => ({
                name: sc.name,
                displayName: sc.displayName,
                example: `[${sc.name}]`
            }))
        });
        
    } catch (error) {
        console.error('Error fetching public store:', error);
        res.status(500).json({ error: 'Failed to load store' });
    }
});


// ============================================
// دالة مساعدة لتوليد محتوى صفحة الاتصال
// ============================================

function generateContactContent(storeSettings, user) {
    const socialLinks = storeSettings?.socialLinks || {};
    
    return `
        <div class="contact-page max-w-2xl mx-auto">
            <div class="contact-info space-y-6">
                <!-- Email -->
                <div class="flex items-center gap-4 p-4 bg-gray-50 dark:bg-gray-800 rounded-xl">
                    <div class="w-12 h-12 rounded-full bg-blue-100 dark:bg-blue-900/30 flex items-center justify-center">
                        <i class='bx bx-envelope text-2xl text-blue-500'></i>
                    </div>
                    <div>
                        <p class="text-sm text-gray-500">Email</p>
                        <a href="mailto:${storeSettings?.contactEmail || user.email}" class="text-lg font-medium text-blue-600 hover:underline">
                            ${storeSettings?.contactEmail || user.email}
                        </a>
                    </div>
                </div>
                
                ${socialLinks.instagram ? `
                <div class="flex items-center gap-4 p-4 bg-gray-50 dark:bg-gray-800 rounded-xl">
                    <div class="w-12 h-12 rounded-full bg-pink-100 dark:bg-pink-900/30 flex items-center justify-center">
                        <i class='bx bxl-instagram text-2xl text-pink-500'></i>
                    </div>
                    <div>
                        <p class="text-sm text-gray-500">Instagram</p>
                        <a href="${socialLinks.instagram}" target="_blank" class="text-lg font-medium text-blue-600 hover:underline">
                            @${socialLinks.instagram.split('/').pop()}
                        </a>
                    </div>
                </div>
                ` : ''}
                
                ${socialLinks.facebook ? `
                <div class="flex items-center gap-4 p-4 bg-gray-50 dark:bg-gray-800 rounded-xl">
                    <div class="w-12 h-12 rounded-full bg-blue-100 dark:bg-blue-900/30 flex items-center justify-center">
                        <i class='bx bxl-facebook text-2xl text-blue-600'></i>
                    </div>
                    <div>
                        <p class="text-sm text-gray-500">Facebook</p>
                        <a href="${socialLinks.facebook}" target="_blank" class="text-lg font-medium text-blue-600 hover:underline">
                            Facebook Page
                        </a>
                    </div>
                </div>
                ` : ''}
                
                ${socialLinks.twitter ? `
                <div class="flex items-center gap-4 p-4 bg-gray-50 dark:bg-gray-800 rounded-xl">
                    <div class="w-12 h-12 rounded-full bg-sky-100 dark:bg-sky-900/30 flex items-center justify-center">
                        <i class='bx bxl-twitter text-2xl text-sky-500'></i>
                    </div>
                    <div>
                        <p class="text-sm text-gray-500">Twitter</p>
                        <a href="${socialLinks.twitter}" target="_blank" class="text-lg font-medium text-blue-600 hover:underline">
                            @${socialLinks.twitter.split('/').pop()}
                        </a>
                    </div>
                </div>
                ` : ''}
            </div>
            
            <div class="mt-8">
                <h3 class="text-xl font-semibold mb-4">Send us a message</h3>
                <form id="store-contact-form" class="space-y-4" onsubmit="event.preventDefault(); sendStoreContactMessage();">
                    <div>
                        <input type="text" id="contact-name" placeholder="Your Name" required
                            class="w-full p-3 border rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-800 dark:border-gray-700">
                    </div>
                    <div>
                        <input type="email" id="contact-email" placeholder="Your Email" required
                            class="w-full p-3 border rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-800 dark:border-gray-700">
                    </div>
                    <div>
                        <textarea id="contact-message" rows="5" placeholder="Your Message" required
                            class="w-full p-3 border rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-800 dark:border-gray-700"></textarea>
                    </div>
                    <button type="submit" 
                        class="w-full py-3 bg-blue-500 text-white rounded-lg font-semibold hover:bg-blue-600 transition">
                        Send Message
                    </button>
                </form>
            </div>
        </div>
        
        <script>
            async function sendStoreContactMessage() {
                const name = document.getElementById('contact-name')?.value;
                const email = document.getElementById('contact-email')?.value;
                const message = document.getElementById('contact-message')?.value;
                
                if (!name || !email || !message) {
                    alert('Please fill all fields');
                    return;
                }
                
                try {
                    const csrfToken = await fetchCsrfToken();
                    const response = await fetch('${process.env.BASE_URL}/api/store/contact', {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json',
                            'X-CSRF-Token': csrfToken
                        },
                        body: JSON.stringify({
                            sellerId: '${user._id}',
                            name: name,
                            email: email,
                            message: message
                        })
                    });
                    
                    const result = await response.json();
                    
                    if (response.ok) {
                        alert('Message sent successfully!');
                        document.getElementById('contact-name').value = '';
                        document.getElementById('contact-email').value = '';
                        document.getElementById('contact-message').value = '';
                    } else {
                        alert(result.error || 'Failed to send message');
                    }
                } catch (error) {
                    console.error('Error sending message:', error);
                    alert('Failed to send message. Please try again.');
                }
            }
        </script>
    `;
}

// ========== 6. دالة مساعدة لتحديث صلاحيات المستخدم ==========
async function updateUserPermissions(userId, plan) {
    const user = await User.findById(userId);
    if (!user) return;
    
    if (!plan) {
        user.profile.storeEnabled = false;
        user.profile.maxProducts = 0;
        user.profile.maxDigitalProducts = 0;
        user.profile.maxProjects = 0;
        user.profile.maxServices = 0;
        user.profile.pageBuilderEnabled = false;
        user.profile.customDomain = false;
        user.profile.analyticsEnabled = false;
        user.profile.prioritySupport = false;
        user.profile.removeBranding = false;
        user.profile.teamMembers = 1;
        user.profile.apiAccess = false;
        user.profile.customCss = false;
        user.profile.advancedAnalytics = false;
        user.profile.exportData = false;
    } else {
        user.profile.storeEnabled = plan.features?.storeEnabled || false;
        user.profile.maxProducts = plan.features?.maxProducts || 0;
        user.profile.maxDigitalProducts = plan.features?.maxDigitalProducts || 0;
        user.profile.maxProjects = plan.features?.maxProjects || 0;
        user.profile.maxServices = plan.features?.maxServices || 0;
        user.profile.pageBuilderEnabled = plan.features?.pageBuilderEnabled || false;
        user.profile.customDomain = plan.features?.customDomain || false;
        user.profile.analyticsEnabled = plan.features?.analyticsEnabled || false;
        user.profile.prioritySupport = plan.features?.prioritySupport || false;
        user.profile.removeBranding = plan.features?.removeBranding || false;
        user.profile.teamMembers = plan.features?.teamMembers || 1;
        user.profile.apiAccess = plan.features?.apiAccess || false;
        user.profile.customCss = plan.features?.customCss || false;
        user.profile.advancedAnalytics = plan.features?.advancedAnalytics || false;
        user.profile.exportData = plan.features?.exportData || false;
    }
    
    await user.save();
}

// ========== 7. سيرفر مهام لتحديث صلاحية الاشتراكات ==========
// يمكن تشغيل هذا الـ cron job يومياً
const checkExpiredSubscriptions = async () => {
    const now = new Date();
    
    // العثور على الاشتراكات المنتهية
    const expired = await UserSubscription.find({
        status: 'active',
        endDate: { $lt: now }
    });
    
    for (const sub of expired) {
        sub.status = 'expired';
        sub.updatedAt = now;
        await sub.save();
        
        // تعطيل صلاحيات المستخدم
        await updateUserPermissions(sub.userId, null);
        
        // إشعار المستخدم
        const user = await User.findById(sub.userId);
        if (user) {
            const notification = new Notification({
                userId: sub.userId,
                type: 'subscription_expired',
                content: 'Your subscription has expired. Please renew to continue accessing premium features.',
                targetId: `/subscription`,
                targetType: 'subscription',
                read: false
            });
            await notification.save();
        }
    }
    
    console.log(`Expired ${expired.length} subscriptions`);
};

// تشغيل المهمة يومياً (يمكن إضافتها في مكان آخر)
setInterval(checkExpiredSubscriptions, 24 * 60 * 60 * 1000);




// ============================================
// 🖼️ BACKGROUNDS HELPER FUNCTIONS
// ============================================

/**
 * جلب الخلفيات المتاحة للمستخدم
 * @param {string} userId - معرف المستخدم
 * @returns {Array} - قائمة الخلفيات
 */
async function getAvailableBackgrounds(userId) {
    // الخلفيات العامة
    const publicBackgrounds = [
        { id: 'bg_purple_abstract', name: 'Purple Abstract', url: 'https://img.magnific.com/premium-photo/blue-sphere-consisting-points-modern-wireframe-elements-technology-grid-sphere-3d-rendering_658411-190.jpg?semt=ais_hybrid&w=740&q=80', category: 'abstract', type: 'image' },
        { id: 'bg_glowing_orb', name: 'Glowing Orb', url: 'https://img.magnific.com/premium-photo/glowing-orb-dark-space_303714-9996.jpg?semt=ais_hybrid&w=740&q=80', category: 'abstract', type: 'image' },
        { id: 'bg_cosmic_sphere', name: 'Cosmic Sphere', url: 'https://64.media.tumblr.com/cbebea0e22c5e7fb6df960803e9a6bcd/059f55258bab86dd-7d/s2048x3072/02c114e6cfa03fdc04a670fdcbeca9eedff33ba8.pnj', category: 'space', type: 'image' },
        { id: 'bg_galaxy_anim', name: 'Galaxy Animation', url: 'https://64.media.tumblr.com/93a523c16ff3501b1fb8b5e69f21165d/tumblr_pad8tumDpI1w6uqh8o1_640.gifv', category: 'space', type: 'gif' },
        { id: 'bg_star_field', name: 'Star Field', url: 'https://64.media.tumblr.com/5f5de73c7435cfc6a2455f015325e66a/tumblr_pkt9yhi8oQ1w6uqh8o1_1280.gifv', category: 'space', type: 'gif' },
        { id: 'bg_cosmic_dance', name: 'Cosmic Dance', url: 'https://64.media.tumblr.com/70a160a091f547c28dc7f8a834eb24ae/tumblr_pudp7wpAYQ1w6uqh8o1_640.gifv', category: 'space', type: 'gif' },
        { id: 'bg_starry_night', name: 'Starry Night', url: 'https://64.media.tumblr.com/da0cf61d7513891c4f8e5d62d07ed1a0/tumblr_mxdx1pDDxh1sso6sco1_500.gif', category: 'space', type: 'gif' },
        { id: 'bg_gradient_anim', name: 'Gradient Animation', url: 'https://media.deloitte.com/is/image/deloitte/1920x880_wie-veraendern-sich-die-deutschen-exportstrukturen_promo:720-x-480?defaultImage=default-nonprofile-thumbnail&defaultImageMode=1', category: 'gradient', type: 'image' },
        { id: 'bg_color_wave', name: 'Color Wave', url: 'https://i1.sndcdn.com/artworks-000059427896-ueko8g-t500x500.jpg', category: 'gradient', type: 'image' },
        { id: 'bg_blue_gradient', name: 'Blue Gradient', url: 'https://media.deloitte.com/is/image/deloitte/ai-in-banking-header-1920-880-1:1200-x-675?$Responsive$&fmt=webp&fit=stretch,1&dpr=off', category: 'gradient', type: 'image' },
        { id: 'bg_tech_grid', name: 'Tech Grid', url: 'https://media.deloitte.com/is/image/deloitte/us-variance-in-board-ceo-succession-1920x880:1200-x-675?$Responsive$&fmt=webp&fit=stretch,1&dpr=off', category: 'tech', type: 'image' },
        { id: 'bg_digital_network', name: 'Digital Network', url: 'https://miro.medium.com/v2/resize:fit:1400/1*l7Da76q9ZeRbIM1cjiY2Mw.png', category: 'tech', type: 'image' },
        { id: 'bg_tech_banner', name: 'Tech Banner', url: 'https://media.deloitte.com/is/image/deloitte/in-industry-banner-gcc-4-1920-x-880:1200-x-627', category: 'tech', type: 'image' },
        { id: 'bg_nature_anim', name: 'Nature Animation', url: 'https://www.thisiscolossal.com/wp-content/uploads/2018/04/agif2opt.gif', category: 'nature', type: 'gif' },
        { id: 'bg_nature_scene', name: 'Nature Scene', url: 'https://static.wixstatic.com/media/aec810_7a5c7c17a2b5449883ff60fedcc6864e~mv2.gif', category: 'nature', type: 'gif' },
        { id: 'bg_nature_flow', name: 'Nature Flow', url: 'https://www.thisiscolossal.com/wp-content/uploads/2018/04/agif5opt.gif', category: 'nature', type: 'gif' }
    ];
    
    // جلب الخلفيات المخصصة للمستخدم
    let customBackgrounds = [];
    if (userId) {
        const settings = await StoreSettings.findOne({ userId });
        if (settings?.customBackgrounds) {
            customBackgrounds = settings.customBackgrounds;
        }
    }
    
    return [...publicBackgrounds, ...customBackgrounds];
}

/**
 * تطبيق خلفية على متجر المستخدم
 */
async function applyBackgroundToStore(userId, background) {
    const settings = await StoreSettings.findOneAndUpdate(
        { userId },
        {
            $set: {
                backgroundType: background.type || 'image',
                backgroundValue: background.url,
                'currentBackground.url': background.url,
                'currentBackground.name': background.name || 'Custom Background',
                'currentBackground.type': background.type || 'image',
                'currentBackground.appliedAt': new Date(),
                updatedAt: Date.now()
            },
            $push: {
                backgroundHistory: {
                    url: background.url,
                    name: background.name || 'Custom Background',
                    appliedAt: new Date()
                }
            }
        },
        { upsert: true, new: true }
    );
    
    // أيضاً تحديث theme إذا كان موجود
    await StoreTheme.findOneAndUpdate(
        { userId },
        {
            $set: {
                'colors.background': background.url,
                updatedAt: Date.now()
            }
        },
        { upsert: true }
    );
    
    return settings;
}


// ============================================
// CRON JOBS FOR SUBSCRIPTIONS
// ============================================

// تشغيل عند بدء السيرفر
async function initSubscriptionCronJobs() {
    console.log('🔄 Initializing subscription cron jobs...');
    await checkExpiredSubscriptions();
    await sendExpirationReminders();
    
    // تشغيل كل 6 ساعات
    setInterval(async () => {
        console.log('🔄 Running subscription maintenance...');
        await checkExpiredSubscriptions();
        await sendExpirationReminders();
        await updateSubscriptionMetrics();
    }, 6 * 60 * 60 * 1000);
}

// إرسال تذكيرات قبل انتهاء الاشتراك
async function sendExpirationReminders() {
    const now = new Date();
    const reminderDays = [7, 3, 1]; // قبل 7, 3, 1 يوم
    
    for (const days of reminderDays) {
        const targetDate = new Date();
        targetDate.setDate(targetDate.getDate() + days);
        const startOfDay = new Date(targetDate.setHours(0, 0, 0, 0));
        const endOfDay = new Date(targetDate.setHours(23, 59, 59, 999));
        
        const expiringSubscriptions = await UserSubscription.find({
            status: 'active',
            endDate: { $gte: startOfDay, $lte: endOfDay }
        }).populate('planId').populate('userId');
        
        for (const sub of expiringSubscriptions) {
            // تجنب إرسال أكثر من تذكير لنفس المستخدم
            const existingNotification = await Notification.findOne({
                userId: sub.userId._id,
                type: 'subscription_expiring',
                createdAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) }
            });
            
            if (!existingNotification) {
                const notification = new Notification({
                    userId: sub.userId._id,
                    type: 'subscription_expiring',
                    content: `Your subscription to "${sub.planId.name}" will expire in ${days} day${days !== 1 ? 's' : ''}. Renew now to continue enjoying premium features.`,
                    targetId: `/subscription`,
                    targetType: 'subscription',
                    read: false
                });
                await notification.save();
                
                // إرسال إيميل
                const user = sub.userId;
                const emailHtml = `
                    <h2>Subscription Expiring Soon</h2>
                    <p>Dear ${user.username},</p>
                    <p>Your subscription to "${sub.planId.name}" will expire in ${days} day${days !== 1 ? 's' : ''} (${new Date(sub.endDate).toLocaleDateString()}).</p>
                    <p>Renew now to continue enjoying premium features.</p>
                    <a href="${FRONTEND_URL}/subscription.html" style="background: #667eea; color: white; padding: 10px 20px; text-decoration: none; border-radius: 8px;">Renew Now →</a>
                `;
                await sendStoreEmailWithBrevo(user.email, `Subscription Expiring Soon - ${sub.planId.name}`, emailHtml, '');
            }
        }
    }
}

// تحديث إحصائيات الاشتراكات
async function updateSubscriptionMetrics() {
    const today = new Date().toISOString().slice(0, 7);
    
    // تسجيل إحصائيات يومية
    const activeCount = await UserSubscription.countDocuments({ status: 'active' });
    const totalRevenue = await SubscriptionEarnings.aggregate([
        { $match: { status: 'completed' } },
        { $group: { _id: null, total: { $sum: '$amount' } } }
    ]);
    
    console.log(`📊 Subscription Metrics: Active: ${activeCount}, Revenue: ${totalRevenue[0]?.total || 0}`);
}

// تشغيل cron jobs عند بدء السيرفر
initSubscriptionCronJobs();

const fileLimiter = rateLimit({
    windowMs: 15 * 60 * 1000,
    max: 20,
    message: 'Too many file operations, please try again later.',
    validate: { trustProxy: false }
});
app.use('/api/files', fileLimiter);

app.set('view engine', 'ejs');
app.set('views', './views');
app.use(express.static('public'));

// Privacy Policy Page
app.get('/privacy', (req, res) => {
    res.render('privacy');
});

// Terms of Service Page
app.get('/terms', (req, res) => {
    res.render('terms');
});


// ============================================
// Sitemap Generator - Full Version
// ============================================

// المسار اللي هتحفظ فيه الـ Sitemaps (لو عايز تخدمها كملفات static)
const SITEMAP_DIR = path.join(__dirname, 'public');

// التأكد من وجود المجلد
if (!fs.existsSync(SITEMAP_DIR)) {
    fs.mkdirSync(SITEMAP_DIR, { recursive: true });
}

// ============================================
// دالة مساعدة لتوليد Sitemap للمتاجر
// ============================================
async function generateStoresSitemap() {


    const today = new Date().toISOString().split('T')[0];
    
    // جلب المتاجر النشطة
    const stores = await StoreSettings.find({ enabled: true })
        .populate('userId', 'profile.nickname username')
        .sort({ updatedAt: -1 });
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
    
    for (const store of stores) {
        const nickname = store.userId?.profile?.nickname || store.userId?.username;
        if (nickname) {
            xml += `  <url>\n`;
            xml += `    <loc>${FRONTEND_URL}/shop/${nickname}</loc>\n`;
            xml += `    <lastmod>${store.updatedAt ? store.updatedAt.toISOString().split('T')[0] : today}</lastmod>\n`;
            xml += `    <changefreq>daily</changefreq>\n`;
            xml += `    <priority>0.8</priority>\n`;
            xml += `  </url>\n`;
        }
    }
    
    xml += '</urlset>';
    
    // حفظ كملف
    const filePath = path.join(SITEMAP_DIR, 'sitemap-stores.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-stores.xml (${stores.length} stores)`);
    
    return xml;
}

// ============================================
// دالة مساعدة لتوليد Sitemap للمنتجات
// ============================================
async function generateProductsSitemap() {
    
    const today = new Date().toISOString().split('T')[0];
    
    // جلب المنتجات النشطة (حد أقصى 5000)
    const products = await Product.find({ isActive: true })
        .populate('userId', 'profile.nickname username')
        .sort({ updatedAt: -1 })
        .limit(5000);
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
    
    for (const product of products) {
        const nickname = product.userId?.profile?.nickname || product.userId?.username;
        if (nickname) {
            xml += `  <url>\n`;
            xml += `    <loc>${FRONTEND_URL}/product.html?id=${product._id}&amp;owner=${encodeURIComponent(nickname)}</loc>\n`;
            xml += `    <lastmod>${product.updatedAt ? product.updatedAt.toISOString().split('T')[0] : today}</lastmod>\n`;
            xml += `    <changefreq>weekly</changefreq>\n`;
            xml += `    <priority>0.6</priority>\n`;
            xml += `  </url>\n`;
        }
    }
    
    xml += '</urlset>';
    
    // حفظ كملف
    const filePath = path.join(SITEMAP_DIR, 'sitemap-products.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-products.xml (${products.length} products)`);
    
    return xml;
}

// ============================================
// دالة مساعدة لتوليد Sitemap للمستخدمين
// ============================================
async function generateUsersSitemap() {


    const today = new Date().toISOString().split('T')[0];
    
    // جلب المستخدمين العموميين
    const users = await User.find({ 'profile.isPublic': true })
        .select('profile.nickname profile.updatedAt');
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
    
    for (const user of users) {
        if (user.profile?.nickname) {
            xml += `  <url>\n`;
            xml += `    <loc>${FRONTEND_URL}/profile/${user.profile.nickname}</loc>\n`;
            xml += `    <lastmod>${user.profile.updatedAt ? user.profile.updatedAt.toISOString().split('T')[0] : today}</lastmod>\n`;
            xml += `    <changefreq>weekly</changefreq>\n`;
            xml += `    <priority>0.7</priority>\n`;
            xml += `  </url>\n`;
        }
    }
    
    xml += '</urlset>';
    
    // حفظ كملف
    const filePath = path.join(SITEMAP_DIR, 'sitemap-users.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-users.xml (${users.length} users)`);
    
    return xml;
}

// ============================================
// دالة مساعدة لتوليد Sitemap للصفحات الثابتة
// ============================================
function generateStaticSitemap() {

    const today = new Date().toISOString().split('T')[0];
    
    // قائمة بكل الصفحات الثابتة من الـ firebase.json
    const staticPages = [
        { loc: '/', changefreq: 'daily', priority: 1.0 },
        { loc: '/root.html', changefreq: 'daily', priority: 1.0 },
        { loc: '/discover.html', changefreq: 'daily', priority: 1.0 },
        { loc: '/feed.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/videos.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/video.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/achievement.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/template-store.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/explore.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/profile.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/shop.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/jobs.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/benchmark.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/network.html', changefreq: 'daily', priority: 0.8 },
        { loc: '/messages.html', changefreq: 'daily', priority: 0.7 },
        { loc: '/product.html', changefreq: 'daily', priority: 0.9 },
        { loc: '/cv.html', changefreq: 'weekly', priority: 0.9 },
        { loc: '/cv-data.json', changefreq: 'monthly', priority: 0.5 },
        { loc: '/article/index.html', changefreq: 'monthly', priority: 0.9 },
        { loc: '/checkout.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/order-confirmation.html', changefreq: 'weekly', priority: 0.4 },
        { loc: '/my-orders.html', changefreq: 'daily', priority: 0.6 },
        { loc: '/settings.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/backgrounds.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/saved.html', changefreq: 'daily', priority: 0.5 },
        { loc: '/subscription.html', changefreq: 'daily', priority: 0.8 },
        { loc: '/subscription-details.html', changefreq: 'weekly', priority: 0.6 },
        { loc: '/pricing.html', changefreq: 'weekly', priority: 0.6 },
        { loc: '/project.html', changefreq: 'daily', priority: 0.7 },
        { loc: '/project-dashboard-live.html', changefreq: 'daily', priority: 0.6 },
        { loc: '/post-job.html', changefreq: 'daily', priority: 0.6 },
        { loc: '/my-jobs.html', changefreq: 'daily', priority: 0.6 },
        { loc: '/job-applications.html', changefreq: 'daily', priority: 0.6 },
        { loc: '/application-details.html', changefreq: 'daily', priority: 0.5 },
        { loc: '/edit-job.html', changefreq: 'weekly', priority: 0.4 },
        { loc: '/job-details.html', changefreq: 'daily', priority: 0.7 },
        { loc: '/job-application.html', changefreq: 'daily', priority: 0.6 },
        { loc: '/apply-job.html', changefreq: 'daily', priority: 0.6 },
        { loc: '/post.html', changefreq: 'daily', priority: 0.7 },
        { loc: '/login.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/register.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/search.html', changefreq: 'daily', priority: 0.7 },
        { loc: '/about.html', changefreq: 'monthly', priority: 0.5 },
        { loc: '/features.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/success-stories.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/career-advice.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/salary-guide.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/find-candidates.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/recruiting-solutions.html', changefreq: 'weekly', priority: 0.5 },
        { loc: '/help.html', changefreq: 'weekly', priority: 0.4 },
        { loc: '/privacy.html', changefreq: 'monthly', priority: 0.3 },
        { loc: '/terms.html', changefreq: 'monthly', priority: 0.3 },
        { loc: '/data-deletion.html', changefreq: 'monthly', priority: 0.2 },
        { loc: '/admin/', changefreq: 'daily', priority: 0.4 },
        { loc: '/auth/callback.html', changefreq: 'yearly', priority: 0.1 },
        { loc: '/article/', changefreq: 'daily', priority: 0.6 }
    ];
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
    
    for (const page of staticPages) {
        xml += `  <url>\n`;
        xml += `    <loc>${FRONTEND_URL}${page.loc}</loc>\n`;
        xml += `    <lastmod>${today}</lastmod>\n`;
        xml += `    <changefreq>${page.changefreq}</changefreq>\n`;
        xml += `    <priority>${page.priority}</priority>\n`;
        xml += `  </url>\n`;
    }
    
    xml += '</urlset>';
    
    // حفظ كملف
    const filePath = path.join(SITEMAP_DIR, 'sitemap-static.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-static.xml (${staticPages.length} pages)`);
    
    return xml;
}


// ============================================
// دالة مساعدة لتوليد Sitemap للمنشورات (Posts) - النسخة النهائية
// ============================================
async function generatePostsSitemap() {
    
    const today = new Date().toISOString().split('T')[0];
    
    // جلب المنشورات العامة (public و followers) - آخر 10,000 منشور
    const posts = await Post.find({ 
        visibility: { $in: ['public', 'followers'] }
    })
    .populate('userId', 'username profile.nickname')
    .select('_id content images createdAt updatedAt userId')
    .sort({ updatedAt: -1 })
    .limit(10000)
    .lean(); // ✅ أضف lean() عشان تقليل الذاكرة
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"\n';
    xml += '        xmlns:news="http://www.google.com/schemas/sitemap-news/0.9"\n';
    xml += '        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">\n';
    
    for (const post of posts) {
        const lastmod = post.updatedAt ? post.updatedAt.toISOString().split('T')[0] : today;
        const publishedISO = post.createdAt ? post.createdAt.toISOString() : new Date().toISOString();
        const published = publishedISO.split('T')[0];
        
        // ✅ استخراج عنوان من المحتوى بشكل آمن
        let plainContent = '';
        if (post.content) {
            plainContent = post.content
                .replace(/<[^>]*>/g, '')
                .replace(/&/g, 'and')
                .replace(/\s+/g, ' ')
                .trim();
        }
        let newsTitle = plainContent.substring(0, 100);
        if (newsTitle.length === 100) newsTitle += '...';
        
        const postUrl = `${FRONTEND_URL}/post.html?id=${post._id}`;
        
        xml += `  <url>\n`;
        xml += `    <loc>${escapeXml(postUrl)}</loc>\n`;
        xml += `    <lastmod>${lastmod}</lastmod>\n`;
        xml += `    <changefreq>weekly</changefreq>\n`;
        xml += `    <priority>0.7</priority>\n`;
        
        // ✅ إضافة علامات News Sitemap للمنشورات الحديثة (آخر 48 ساعة)
        const twoDaysAgo = new Date();
        twoDaysAgo.setDate(twoDaysAgo.getDate() - 2);
        if (post.createdAt && new Date(post.createdAt) > twoDaysAgo && newsTitle) {
            xml += `    <news:news>\n`;
            xml += `      <news:publication>\n`;
            xml += `        <news:name>MGZon Social Feed</news:name>\n`;
            xml += `        <news:language>en</news:language>\n`;
            xml += `      </news:publication>\n`;
            xml += `      <news:publication_date>${publishedISO}</news:publication_date>\n`;
            xml += `      <news:title>${escapeXml(newsTitle)}</news:title>\n`;
            xml += `    </news:news>\n`;
        }
        
        // ✅ إضافة الصور الموجودة في المنشور (مع validation أقوى)
        if (post.images && Array.isArray(post.images) && post.images.length > 0) {
            for (const img of post.images.slice(0, 10)) {
                let imageUrl = null;
                if (typeof img === 'string') imageUrl = img;
                else if (img && typeof img === 'object' && img.url) imageUrl = img.url;
                
                if (imageUrl && typeof imageUrl === 'string' && imageUrl.startsWith('http')) {
                    xml += `    <image:image>\n`;
                    xml += `      <image:loc>${escapeXml(imageUrl)}</image:loc>\n`;
                    xml += `    </image:image>\n`;
                }
            }
        }
        
        xml += `  </url>\n`;
    }
    
    xml += '</urlset>';
    
    const filePath = path.join(SITEMAP_DIR, 'sitemap-posts.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    const imageCount = (xml.match(/<image:image>/g) || []).length;
    console.log(`✅ Saved: sitemap-posts.xml (${posts.length} posts, ${imageCount} images)`);
    
    return xml;
}

// ============================================
// دالة مساعدة لتوليد Sitemap للوظائف (Jobs) - النسخة النهائية
// ============================================
async function generateJobsSitemap() {
    
    const today = new Date().toISOString().split('T')[0];
    
    // جلب الوظائف النشطة فقط (لم تنته صلاحيتها)
    const jobs = await Job.find({ 
        status: 'active',
        deadline: { $gt: new Date() }
    })
    .populate('employerId', 'username profile.nickname')
    .select('_id title createdAt updatedAt location jobType')
    .sort({ updatedAt: -1 })
    .limit(5000)
    .lean();
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    // ✅ فقط الـ namespaces اللي محتاجها فعلاً
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
    
    for (const job of jobs) {
        const lastmod = job.updatedAt ? job.updatedAt.toISOString().split('T')[0] : today;
        const jobUrl = `${FRONTEND_URL}/job-details.html?id=${job._id}`;
        
        xml += `  <url>\n`;
        xml += `    <loc>${escapeXml(jobUrl)}</loc>\n`;
        xml += `    <lastmod>${lastmod}</lastmod>\n`;
        xml += `    <changefreq>daily</changefreq>\n`;
        xml += `    <priority>0.7</priority>\n`;
        xml += `  </url>\n`;
    }
    
    xml += '</urlset>';
    
    const filePath = path.join(SITEMAP_DIR, 'sitemap-jobs.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-jobs.xml (${jobs.length} jobs)`);
    
    return xml;
}

// ============================================
// دالة مساعدة لتوليد Sitemap للقوالب (Templates) - النسخة النهائية
// ============================================
async function generateTemplatesSitemap() {
    
    const today = new Date().toISOString().split('T')[0];
    
    const templates = await TemplateStore.find({ isActive: true })
        .select('_id name previewImage updatedAt')
        .sort({ downloadsCount: -1 })
        .limit(2000)
        .lean();
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"\n';
    xml += '        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">\n';
    
    for (const template of templates) {
        const lastmod = template.updatedAt ? template.updatedAt.toISOString().split('T')[0] : today;
        const templateUrl = `${FRONTEND_URL}/template-store.html?id=${template._id}`;
        
        xml += `  <url>\n`;
        xml += `    <loc>${escapeXml(templateUrl)}</loc>\n`;
        xml += `    <lastmod>${lastmod}</lastmod>\n`;
        xml += `    <changefreq>weekly</changefreq>\n`;
        xml += `    <priority>0.6</priority>\n`;
        
        if (template.previewImage) {
            xml += `    <image:image>\n`;
            xml += `      <image:loc>${escapeXml(template.previewImage)}</image:loc>\n`;
            xml += `    </image:image>\n`;
        }
        
        xml += `  </url>\n`;
    }
    
    xml += '</urlset>';
    
    const filePath = path.join(SITEMAP_DIR, 'sitemap-templates.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-templates.xml (${templates.length} templates)`);
    
    return xml;
}

// ============================================
// دالة مساعدة لتوليد Sitemap للصفحات المخصصة - النسخة النهائية
// ============================================
async function generatePagesSitemap() {
    
    const today = new Date().toISOString().split('T')[0];
    
    const pages = await Page.find({ 
        isEnabled: true,
        visibility: 'public'
    })
    .populate('storeId', 'profile.nickname username')
    .select('_id slug updatedAt storeId')
    .sort({ updatedAt: -1 })
    .lean();
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
    
    for (const page of pages) {
        const lastmod = page.updatedAt ? page.updatedAt.toISOString().split('T')[0] : today;
        const storeNickname = page.storeId?.profile?.nickname || page.storeId?.username || 'store';
        const pageUrl = `${FRONTEND_URL}/shop/${encodeURIComponent(storeNickname)}/page/${page.slug}`;
        
        xml += `  <url>\n`;
        xml += `    <loc>${escapeXml(pageUrl)}</loc>\n`;
        xml += `    <lastmod>${lastmod}</lastmod>\n`;
        xml += `    <changefreq>weekly</changefreq>\n`;
        xml += `    <priority>0.5</priority>\n`;
        xml += `  </url>\n`;
    }
    
    xml += '</urlset>';
    
    const filePath = path.join(SITEMAP_DIR, 'sitemap-pages.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-pages.xml (${pages.length} custom pages)`);
    
    return xml;
}

// ============================================
// دالة مساعدة لتوليد Sitemap للوسوم - النسخة النهائية
// ============================================
async function generateTagsSitemap() {
    
    const today = new Date().toISOString().split('T')[0];
    
    // جلب الوسوم الأكثر استخداماً من المنشورات
    const tags = await Post.aggregate([
        { $match: { visibility: { $in: ['public', 'followers'] } } },
        { $unwind: { path: '$tags', preserveNullAndEmptyArrays: false } },
        { $group: { _id: '$tags', count: { $sum: 1 } } },
        { $sort: { count: -1 } },
        { $limit: 500 }
    ]);
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
    
    for (const tag of tags) {
        const tagName = encodeURIComponent(tag._id);
        const tagUrl = `${FRONTEND_URL}/search.html?q=${tagName}&type=posts`;
        
        xml += `  <url>\n`;
        xml += `    <loc>${escapeXml(tagUrl)}</loc>\n`;
        xml += `    <lastmod>${today}</lastmod>\n`;
        xml += `    <changefreq>weekly</changefreq>\n`;
        xml += `    <priority>0.4</priority>\n`;
        xml += `  </url>\n`;
    }
    
    xml += '</urlset>';
    
    const filePath = path.join(SITEMAP_DIR, 'sitemap-tags.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-tags.xml (${tags.length} tags)`);
    
    return xml;
}

// ============================================
// دالة مساعدة لتوليد Sitemap للصور - النسخة النهائية
// ============================================
async function generateImageSitemap() {
    
    const today = new Date().toISOString().split('T')[0];
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"\n';
    xml += '        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">\n';
    
    let totalImages = 0;
    let totalPages = 0;
    
    // 1️⃣ صور المنتجات
    const products = await Product.find({ isActive: true, images: { $exists: true, $ne: [] } })
        .select('_id images updatedAt')
        .limit(5000)
        .lean();
    
    for (const product of products) {
        if (!product.images || product.images.length === 0) continue;
        
        const pageUrl = `${FRONTEND_URL}/product.html?id=${product._id}`;
        let hasImages = false;
        let urlBlock = `  <url>\n    <loc>${escapeXml(pageUrl)}</loc>\n    <lastmod>${product.updatedAt ? product.updatedAt.toISOString().split('T')[0] : today}</lastmod>\n`;
        
        for (const imageUrl of product.images.slice(0, 10)) {
            if (imageUrl && typeof imageUrl === 'string' && imageUrl.startsWith('http')) {
                hasImages = true;
                totalImages++;
                urlBlock += `    <image:image>\n      <image:loc>${escapeXml(imageUrl)}</image:loc>\n    </image:image>\n`;
            }
        }
        
        if (hasImages) {
            urlBlock += `  </url>\n`;
            xml += urlBlock;
            totalPages++;
        }
    }
    
    // 2️⃣ صور المنشورات
    const posts = await Post.find({ 
        'images.0': { $exists: true },
        visibility: { $in: ['public', 'followers'] }
    }).select('_id images updatedAt').limit(5000).lean();
    
    for (const post of posts) {
        if (!post.images || post.images.length === 0) continue;
        
        const pageUrl = `${FRONTEND_URL}/post.html?id=${post._id}`;
        let hasImages = false;
        let urlBlock = `  <url>\n    <loc>${escapeXml(pageUrl)}</loc>\n    <lastmod>${post.updatedAt ? post.updatedAt.toISOString().split('T')[0] : today}</lastmod>\n`;
        
        for (const img of post.images.slice(0, 10)) {
            let imageUrl = null;
            if (typeof img === 'string') imageUrl = img;
            else if (img && typeof img === 'object' && img.url) imageUrl = img.url;
            
            if (imageUrl && typeof imageUrl === 'string' && imageUrl.startsWith('http')) {
                hasImages = true;
                totalImages++;
                urlBlock += `    <image:image>\n      <image:loc>${escapeXml(imageUrl)}</image:loc>\n    </image:image>\n`;
            }
        }
        
        if (hasImages) {
            urlBlock += `  </url>\n`;
            xml += urlBlock;
            totalPages++;
        }
    }
    
    xml += '</urlset>';
    
    const filePath = path.join(SITEMAP_DIR, 'sitemap-images.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-images.xml (${totalImages} images, ${totalPages} pages)`);
    
    return xml;
}

// ============================================
// دالة مساعدة لتوليد Sitemap للتعليقات - النسخة النهائية (اختياري)
// ============================================
async function generateCommentsSitemapLight() {
    const today = new Date().toISOString().split('T')[0];
    
    // ✅ جلب بس التعليقات اللي عليها تفاعل (likes أو replies)
    const comments = await Comment.find({ 
        hidden: false,
        visibility: 'public',
        $or: [
            { likes: { $exists: true, $not: { $size: 0 } } },
            { replies: { $exists: true, $not: { $size: 0 } } }
        ]
    })
    .select('_id projectId timestamp')
    .sort({ likesCount: -1 })
    .limit(2000)  // ✅ حد أقل عشان السرعة
    .lean();
    
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
    
    for (const comment of comments) {
        if (!comment.projectId) continue;
        
        const lastmod = comment.timestamp ? comment.timestamp.toISOString().split('T')[0] : today;
        const commentUrl = `${FRONTEND_URL}/project.html?id=${comment.projectId}&comment=${comment._id}`;
        
        xml += `  <url>\n`;
        xml += `    <loc>${escapeXml(commentUrl)}</loc>\n`;
        xml += `    <lastmod>${lastmod}</lastmod>\n`;
        xml += `    <changefreq>monthly</changefreq>\n`;
        xml += `    <priority>0.3</priority>\n`;
        xml += `  </url>\n`;
    }
    
    xml += '</urlset>';
    
    const filePath = path.join(SITEMAP_DIR, 'sitemap-comments.xml');
    fs.writeFileSync(filePath, xml, 'utf8');
    console.log(`✅ Saved: sitemap-comments.xml (${comments.length} comments)`);
    
    return xml;
}


// ============================================
// دالة مساعدة لتوليد Sitemap الرئيسي (index)
// ============================================
function generateMainSitemapIndex() {
    const today = new Date().toISOString().split('T')[0];
    
    const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
    <!-- Static pages -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-static.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    
    <!-- Stores (Shops) -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-stores.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    
    <!-- Products -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-products.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    
    <!-- User Profiles -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-users.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    
    <!-- Posts / Social Feed -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-posts.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    
    <!-- Comments -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-comments.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    <!-- Jobs -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-jobs.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    
    <!-- Templates -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-templates.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    
    <!-- Custom Pages -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-pages.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    
    <!-- Images -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-images.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>

    <!-- Tags & Categories -->
    <sitemap>
        <loc>${FRONTEND_URL}/sitemap-tags.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    <sitemap>
        <loc>${FRONTEND_URL}/annotations.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
    <sitemap>
        <loc>${FRONTEND_URL}/context.xml</loc>
        <lastmod>${today}</lastmod>
    </sitemap>
</sitemapindex>`;
    
    const filePath = path.join(SITEMAP_DIR, 'sitemap.xml');
    fs.writeFileSync(filePath, sitemap, 'utf8');
    console.log(`✅ Saved: sitemap.xml (index with ${sitemap.match(/<sitemap>/g)?.length || 0} sub-sitemaps)`);
    
    return sitemap;
}


// ============================================
// دالة مساعدة لتوليد robots.txt
// ============================================
function generateRobotsTxt() {
    
    const robots = `User-agent: *
Allow: /
Disallow: /api/
Disallow: /admin/
Disallow: /settings
Disallow: /login
Disallow: /register
Disallow: /logout
Disallow: /reset-password
Disallow: /auth/

# Allow search engines to find important content
Allow: /shop/
Allow: /product.html
Allow: /post.html
Allow: /job-details.html
Allow: /profile/
Allow: /template-store.html
Allow: /ibrahim_al_asfar.ged


# Crawl delay (be nice to search engines)
Crawl-delay: 1

# Sitemaps
Sitemap: ${FRONTEND_URL}/sitemap.xml
Sitemap: ${FRONTEND_URL}/sitemap-static.xml
Sitemap: ${FRONTEND_URL}/sitemap-stores.xml
Sitemap: ${FRONTEND_URL}/sitemap-products.xml
Sitemap: ${FRONTEND_URL}/sitemap-users.xml
Sitemap: ${FRONTEND_URL}/sitemap-posts.xml
Sitemap: ${FRONTEND_URL}/sitemap-jobs.xml
Sitemap: ${FRONTEND_URL}/sitemap-templates.xml
Sitemap: ${FRONTEND_URL}/sitemap-pages.xml
Sitemap: ${FRONTEND_URL}/sitemap-images.xml
Sitemap: ${FRONTEND_URL}/sitemap-comments.xml
Sitemap: ${FRONTEND_URL}/sitemap-tags.xml`;

    const filePath = path.join(SITEMAP_DIR, 'robots.txt');
    fs.writeFileSync(filePath, robots, 'utf8');
    console.log(`✅ Saved: robots.txt`);
    
    return robots;
}

// ============================================
// الدالة الرئيسية لتوليد كل الـ Sitemaps
// ============================================
async function regenerateAllSitemaps() {
    const startTime = Date.now();
    console.log('🔄 Starting sitemap regeneration...');
    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
    
    try {
        // توليد كل الـ Sitemaps بالتوازي (أسرع)
        const results = await Promise.all([
            generateStaticSitemap(),
            generateStoresSitemap(),
            generateProductsSitemap(),
            generateUsersSitemap(),
            generatePostsSitemap(),     
            generateJobsSitemap(),      
            generateTemplatesSitemap(), 
            generatePagesSitemap(),     
            generateTagsSitemap(),      
            generateImageSitemap(),
            generateCommentsSitemapLight(),
            generateMainSitemapIndex(),
            Promise.resolve(generateRobotsTxt())
        ]);
        
        const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
        console.log(`✅ All sitemaps regenerated successfully in ${elapsed}s!`);
        console.log(`   - Posts: ${results[4]?.match(/<url>/g)?.length || 0} URLs`);
        console.log(`   - Jobs: ${results[5]?.match(/<url>/g)?.length || 0} URLs`);
        console.log(`   - Templates: ${results[6]?.match(/<url>/g)?.length || 0} URLs`);
        console.log(`   - Pages: ${results[7]?.match(/<url>/g)?.length || 0} URLs`);
        console.log(`   - Tags: ${results[8]?.match(/<url>/g)?.length || 0} URLs`);

        
        // تسجيل في الـ logs
        const logEntry = {
            timestamp: new Date().toISOString(),
            elapsed: `${elapsed}s`,
            success: true,
            counts: {
                posts: results[4]?.match(/<url>/g)?.length || 0,
                jobs: results[5]?.match(/<url>/g)?.length || 0,
                templates: results[6]?.match(/<url>/g)?.length || 0
            }

        };
        
        const logPath = path.join(SITEMAP_DIR, 'sitemap-logs.json');
        let logs = [];
        if (fs.existsSync(logPath)) {
            logs = JSON.parse(fs.readFileSync(logPath, 'utf8'));
        }
        logs.unshift(logEntry);
        if (logs.length > 100) logs.pop(); // احتفظ بآخر 100 تسجيل فقط
        fs.writeFileSync(logPath, JSON.stringify(logs, null, 2));
        
        return true;
        
    } catch (error) {
        console.error('❌ Error regenerating sitemaps:', error);
        
        // تسجيل الخطأ
        const errorLogPath = path.join(SITEMAP_DIR, 'sitemap-error.log');
        const errorEntry = `[${new Date().toISOString()}] ${error.message}\n${error.stack}\n\n`;
        fs.appendFileSync(errorLogPath, errorEntry);
        
        return false;
    }
}

// ============================================
// تشغيل التوليد التلقائي كل 24 ساعة
// ============================================

// تشغيل لأول مرة عند بدء السيرفر
setTimeout(() => {
    regenerateAllSitemaps();
}, 5000); // بعد 5 ثواني من بدء السيرفر

// جدولة التشغيل كل 24 ساعة
const TWENTY_FOUR_HOURS = 24 * 60 * 60 * 1000;
setInterval(() => {
    console.log('⏰ Running scheduled sitemap regeneration...');
    regenerateAllSitemaps();
}, TWENTY_FOUR_HOURS);

// ============================================
// APIs لخدمة الـ Sitemaps كملفات static (أسرع من dynamic)
// ============================================

// خدمة sitemap.xml من الملف الـ static
app.get('/sitemap.xml', (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        // لو الملف مش موجود، يولده على طول
        generateMainSitemapIndex().then(xml => {
            res.header('Content-Type', 'application/xml');
            res.send(xml);
        });
    }
});

// خدمة sitemap-static.xml
app.get('/sitemap-static.xml', (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-static.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        generateStaticSitemap().then(xml => {
            res.header('Content-Type', 'application/xml');
            res.send(xml);
        });
    }
});

// خدمة sitemap-stores.xml
app.get('/sitemap-stores.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-stores.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        const xml = await generateStoresSitemap();
        res.header('Content-Type', 'application/xml');
        res.send(xml);
    }
});

// خدمة sitemap-products.xml
app.get('/sitemap-products.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-products.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        const xml = await generateProductsSitemap();
        res.header('Content-Type', 'application/xml');
        res.send(xml);
    }
});

// خدمة sitemap-users.xml
app.get('/sitemap-users.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-users.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        const xml = await generateUsersSitemap();
        res.header('Content-Type', 'application/xml');
        res.send(xml);
    }
});


app.get('/sitemap-images.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-images.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        const xml = await generateImageSitemap();
        res.header('Content-Type', 'application/xml');
        res.send(xml);
    }
});
app.get('/sitemap-comments.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-comments.xml');
    
    if (fs.existsSync(filePath)) {
        res.setHeader('Content-Type', 'application/xml');
        return res.sendFile(filePath);
    }
    
    try {
        const xml = await generateCommentsSitemapLight();
        res.setHeader('Content-Type', 'application/xml');
        res.send(xml);
    } catch (error) {
        res.status(500).send('Error generating sitemap');
    }
});

// خدمة sitemap-posts.xml
app.get('/sitemap-posts.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-posts.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        const xml = await generatePostsSitemap();
        res.header('Content-Type', 'application/xml');
        res.send(xml);
    }
});

// خدمة sitemap-jobs.xml
app.get('/sitemap-jobs.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-jobs.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        const xml = await generateJobsSitemap();
        res.header('Content-Type', 'application/xml');
        res.send(xml);
    }
});

// خدمة sitemap-templates.xml
app.get('/sitemap-templates.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-templates.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        const xml = await generateTemplatesSitemap();
        res.header('Content-Type', 'application/xml');
        res.send(xml);
    }
});

// خدمة sitemap-pages.xml
app.get('/sitemap-pages.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-pages.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        const xml = await generatePagesSitemap();
        res.header('Content-Type', 'application/xml');
        res.send(xml);
    }
});

// خدمة sitemap-tags.xml
app.get('/sitemap-tags.xml', async (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'sitemap-tags.xml');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'application/xml');
        res.sendFile(filePath);
    } else {
        const xml = await generateTagsSitemap();
        res.header('Content-Type', 'application/xml');
        res.send(xml);
    }
});

// خدمة robots.txt
app.get('/robots.txt', (req, res) => {
    const filePath = path.join(SITEMAP_DIR, 'robots.txt');
    if (fs.existsSync(filePath)) {
        res.header('Content-Type', 'text/plain');
        res.sendFile(filePath);
    } else {
        const robots = generateRobotsTxt();
        res.header('Content-Type', 'text/plain');
        res.send(robots);
    }
});

// ============================================
// API لإعادة توليد الـ Sitemaps يدوياً (Admin فقط)
// ============================================
app.post('/api/admin/regenerate-sitemaps', authenticateToken, async (req, res) => {
    try {
        // التحقق من صلاحيات الأدمن
        const admin = await User.findById(req.user.userId);
        if (!admin || !admin.isAdmin) {
            return res.status(403).json({ error: 'Admin access required' });
        }
        
        const success = await regenerateAllSitemaps();
        
        if (success) {
            res.json({ 
                success: true, 
                message: 'Sitemaps regenerated successfully',
                timestamp: new Date().toISOString()
            });
        } else {
            res.status(500).json({ error: 'Failed to regenerate sitemaps' });
        }
        
    } catch (error) {
        console.error('Error manually regenerating sitemaps:', error);
        res.status(500).json({ error: 'Failed to regenerate sitemaps' });
    }
});
// Serve static verification files
app.get('/google620570ce87abd87a.html', (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'google620570ce87abd87a.html'));
});

app.get('/BingSiteAuth.xml', (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'BingSiteAuth.xml'));
});

app.get('/yandex_b820fb59d7fe880e.html', (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'yandex_b820fb59d7fe880e.html'));
});


module.exports = {
    sendEmailWithBrevo,
    sendStoreEmailWithBrevo,

    Page,
    SubscriptionPlan,
    PlatformPaymentMethod,
    UserSubscription,
    SubscriptionSettings,
    SubscriptionEarnings,
    Earnings,
    Coupon,
    PlatformBank,
    StoreFollow,
    Cart,
    LayoutPreset,
    User,
    Product,
    Order,
    Review,
    AIConversation,
    Skill,
    Conversation,
    Message,
    StoreTheme,
    StoreSettings,
    Follow,
    Notification,
    SiteSettings,
    Project,
    Comment,
    MessageReport,
    Report,
    Post,
    Job,
    JobApplication,
    JobSave,
    JobCategory,
    Story,
    StoreFollow,
    Rating,
    ProfileAnalytics,
    AlsoViewed,
    PageSuggestion
};


// Serve profile image and logos
app.use('/images', express.static('public/images'));



app.get('/', (req, res) => {
    res.render('index');
});


// ============================================
// 🚀 GRAPHQL SETUP
// ============================================
const { ApolloServer } = require('@apollo/server');
const { expressMiddleware } = require('@as-integrations/express4');
const { ApolloServerPluginLandingPageLocalDefault } = require('@apollo/server/plugin/landingPage/default');
const typeDefs = require('./graphql/schema');
const resolvers = require('./graphql/resolvers');
const context = require('./graphql/context');

// إنشاء GraphQL Server
const graphqlServer = new ApolloServer({
  typeDefs,
  resolvers,
  introspection: true,  // ← خليها true عشان تظهر الواجهة
  plugins: [
    ApolloServerPluginLandingPageLocalDefault({ embed: true })  // ← السطر الجديد
  ],
  formatError: (formattedError) => {
    console.error('GraphQL Error:', formattedError);
    return formattedError;
  }
});

// بدء GraphQL Server (انتظار async)
const startGraphQL = async () => {
  await graphqlServer.start();
  console.log('✅ GraphQL Server started');

  // تطبيق GraphQL Middleware
  app.use(
    '/graphql',
    express.json(),
    expressMiddleware(graphqlServer, {
      context: async ({ req }) => context({ req })
    })
  );

  console.log('🚀 GraphQL Server running on /graphql');
};

// تشغيل GraphQL
startGraphQL().catch(err => {
  console.error('❌ Failed to start GraphQL Server:', err);
});

const server = app.listen(PORT, () => {
    logger.info(`🚀 Server running on port ${PORT}`);
    logger.info(`📡 Timeout set to: ${server.timeout / 1000} seconds`);
});

// Increase timeouts for large file uploads (themes, etc.)
server.timeout = 120000;        // 120 seconds - reading timeout
server.keepAliveTimeout = 120000; // 120 seconds - keep-alive
server.headersTimeout = 120000;   // 120 seconds - headers timeout

// Graceful shutdown
process.on('SIGTERM', () => {
    logger.info('SIGTERM signal received: closing HTTP server');
    server.close(() => {
        logger.info('HTTP server closed');
        process.exit(0);
    });
});

process.on('SIGINT', () => {
    logger.info('SIGINT signal received: closing HTTP server');
    server.close(() => {
        logger.info('HTTP server closed');
        process.exit(0);
    });
});