server.js

const express = require('express');
const multer = require('multer');
const path = require('path');
const fs = require('fs-extra');
const mime = require('mime-types');
const chokidar = require('chokidar');
const crypto = require('crypto');
const yauzl = require('yauzl');
const util = require('util');
const { createServer } = require('http');
const { Server } = require('socket.io');
let ZIMReader = null; // Keep for compatibility
let zimLib = null;
let zimAvailable = false;
let zimLoaded = false;

// Load ZIM functionality
const loadZIM = async () => {
  if (zimLoaded) return zimAvailable;
  
  try {
    zimLib = await import('@openzim/libzim');
    if (zimLib.ZIMReader) console.log('ZIMReader available');
    if (zimLib.ZIM) console.log('ZIM available');
    if (zimLib.Archive) console.log('Archive available');
    zimAvailable = true;
    return true;
  } catch (error) {
    console.warn('ZIM functionality unavailable:', error.message);
    console.warn('ZIM file support will be disabled');
    return false;
  } finally {
    zimLoaded = true;
  }
};
const app = express();
const PORT = process.env.PORT || 3000;

// Configuration
const config = {
  storagePath: process.env.STORAGE_PATH || path.join(__dirname, 'storage'),
  configPath: process.env.CONFIG_PATH || path.join(__dirname, 'config'),
  maxFileSize: process.env.MAX_FILE_SIZE || '10gb',
  adminPassword: process.env.ADMIN_PASSWORD || 'admin',
  serverName: process.env.SERVER_NAME || 'Nomad Docker Server'
};

// Advanced Indexing System (using function constructor for compatibility)
function MediaIndexer() {
  this.indexes = new Map();
  this.watchers = new Map();
  this.building = new Set();
  this.mediaExtensions = {
    video: ['.mp4', '.mkv', '.avi', '.mov', '.wmv', '.flv', '.webm', '.m4v', '.3gp'],
    audio: ['.mp3', '.flac', '.wav', '.aac', '.ogg', '.m4a', '.wma'],
    image: ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg', '.tiff'],
    book: ['.epub', '.pdf', '.mobi', '.azw', '.txt', '.fb2'],
    comic: ['.cbz', '.cbr', '.zip'], 
    archive: ['.zim', '.zip', '.rar', '.7z', '.tar', '.gz'],
    playlist: ['.m3u', '.m3u8', '.pls', '.xspf'],
    rom: ['.nes', '.sfc', '.smc', '.gba', '.gb', '.gbc', '.n64', '.gen', '.md', '.sms', '.psx', '.ps1', '.iso', '.bin', '.z64', '.v64']
  };
}

// Get file signature for change detection
MediaIndexer.prototype.getDirectorySignature = async function(dirPath) {
  try {
    const items = await fs.readdir(dirPath);
    const stats = await Promise.all(
      items.map(async function(item) {
        try {
          const stat = await fs.stat(path.join(dirPath, item));
          return item + ':' + stat.mtime.getTime() + ':' + stat.size;
        } catch (e) {
          return null;
        }
      })
    );
    return crypto.createHash('md5').update(stats.filter(Boolean).join('|')).digest('hex');
  } catch (e) {
    return null;
  }
};

// Check if file matches media extensions
MediaIndexer.prototype.isMediaFile = function(filename, category) {
  category = category || 'all';
  const ext = path.extname(filename).toLowerCase();
  if (category === 'all') {
    const allExtensions = Object.values(this.mediaExtensions);
    return allExtensions.some(function(exts) {
      return exts.includes(ext);
    });
  }
  const categoryExts = this.mediaExtensions[category];
  return categoryExts && categoryExts.includes(ext) || false;
};

// Build index for a directory with optional recursion for Shows and Music
MediaIndexer.prototype.buildIndex = async function(dirPath, recursive) {
  const self = this;
  const normalizedPath = path.normalize(dirPath);
  
  if (this.building.has(normalizedPath)) {
    throw new Error('INDEX_BUILDING');
  }

  this.building.add(normalizedPath);

  try {
    if (!await fs.pathExists(dirPath)) {
      throw new Error('Directory not found');
    }

    const signature = await this.getDirectorySignature(dirPath);
    const entries = [];

    // Determine if we should scan recursively based on directory name
    const dirName = path.basename(dirPath);
    const shouldRecurse = recursive || ['Shows', 'Music'].includes(dirName);

    if (shouldRecurse) {
      // Recursive scan for Shows and Music
      const allEntries = await this.buildRecursiveIndex(dirPath);
      for (const entry of allEntries) {
        entries.push(entry);
      }
    } else {
      // Single level scan
      const items = await fs.readdir(dirPath);
      for (const item of items) {
        try {
          const itemPath = path.join(dirPath, item);
          const stats = await fs.stat(itemPath);
          
          // Build relative path from storage root
          const relativePath = path.relative(settings.mediaDirectory || config.storagePath, itemPath).replace(/\\/g, '/');
          
          entries.push({
            n: item, // name
            t: stats.isDirectory() ? 'd' : 'f', // type: directory or file
            p: '/' + relativePath, // full path from root
            sz: stats.size,
            mt: Math.floor(stats.mtime.getTime() / 1000),
            isDir: stats.isDirectory(),
            isMedia: stats.isDirectory() ? false : self.isMediaFile(item)
          });
        } catch (error) {
          console.warn('Error processing ' + item + ':', error.message);
        }
      }
    }

    entries.sort(function(a, b) {
      if (a.isDir && !b.isDir) return -1;
      if (!a.isDir && b.isDir) return 1;
      return a.n.localeCompare(b.n, undefined, { numeric: true });
    });

    const relativeDirPath = path.relative(settings.mediaDirectory || config.storagePath, dirPath).replace(/\\/g, '/');
    const header = {
      path: '/' + (relativeDirPath || ''),
      sig: signature,
      count: entries.length,
      ts: Math.floor(Date.now() / 1000),
      server: 'nomad-docker'
    };

    const indexData = { header: header, entries: entries, signature: signature };
    this.indexes.set(normalizedPath, indexData);
    this.setupWatcher(dirPath);
    return indexData;

  } finally {
    this.building.delete(normalizedPath);
  }
};

// Setup file watcher for real-time updates
MediaIndexer.prototype.setupWatcher = function(dirPath) {
  const self = this;
  const normalizedPath = path.normalize(dirPath);
  
  if (this.watchers.has(normalizedPath)) {
    this.watchers.get(normalizedPath).close();
  }

  const watcher = chokidar.watch(dirPath, {
    ignoreInitial: true,
    depth: 0,
    persistent: true,
    usePolling: false
  });

  watcher
    .on('add', function() { self.invalidateIndex(normalizedPath); })
    .on('unlink', function() { self.invalidateIndex(normalizedPath); })
    .on('addDir', function() { self.invalidateIndex(normalizedPath); })
    .on('unlinkDir', function() { self.invalidateIndex(normalizedPath); })
    .on('change', function() { self.invalidateIndex(normalizedPath); });

  this.watchers.set(normalizedPath, watcher);
};

// Invalidate index when directory changes
MediaIndexer.prototype.invalidateIndex = function(dirPath) {
  const self = this;
  const normalizedPath = path.normalize(dirPath);
  
  this.indexes.delete(normalizedPath);
  
  setTimeout(async function() {
    try {
      await self.buildIndex(dirPath);
    } catch (error) {
      console.error('Error rebuilding index for ' + dirPath + ':', error.message);
    }
  }, 500);
};

// Get index for directory (build if needed)
MediaIndexer.prototype.getIndex = async function(dirPath) {
  const normalizedPath = path.normalize(dirPath);
  
  if (this.indexes.has(normalizedPath)) {
    const cached = this.indexes.get(normalizedPath);
    const currentSig = await this.getDirectorySignature(dirPath);
    if (cached.signature === currentSig) {
      return cached;
    }
  }

  return await this.buildIndex(dirPath);
};

// Recursively scan directory for NDJSON (needed by some frontends) - FIXED
MediaIndexer.prototype.buildRecursiveIndex = async function(rootPath) {
  const self = this;
  const allEntries = [];
  
  // Get the category name from the directory being scanned
  const mediaDirectory = settings.mediaDirectory || config.storagePath;
  const categoryRelativePath = path.relative(mediaDirectory, rootPath).replace(/\\/g, '/');
  
  async function scanDir(dirPath, relativePath) {
    try {
      const items = await fs.readdir(dirPath);
      
      for (const item of items) {
        const itemPath = path.join(dirPath, item);
        const stats = await fs.stat(itemPath);
        const itemRelativePath = relativePath ? relativePath + '/' + item : item;
        
        // Build full relative path from media root including category
        const fullRelativePath = categoryRelativePath ? categoryRelativePath + '/' + itemRelativePath : itemRelativePath;
        
        allEntries.push({
          n: item,
          t: stats.isDirectory() ? 'd' : 'f',
          p: '/' + fullRelativePath,
          sz: stats.size,
          mt: Math.floor(stats.mtime.getTime() / 1000),
          isDir: stats.isDirectory(),
          isMedia: stats.isDirectory() ? false : self.isMediaFile(item)
        });
        
        // Recurse into subdirectories
        if (stats.isDirectory()) {
          await scanDir(itemPath, itemRelativePath);
        }
      }
    } catch (error) {
      console.warn('Error scanning ' + dirPath + ':', error.message);
    }
  }
  
  await scanDir(rootPath, '');
  return allEntries;
};

// Generate legacy media.json format
MediaIndexer.prototype.generateMediaJson = async function() {
  const self = this;
  const mediaData = {
    movies: [],
    shows: [],
    music: [],
    books: [],
    archive: [],
    games: []
  };

  const categories = [
    { key: 'movies', dir: 'Movies', types: ['video'] },
    { key: 'shows', dir: 'Shows', types: ['video'] },
    { key: 'music', dir: 'Music', types: ['audio'] },
    { key: 'books', dir: 'Books', types: ['book'] },
    { key: 'archive', dir: 'Archive', types: ['archive'] },
    { key: 'games', dir: 'Games', types: ['rom'] }
  ];

  const mediaDirectory = settings.mediaDirectory || config.storagePath;

  for (const category of categories) {
    const categoryPath = path.join(mediaDirectory, category.dir);
    if (await fs.pathExists(categoryPath)) {
      try {
        // Get recursive entries for this category
        const entries = await this.buildRecursiveIndex(categoryPath);
        
        for (const entry of entries) {
          if (!entry.isDir && this.isMediaFile(entry.n)) {
            // Check if this matches the category type
            let matches = false;
            for (const type of category.types) {
              if (this.isMediaFile(entry.n, type)) {
                matches = true;
                break;
              }
            }
            
            if (matches) {
              mediaData[category.key].push({
                name: entry.n,
                file: entry.p,
                path: entry.p,
                size: entry.sz,
                mtime: entry.mt * 1000,
                type: path.extname(entry.n).substring(1).toLowerCase() || 'file'
              });
            }
          }
        }
      } catch (error) {
        console.warn('Error building media.json for ' + category.dir + ':', error.message);
      }
    }
  }

  return mediaData;
};

// Cleanup watchers
MediaIndexer.prototype.cleanup = function() {
  for (const watcher of this.watchers.values()) {
    watcher.close();
  }
  this.watchers.clear();
  this.indexes.clear();
};
// Comic handling utilities
// Comic handling utilities
const ComicReader = {
  pageCache: new Map(), // Cache for extracted pages
  infoCache: new Map(), // Cache for comic info
  
  // Check if file is a comic
  isComic: function(filename) {
    const ext = path.extname(filename).toLowerCase();
    return ['.cbz', '.cbr', '.zip'].includes(ext);
  },

  // Get comic info with caching
  getComicInfo: async function(filePath) {
    // Check cache first
    const cacheKey = filePath + ':info';
    if (this.infoCache.has(cacheKey)) {
      return this.infoCache.get(cacheKey);
    }

    return new Promise((resolve, reject) => {
      yauzl.open(filePath, { lazyEntries: true }, (err, zipfile) => {
        if (err) return reject(err);
        
        const pages = [];
        const imageExts = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.tiff'];
        
        zipfile.readEntry();
        
        zipfile.on('entry', (entry) => {
          if (!entry.fileName.endsWith('/') && !entry.fileName.startsWith('__MACOSX/')) {
            const ext = path.extname(entry.fileName).toLowerCase();
            if (imageExts.includes(ext)) {
              pages.push({
                name: entry.fileName,
                index: pages.length,
                size: entry.uncompressedSize
              });
            }
          }
          zipfile.readEntry();
        });
        
        zipfile.on('end', () => {
          // Sort pages naturally (handles numbers correctly)
          pages.sort((a, b) => {
            return a.name.localeCompare(b.name, undefined, { 
              numeric: true, 
              sensitivity: 'base' 
            });
          });
          
          const info = {
            pageCount: pages.length,
            pages: pages,
            fileName: path.basename(filePath)
          };
          
          // Cache the info
          this.infoCache.set(cacheKey, info);
          resolve(info);
        });
        
        zipfile.on('error', reject);
      });
    });
  },

  // Extract page with sequential processing
  getComicPage: async function(filePath, pageIndex) {
    // Check page cache first
    const cacheKey = `${filePath}:${pageIndex}`;
    if (this.pageCache.has(cacheKey)) {
      return this.pageCache.get(cacheKey);
    }

    // First, get the comic info to know which page we want
    const info = await this.getComicInfo(filePath);
    
    if (pageIndex >= info.pages.length || pageIndex < 0) {
      throw new Error(`Page ${pageIndex} not found. Comic has ${info.pages.length} pages.`);
    }

    const targetPageName = info.pages[pageIndex].name;

    return new Promise((resolve, reject) => {
      yauzl.open(filePath, { lazyEntries: true }, (err, zipfile) => {
        if (err) return reject(err);
        
        zipfile.readEntry();
        
        zipfile.on('entry', (entry) => {
          if (entry.fileName === targetPageName) {
            // Found our target page, extract it immediately
            zipfile.openReadStream(entry, (err, readStream) => {
              if (err) {
                zipfile.close();
                return reject(err);
              }
              
              const chunks = [];
              readStream.on('data', (chunk) => chunks.push(chunk));
              readStream.on('end', () => {
                zipfile.close();
                
                const buffer = Buffer.concat(chunks);
                const mimeType = mime.lookup(entry.fileName) || 'image/jpeg';
                
                const pageData = {
                  buffer: buffer,
                  mimeType: mimeType,
                  fileName: path.basename(entry.fileName)
                };
                
                // Cache the page
                if (this.pageCache.size < 50) {
                  this.pageCache.set(cacheKey, pageData);
                }
                
                resolve(pageData);
              });
              readStream.on('error', (err) => {
                zipfile.close();
                reject(err);
              });
            });
          } else {
            zipfile.readEntry();
          }
        });
        
        zipfile.on('end', () => {
          zipfile.close();
          reject(new Error('Page not found in archive'));
        });
        
        zipfile.on('error', (err) => {
          zipfile.close();
          reject(err);
        });
      });
    });
  },

  // Clear cache when needed
  clearCache: function() {
    this.pageCache.clear();
    this.infoCache.clear();
  }
};

// ZIM Archive Manager
function ZimManager() {
  this.zimFiles = new Map();
  this.zimIndex = new Map();
  this.initialized = false;
}

ZimManager.prototype.initialize = async function() {
  if (this.initialized) return;
  
  const archivePath = path.join(settings.mediaDirectory || config.storagePath, 'Archives');
  await fs.ensureDir(archivePath);
  
  try {
    const files = await fs.readdir(archivePath);
    
    const zimFiles = files.filter(function(f) { return f.toLowerCase().endsWith('.zim'); });
    
    if (zimFiles.length === 0) {
      this.initialized = true;
      return;
    }
    
    // Wait for ZIM module to load
    const isAvailable = await loadZIM();
    if (!isAvailable) {
      this.initialized = true;
      return;
    }
  
    
    for (const zimFile of zimFiles) {
      try {
        const filePath = path.join(archivePath, zimFile);
        const stats = await fs.stat(filePath);
        
        if (stats.size > 0) {
          const zimReader = new zimLib.Archive(filePath);
          this.zimFiles.set(zimFile, zimReader);
          const title = zimReader.getMetadata('Title') || zimFile;
          const description = zimReader.getMetadata('Description') || '';
          const articleCount = zimReader.articleCount;
          
          // ADD THIS MISSING LINE:
          this.zimIndex.set(zimFile, {
            filename: zimFile,
            title: title,
            description: description,
            articleCount: articleCount,
            path: filePath
          });
          
        } else {
        }
      } catch (error) {
        console.warn('⚠️ Failed to load ZIM file ' + zimFile + ':', error.message);
      }
    }
    
    this.initialized = true;
  } catch (error) {
    console.error('Error initializing ZIM files:', error);
    this.initialized = true;
  }
};
ZimManager.prototype.searchArticles = async function(query, limit) {
  if (!this.initialized) await this.initialize();
  
  limit = limit || 20;
  const results = [];
  const searchTerm = query.toLowerCase();
  
  for (const [filename, zimFile] of this.zimFiles.entries()) {
    
    // Always use manual iteration for partial title matching
    try {
      const titleIterator = zimFile.iterByTitle();
      let count = 0;
      let totalChecked = 0;
      
      for (const entry of titleIterator) {
        totalChecked++;
        if (count >= limit) break;
        if (totalChecked > 2000) break; // Check more entries but prevent infinite loop
        
        if (entry.title && entry.title.toLowerCase().includes(searchTerm)) {
          // Skip redirect entries since they often don't work in truncated ZIM files
          if (entry.isRedirect) {
          } else {
            
            const resultUrl = entry.path || entry.title;
            
            results.push({
              title: entry.title,
              url: resultUrl,
              filename: filename,
              zimTitle: this.zimIndex.get(filename).title
            });
            count++;
          }
        }
        
        // Log progress every 500 entries
        if (totalChecked % 500 === 0) {
        if (entry.title && entry.title.toLowerCase().includes(searchTerm)) {
          
          const resultUrl = entry.path || entry.title;
          
          results.push({
            title: entry.title,
            url: resultUrl,  // Make sure we use a valid URL
            filename: filename,
            zimTitle: this.zimIndex.get(filename).title
          });
          count++;
        }
        }
      }
    } catch (error) {
      console.warn('🔍 ZIM Search Debug: Manual iteration failed:', error.message);
    }
  }
  return results.slice(0, limit);
};

ZimManager.prototype.getArticle = async function(filename, articleUrl) {
  if (!this.initialized) await this.initialize();
  
  const zimReader = this.zimFiles.get(filename);
  if (!zimReader) {
    throw new Error('ZIM file not found: ' + filename);
  }
  
  try {
    let entry;
    
    // List of possible namespaces to try for images and assets
    const possiblePaths = [
      articleUrl,                    // Original path
      'I/' + articleUrl,            // Image namespace
      'A/' + articleUrl,            // Article namespace  
      '-/' + articleUrl,            // Other assets namespace
      articleUrl.replace(/^_assets_\//, 'I/'),  // Convert _assets_ to I/
      articleUrl.replace(/^_assets_\//, '-/'),  // Convert _assets_ to -/
      articleUrl.replace(/^_assets_\//, 'A/'),  // Convert _assets_ to A/
    ];
    
    // Remove duplicates
    const uniquePaths = [...new Set(possiblePaths)];
    
    // Try different methods to get the entry
    for (const tryPath of uniquePaths) {;
      if (zimReader.hasEntryByPath && zimReader.hasEntryByPath(tryPath)) {
        entry = zimReader.getEntryByPath(tryPath);
        break;
      } else if (zimReader.hasEntryByTitle && zimReader.hasEntryByTitle(tryPath)) {
        entry = zimReader.getEntryByTitle(tryPath);
        break;
      }
    }
    
    // If still not found, try iterating (last resort)
    if (!entry) {
      const titleIterator = zimReader.iterByTitle();
      let count = 0;
      for (const iterEntry of titleIterator) {
        count++;
        // Stop after checking too many entries to avoid performance issues
        if (count > 50000) break;
        
        for (const tryPath of uniquePaths) {
          if (iterEntry.path === tryPath || iterEntry.title === tryPath) {
            entry = iterEntry;
            break;
          }
        }
        if (entry) break;
      }
    }
    
    if (!entry) {
      throw new Error('Entry not found');
    }
    // Get the content using the correct ZIM library methods
    let content, mimeType;

    // Check if this is a redirect entry and follow it
    if (entry.isRedirect) {
      try {
        // Try different ways to get the redirect target
        let redirectTarget = null;
        
        // Method 1: Try redirectEntry() function
        if (typeof entry.redirectEntry === 'function') {
          try {
            redirectTarget = entry.redirectEntry();
          } catch (e) {
          }
        }
        
        // Method 2: Try getRedirectEntry() function
        if (!redirectTarget && typeof entry.getRedirectEntry === 'function') {
          try {
            redirectTarget = entry.getRedirectEntry();
          } catch (e) {
          }
        }
        
        // Method 3: Check if redirect is an index/number
        if (!redirectTarget && typeof entry.redirect !== 'undefined') {
          // If redirect is a number, try to get entry by index
          if (typeof entry.redirect === 'number') {
            try {
              redirectTarget = zimReader.getEntryByClusterOrder(entry.redirect);
            } catch (e) {
            }
          }
        }
        
        if (redirectTarget) {
          // Recursively call getArticle with the redirect target
          return await this.getArticle(filename, redirectTarget.path);
        } else {
          // Try to get content anyway - might be HTML redirect
          const item = entry.getItem();
          if (item) {
            // Continue to content extraction to see if it's an HTML redirect
          } else {
            throw new Error('Redirect entry has no content and redirect could not be followed: ' + entry.path);
          }
        }
      } catch (redirectError) {
        console.error('🔍 ZIM Article Debug: Failed to follow redirect:', redirectError);
        throw redirectError;
      }
    }

    try {
      const item = entry.getItem();
      if (!item) {
        throw new Error('No content item found for entry: ' + entry.path);
      }
      // Get the raw content - it's a Blob object
      const rawContent = item.getData();
      // Since it's a Blob, try to get data from the item's data property instead
      let blobData;
      if (typeof item.data !== 'undefined') {
        blobData = item.data;
      } else if (rawContent && typeof rawContent.data !== 'undefined') {
        blobData = rawContent.data;
      } else {
        // Try different Blob extraction methods
        if (rawContent && typeof rawContent.getData === 'function') {
          blobData = rawContent.getData();
        } else {
          blobData = rawContent;
        }
      }

      // Get MIME type FIRST to determine how to handle content
      mimeType = item.mimetype || 'text/html';

      // Handle binary content (images, etc.) differently from text content
      if (mimeType.startsWith('image/') || mimeType.startsWith('audio/') || 
          mimeType.startsWith('video/') || mimeType === 'application/octet-stream') {

        // For binary content, return raw data WITHOUT converting to string
        let binaryData;
        if (blobData instanceof Buffer) {
          binaryData = blobData;
        } else if (blobData instanceof Uint8Array) {
          binaryData = Buffer.from(blobData);
        } else {
          // Try to extract binary data from the item
          try {
            binaryData = Buffer.from(blobData);
          } catch (e) {
            console.error('Failed to convert to binary data:', e);
            throw new Error('Could not extract binary data from ZIM entry');
          }
        }

        return {
          title: entry.title,
          content: binaryData,
          mimeType: mimeType,
          isBinary: true
        };
        
      } else {
        // Handle text content (HTML, CSS, JS, etc.)

        // Convert data to string
        if (blobData instanceof Buffer) {
          content = blobData.toString('utf8');
        } else if (blobData instanceof Uint8Array) {
          content = new TextDecoder('utf8').decode(blobData);
        } else if (typeof blobData === 'string') {
          content = blobData;
        } else {
          content = String(blobData);
        }
    
        // Check if content is an HTML redirect
        if (content && content.includes('<meta http-equiv="refresh"')) {
          
          // Extract the redirect URL from meta refresh
          const metaRefreshMatch = content.match(/content="\d+;URL='([^']+)'/i);
          if (metaRefreshMatch) {
            const redirectUrl = metaRefreshMatch[1];
            
            // Clean up the redirect URL (remove ./ prefix, handle fragments)
            let cleanUrl = redirectUrl.replace(/^\.\//, '');
            const hashIndex = cleanUrl.indexOf('#');
            if (hashIndex !== -1) {
              cleanUrl = cleanUrl.substring(0, hashIndex);  // Remove fragment for now
            }
            
            // Try to follow the HTML redirect
            if (cleanUrl && cleanUrl !== entry.path) {
              return await this.getArticle(filename, cleanUrl);
            }
          }
        }

        return {
          title: entry.title,
          content: content,
          mimeType: mimeType,
          isBinary: false
        };
      }
    } catch (contentError) {
      console.error('🔍 ZIM Article Debug: Content extraction error:', contentError);
      throw contentError;
    }
        
  } catch (error) {
    console.error('🔍 ZIM Article Debug: Error details:', error);
    throw new Error('Article not found: ' + articleUrl + ' in ' + filename);
  }
};

ZimManager.prototype.getZimList = function() {
  const result = [];
  for (const value of this.zimIndex.values()) {
    result.push(value);
  }
  return result;
};
// Initialize indexer
const mediaIndexer = new MediaIndexer();
const zimManager = new ZimManager();
// Settings
// Settings
let settings = {
  adminPassword: config.adminPassword,
  serverName: config.serverName,
  autoGenerateMedia: true,
  mediaDirectory: config.storagePath,
  defaultStoragePath: config.storagePath,
  theme: 'dark',
  maxFileSize: 100,
  cacheDuration: 24,
  allowDownloads: true,
  allowBulkDownloads: true,
  maxConcurrentDownloads: 3,
  requireAuth: false,
  guestAccess: true,
  sessionTimeout: 60,
  enableCustomCSS: false,
  customCSS: '',
  mediaDirectories: {
    movies: [path.join(config.storagePath, 'Movies')],
    shows: [path.join(config.storagePath, 'Shows')],
    music: [path.join(config.storagePath, 'Music')],
    books: [path.join(config.storagePath, 'Books')],
    games: [path.join(config.storagePath, 'Games')],
    gallery: [path.join(config.storagePath, 'Gallery')]
  }
};

// Create required directories
const ensureMediaDirs = function() {
  const mediaDirectory = settings.mediaDirectory || config.storagePath;
  const requiredDirs = [
    'Movies', 'Shows', 'Music', 'Books', 'Archive', 'Gallery', 'Files', 'config'
  ].map(function(dir) { return path.join(mediaDirectory, dir); });

  requiredDirs.forEach(function(dir) { fs.ensureDirSync(dir); });
};

ensureMediaDirs();

// Middleware
app.use(express.json({ limit: '50mb' }));
app.use(express.urlencoded({ extended: true, limit: '50mb' }));

// CORS headers
app.use(function(req, res, next) {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, HEAD');
  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Range, Authorization');
  if (req.method === 'OPTIONS') return res.sendStatus(200);
  next();
});
// Add this BEFORE the express.static middleware (before line 888)
app.get('/', function(req, res) {
  res.sendFile(path.join(__dirname, 'frontend', 'menu.html'));
});
app.get('/logo.png', function(req, res) {
  res.sendFile(path.join(__dirname, 'frontend', 'Logo.png'));
});

app.get('/Logo.png', function(req, res) {
  res.sendFile(path.join(__dirname, 'frontend', 'Logo.png'));
});
// Serve frontend files with proper MIME types
app.use(express.static(path.join(__dirname, 'frontend'), {
  setHeaders: function(res, filePath) {
    if (filePath.endsWith('.js')) {
      res.setHeader('Content-Type', 'application/javascript');
    } else if (filePath.endsWith('.css')) {
      res.setHeader('Content-Type', 'text/css');
    } else if (filePath.endsWith('.wasm')) {
      res.setHeader('Content-Type', 'application/wasm');
    } else if (filePath.endsWith('.data')) {
      res.setHeader('Content-Type', 'application/octet-stream');
    }
  }
}));
// Serve menu.html as the root page instead of index.html
app.get('/', function(req, res) {
  res.sendFile(path.join(__dirname, 'frontend', 'menu.html'));
});

// Serve frontend files with proper MIME types
app.use(express.static(path.join(__dirname, 'frontend'), {
  setHeaders: function(res, filePath) {
    if (filePath.endsWith('.js')) {
      res.setHeader('Content-Type', 'application/javascript');
    } else if (filePath.endsWith('.css')) {
      res.setHeader('Content-Type', 'text/css');
    } else if (filePath.endsWith('.wasm')) {
      res.setHeader('Content-Type', 'application/wasm');
    } else if (filePath.endsWith('.data')) {
      res.setHeader('Content-Type', 'application/octet-stream');
    }
  }
}));
// File upload configuration
const storage = multer.diskStorage({
  destination: function(req, file, cb) {
    const category = req.body.category || 'Files';
    const mediaDirectory = settings.mediaDirectory || config.storagePath;
    const destPath = path.join(mediaDirectory, category);
    fs.ensureDirSync(destPath);
    cb(null, destPath);
  },
  filename: function(req, file, cb) {
    cb(null, file.originalname);
  }
});

const upload = multer({ 
  storage: storage,
  limits: { fileSize: parseInt(config.maxFileSize) || 10 * 1024 * 1024 * 1024 }
});

// Utility functions
const sanitizePath = function(filePath) {
  return path.normalize(filePath).replace(/^(\.\.[\/\\])+/, '');
};
// ZIM API Routes
app.get('/api/zim/search', async function(req, res) {
  try {
    const query = req.query.q;
    if (!query) {
      return res.json([]);
    }

    const results = await zimManager.searchArticles(query, 20);
    res.json(results);
  } catch (error) {
    console.error('ZIM search error:', error);
    res.status(500).json({ error: 'Search failed' });
  }
});
// Add alias for frontend compatibility
app.get('/zim-list', async function(req, res) {
  try {
    await zimManager.initialize();
    
    const zimFiles = Array.from(zimManager.zimIndex.values());
    
    res.json(zimFiles);
  } catch (error) {
    console.error('ZIM list error:', error);
    res.status(500).json({ error: error.message });
  }
});

// Add alias for frontend compatibility
app.get('/zim-list', async function(req, res) {
  try {
    await zimManager.initialize();
    const zimFiles = Array.from(zimManager.zimIndex.values());
    
    res.json(zimFiles.map(zim => ({
      path: zim.filename,
      title: zim.title,
      description: zim.description,
      articleCount: zim.articleCount
    })));
  } catch (error) {
    console.error('ZIM list error:', error);
    res.status(500).json({ error: error.message });
  }
});

app.get('/api/zim/article', async function(req, res) {

  try {
    const filename = req.query.filename;
    const url = req.query.url;
    
    if (!filename || !url) {
      return res.status(400).json({ error: 'Missing filename or url parameter' });
    }

    const article = await zimManager.getArticle(filename, url);
    
    // Fix MIME type for common file types
    let mimeType = article.mimeType;
    if (url.endsWith('.css') && mimeType === 'text/html') {
      mimeType = 'text/css';
    } else if (url.endsWith('.js') && mimeType === 'text/html') {
      mimeType = 'application/javascript';
    } else if (url.endsWith('.svg') && mimeType === 'text/html') {
      mimeType = 'image/svg+xml';
    }
    
    // Set appropriate headers
    res.set('Content-Type', mimeType);
    
    if (article.isBinary) {
      // For binary content (images, etc.), send as buffer
      res.set('Cache-Control', 'public, max-age=31536000');
      res.send(article.content);
    } else {
      // For text content (HTML, CSS, etc.), send as string
      res.send(article.content);
    }
    
  } catch (error) {
    console.error('ZIM article error:', error);
    res.status(404).json({ error: error.message });
  }
});
// Debug route to explore ZIM entries
app.get('/api/zim/debug/:filename', async function(req, res) {
  try {
    const filename = req.params.filename;
    const search = req.query.search || '';
    const limit = parseInt(req.query.limit) || 50;
    const startFrom = parseInt(req.query.start) || 0;
    
    await zimManager.initialize();
    const zimFile = zimManager.zimFiles.get(filename);
    
    if (!zimFile) {
      throw new Error('ZIM file not found: ' + filename);
    }
    
    const entries = [];
    let count = 0;
    
    // Get entry count
    const entryCount = zimFile.entryCount;
    
    // Use direct index access to see ALL entries including images
    for (let i = startFrom; i < entryCount && count < limit; i++) {
      try {
        const entry = zimFile.getEntryByIndex(i);
        if (entry && entry.path) {
          if (!search || entry.path.toLowerCase().includes(search.toLowerCase())) {
            entries.push({
              index: i,
              path: entry.path,
              title: entry.title,
              namespace: entry.path.charAt(0),
              isRedirect: entry.isRedirect || false
            });
            count++;
          }
        }
      } catch (e) {
        // Skip invalid entries
      }
    }
    
    res.json({
      filename: filename,
      totalEntries: entryCount,
      searchTerm: search,
      startFrom: startFrom,
      results: entries,
      found: count,
      hasMore: startFrom + limit < entryCount
    });
    
  } catch (error) {
    console.error('ZIM debug error:', error);
    res.status(500).json({ error: error.message });
  }
});
// Handle MediaWiki asset requests (/_mw_/*)
app.get('/_mw_/*', async function(req, res) {
  try {
    // Extract the asset path
    const assetPath = req.path.substring(5); // Remove /_mw_/ prefix
    
    // Try to get from the current ZIM file context
    const referer = req.get('Referer');
    if (referer) {
      const refererUrl = new URL(referer);
      const zimFile = refererUrl.searchParams.get('zim');
      
      if (zimFile) {
        
        // Try multiple possible paths for the asset
        const possiblePaths = [
          assetPath,
          `I/${assetPath}`,
          `A/${assetPath}`,
          `-/${assetPath}`,
          `_mw_/${assetPath}`
        ];
        
        for (const path of possiblePaths) {
          try {
            const article = await zimManager.getArticle(zimFile, path);
            
            res.set('Content-Type', article.mimeType);
            
            if (article.isBinary) {
              res.set('Cache-Control', 'public, max-age=31536000');
              res.send(article.content);
            } else {
              res.send(article.content);
            }
            return;
          } catch (e) {
            // Continue to next path
          }
        }
      }
    }
    
    // If it's a common missing asset, provide a placeholder
    if (assetPath.includes('Lock-') && assetPath.endsWith('.svg')) {
      res.set('Content-Type', 'image/svg+xml');
      res.set('Cache-Control', 'public, max-age=3600');
      
      // Simple lock icon placeholder
      const lockColor = assetPath.includes('green') ? '#00aa00' : 
                       assetPath.includes('red') ? '#aa0000' : '#888888';
      
      const svgContent = `<?xml version="1.0"?>
<svg xmlns="http://www.w3.org/2000/svg" width="12" height="16" viewBox="0 0 12 16">
  <path fill="${lockColor}" d="M3 5V4c0-1.7 1.3-3 3-3s3 1.3 3 3v1h1c.6 0 1 .4 1 1v6c0 .6-.4 1-1 1H2c-.6 0-1-.4-1-1V6c0-.6.4-1 1-1h1zm2-1v1h2V4c0-.6-.4-1-1-1s-1 .4-1 1z"/>
</svg>`;
      res.send(svgContent);
      return;
    }
    
    // Asset not found - return 404 with proper content type
    res.status(404).send('Asset not found');
    
  } catch (error) {
    console.error('MediaWiki asset error:', error);
    res.status(404).send('Asset not found');
  }
});
// Serve archive.html for ZIM articles
app.get('/archive.html', function(req, res) {
  res.sendFile(path.join(__dirname, 'frontend', 'archive.html'));
});
// Routes - Serve HTML pages
const routes = ['', 'menu', 'admin', 'filebrowser', 'movies', 'shows', 'music', 'books', 'games', 'gallery', 'maps', 'playlist', 'files', 'whiteboard'];
routes.forEach(function(route) {
  app.get(route === '' ? '/' : '/' + route, function(req, res) {
    if (route === 'admin') {
      // Redirect admin to settings
      return res.redirect('/settings');
    }
    const htmlFile = route === '' ? 'menu.html' : route + '.html';
    res.sendFile(path.join(__dirname, 'frontend', htmlFile));
  });
});
// Add comic reader route
app.get('/comic-reader', function(req, res) {
  res.sendFile(path.join(__dirname, 'frontend', 'comic-reader.html'));
});
// Settings page
app.get('/settings', function(req, res) {
  res.sendFile(path.join(__dirname, 'frontend', 'settings.html'));
});

// Direct image serving for media categories
const mediaCategories = ['Movies', 'Shows', 'Music', 'Books', 'Archive', 'Gallery', 'Files', 'Games'];
mediaCategories.forEach(function(category) {
    app.get('/' + category + '/*', async function(req, res) {
    const requestedPath = req.params[0];
    
    // Skip EmulatorJS paths for Games category - let static middleware handle them
    if (category === 'Games' && requestedPath.startsWith('EmulatorJS/')) {
      return res.status(404).send('Not found');
    }
    
    if (!requestedPath) return res.status(400).send('File path required');
    
    const mediaDirectory = settings.mediaDirectory || config.storagePath;
    const fullPath = path.join(mediaDirectory, category, sanitizePath(requestedPath));
    
    if (!await fs.pathExists(fullPath)) {
      return res.status(404).send('File not found: ' + requestedPath);
    }
    
    const stat = await fs.stat(fullPath);
    const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
    const fileName = path.basename(fullPath);
    
    // Check if this is a download request (has download parameter or specific user agent patterns)
    const isDownload = req.query.download !== undefined || 
                      req.headers['sec-fetch-dest'] === 'document' ||
                      req.headers.accept?.includes('text/html');
    
    if (isDownload) {
      // Handle as download - force download with attachment header
      res.set({
        'Content-Type': mimeType,
        'Content-Length': stat.size,
        'Content-Disposition': `attachment; filename="${fileName}"`
      });
      
      return fs.createReadStream(fullPath).pipe(res);
    }
    
    // Set cache headers for images
    if (mimeType.startsWith('image/')) {
      res.set({
        'Content-Type': mimeType,
        'Content-Length': stat.size,
        'Cache-Control': 'public, max-age=31536000',
        'ETag': '"' + stat.mtime.getTime() + '-' + stat.size + '"'
      });
      
      return fs.createReadStream(fullPath).pipe(res);
    }
    
    // For non-images, use regular media streaming with range support
    const total = stat.size;
    
    // Handle range requests for streaming
    if (req.headers.range) {
      const range = req.headers.range;
      const parts = range.replace(/bytes=/, "").split("-");
      const partialstart = parts[0];
      const partialend = parts[1];
      
      const start = parseInt(partialstart, 10);
      const end = partialend ? parseInt(partialend, 10) : total - 1;
      const chunksize = (end - start) + 1;
      
      const file = fs.createReadStream(fullPath, { start: start, end: end });
      
      res.writeHead(206, {
        'Content-Range': 'bytes ' + start + '-' + end + '/' + total,
        'Accept-Ranges': 'bytes',
        'Content-Length': chunksize,
        'Content-Type': mimeType
      });
      
      file.pipe(res);
    } else {
      res.writeHead(200, {
        'Content-Length': total,
        'Content-Type': mimeType,
        'Accept-Ranges': 'bytes'
      });
      
      fs.createReadStream(fullPath).pipe(res);
    }
  });
});
// System index endpoints for search functionality
const searchCategories = ['Movies', 'Shows', 'Music', 'Books', 'Gallery', 'Files'];
searchCategories.forEach(function(category) {
  app.get('/.system-index/' + category + '.index.ndjson', async function(req, res) {
    try {
      const mediaDirectory = settings.mediaDirectory || config.storagePath;
      const categoryPath = path.join(mediaDirectory, category);
      
      if (!await fs.pathExists(categoryPath)) {
        return res.status(404).send('Category directory not found');
      }

      const indexData = await mediaIndexer.getIndex(categoryPath);
      
      let ndjson = JSON.stringify(indexData.header) + '\n';
      for (const entry of indexData.entries) {
        ndjson += JSON.stringify(entry) + '\n';
      }
      
      res.set('Content-Type', 'application/x-ndjson');
      res.send(ndjson);
      
    } catch (error) {
      console.error('System index error for ' + category + ':', error);
      res.status(500).send('Error generating index');
    }
  });
});

// Advanced Index API (NDJSON format expected by frontend)
app.get('/api/index', async function(req, res) {
  try {
    const requestedPath = req.query.path || '/';
    const mediaDirectory = settings.mediaDirectory || config.storagePath;
    const fullPath = path.join(mediaDirectory, sanitizePath(requestedPath));
    
    if (mediaIndexer.building.has(path.normalize(fullPath))) {
      return res.status(202).json({ message: 'Index building in progress' });
    }

    const indexData = await mediaIndexer.getIndex(fullPath);
    
    let ndjson = JSON.stringify(indexData.header) + '\n';
    for (const entry of indexData.entries) {
      ndjson += JSON.stringify(entry) + '\n';
    }
    
    res.set('Content-Type', 'application/x-ndjson');
    res.send(ndjson);
    
  } catch (error) {
    if (error.message === 'INDEX_BUILDING') {
      return res.status(202).json({ message: 'Index building in progress' });
    }
    console.error('Index API error:', error);
    res.status(500).json({ error: error.message });
  }
});

// Legacy media.json endpoint
app.get('/media.json', async function(req, res) {
  try {
    const mediaData = await mediaIndexer.generateMediaJson();
    res.json(mediaData);
  } catch (error) {
    console.error('Media JSON error:', error);
    res.status(500).json({ error: error.message });
  }
});

// Media streaming with range request support
app.get('/media', async function(req, res) {
  const filePath = req.query.file;
  if (!filePath) return res.status(400).send('File parameter required');
  
  // Clean the path - remove leading slash if present since we'll join with mediaDirectory
  const cleanPath = filePath.replace(/^\/+/, '');
  const mediaDirectory = settings.mediaDirectory || config.storagePath;
  const fullPath = path.join(mediaDirectory, sanitizePath(cleanPath));
  
  if (!await fs.pathExists(fullPath)) {
    return res.status(404).send('File not found: ' + filePath);
  }
  
  const stat = await fs.stat(fullPath);
  const total = stat.size;
  const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
  
  // Set cache headers for images (covers)
  if (mimeType.startsWith('image/')) {
    res.set({
      'Cache-Control': 'public, max-age=31536000', // 1 year
      'ETag': '"' + stat.mtime.getTime() + '-' + stat.size + '"'
    });
  }
  
  // Handle range requests
  if (req.headers.range) {
    const range = req.headers.range;
    const parts = range.replace(/bytes=/, "").split("-");
    const partialstart = parts[0];
    const partialend = parts[1];
    
    const start = parseInt(partialstart, 10);
    const end = partialend ? parseInt(partialend, 10) : total - 1;
    const chunksize = (end - start) + 1;
    
    const file = fs.createReadStream(fullPath, { start: start, end: end });
    
    res.writeHead(206, {
      'Content-Range': 'bytes ' + start + '-' + end + '/' + total,
      'Accept-Ranges': 'bytes',
      'Content-Length': chunksize,
      'Content-Type': mimeType
    });
    
    file.pipe(res);
  } else {
    res.writeHead(200, {
      'Content-Length': total,
      'Content-Type': mimeType,
      'Accept-Ranges': 'bytes'
    });
    
    fs.createReadStream(fullPath).pipe(res);
  }
});

// File operations
app.post('/upload', upload.array('files'), function(req, res) {
  const fileCount = req.files && req.files.length || 0;
  console.log('✅ Uploaded ' + fileCount + ' files');
  res.json({ success: true, message: 'Files uploaded successfully', count: fileCount });
});

app.post('/delete', async function(req, res) {
  try {
    const mediaDirectory = settings.mediaDirectory || config.storagePath;
    const filePath = path.join(mediaDirectory, sanitizePath(req.body.path));
    await fs.remove(filePath);
    console.log('Deleted: ' + req.body.path);
    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Settings API
app.get('/api/settings', function(req, res) {
  res.json(settings);
});

app.post('/api/settings', async function(req, res) {
  try {
    settings = Object.assign({}, settings, req.body);
    const settingsPath = path.join(config.configPath, 'settings.json');
    await fs.ensureDir(path.dirname(settingsPath));
    await fs.writeJson(settingsPath, settings, { spaces: 2 });
    
    // Ensure new media directories exist
    ensureMediaDirs();
    
    console.log('Settings updated');
    res.json({ success: true, settings: settings });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});
// Comic API endpoints
app.get('/api/comic/info', async function(req, res) {
  try {
    const filePath = req.query.file;
    if (!filePath) return res.status(400).json({ error: 'File parameter required' });
    
    const cleanPath = filePath.replace(/^\/+/, '');
    const mediaDirectory = settings.mediaDirectory || config.storagePath;
    const fullPath = path.join(mediaDirectory, sanitizePath(cleanPath));
    
    if (!await fs.pathExists(fullPath)) {
      return res.status(404).json({ error: 'File not found' });
    }
    
    if (!ComicReader.isComic(fullPath)) {
      return res.status(400).json({ error: 'Not a comic file' });
    }
    


    const info = await ComicReader.getComicInfo(fullPath);
    res.json(info);
    
  } catch (error) {
    console.error('Comic info error:', error);
    res.status(500).json({ error: error.message });
  }
});

app.get('/api/comic/page', async function(req, res) {
  try {
    const filePath = req.query.file;
    const pageIndex = parseInt(req.query.page) || 0;
    
    if (!filePath) return res.status(400).send('File parameter required');
    
    const cleanPath = filePath.replace(/^\/+/, '');
    const mediaDirectory = settings.mediaDirectory || config.storagePath;
    const fullPath = path.join(mediaDirectory, sanitizePath(cleanPath));
    
    if (!await fs.pathExists(fullPath)) {
      return res.status(404).send('File not found');
    }
    
    const pageData = await ComicReader.getComicPage(fullPath, pageIndex);
    
    res.set({
      'Content-Type': pageData.mimeType,
      'Content-Length': pageData.buffer.length,
      'Cache-Control': 'public, max-age=3600',
      'Content-Disposition': `inline; filename="${pageData.fileName}"`
    });
    
    res.send(pageData.buffer);
    
  } catch (error) {
    console.error('Comic page error:', error);
    res.status(500).send('Error loading page: ' + error.message);
  }
});
// Health check
app.get('/health', function(req, res) {
  res.json({ 
    status: 'OK', 
    timestamp: new Date().toISOString(),
    indexes: mediaIndexer.indexes.size,
    watchers: mediaIndexer.watchers.size
  });
});

// Admin status
app.get('/admin-status', function(req, res) {
  res.json({
    uptime: process.uptime(),
    memory: process.memoryUsage(),
    version: '3.5.1-path-fixed',
    platform: process.platform,
    nodeVersion: process.version
  });
});

// Force rebuild index
app.post('/api/rebuild-index', async function(req, res) {
  try {
    const requestedPath = req.body.path || '/';
    const mediaDirectory = settings.mediaDirectory || config.storagePath;
    const fullPath = path.join(mediaDirectory, sanitizePath(requestedPath));
    
    // Clear existing index
    mediaIndexer.indexes.delete(path.normalize(fullPath));
    
    // Rebuild
    const indexData = await mediaIndexer.buildIndex(fullPath);
    res.json({ success: true, count: indexData.entries.length });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Load settings on startup
const loadSettings = async function() {
  try {
    const settingsPath = path.join(config.configPath, 'settings.json');
    if (await fs.pathExists(settingsPath)) {
      const savedSettings = await fs.readJson(settingsPath);
      settings = Object.assign({}, settings, savedSettings);
      console.log('Settings loaded');
    }
  } catch (error) {
    console.log('Using default settings');
  }
};

// Graceful shutdown
process.on('SIGTERM', function() {
  console.log('🛑 Shutting down gracefully...');
  mediaIndexer.cleanup();
  process.exit(0);
});

process.on('SIGINT', function() {
  console.log('🛑 Shutting down gracefully...');
  mediaIndexer.cleanup();
  process.exit(0);
});

// Start server
// Start server
// Start server
const startServer = async function() {
  await loadSettings();
  ensureMediaDirs();
  
  // Initialize ZIM files
  try {
    await zimManager.initialize();
  } catch (error) {
    console.error('ZIM initialization failed:', error);
  }
  
  // Create HTTP server and Socket.io
  const server = createServer(app);
  const io = new Server(server);
  
  // Whiteboard socket handling
  let whiteboardState = null;
  
  // Chat state handling - keep last 100 messages
  let chatHistory = [];
  const MAX_CHAT_HISTORY = 100;

  io.on('connection', (socket) => {
    
    socket.on('join-whiteboard', () => {
      socket.join('whiteboard');
      socket.emit('whiteboard-state', whiteboardState);
    });
    
    socket.on('whiteboard-draw', (data) => {
      socket.to('whiteboard').emit('whiteboard-data', data);
    });
    
    socket.on('whiteboard-save-state', (imageData) => {
      whiteboardState = imageData;
    });
    
    socket.on('whiteboard-clear', () => {
      whiteboardState = null;
      socket.to('whiteboard').emit('whiteboard-clear');
    });
    
    socket.on('whiteboard-load', (imageData) => {
      whiteboardState = imageData;
      socket.to('whiteboard').emit('whiteboard-load', imageData);
    });
    
    // Chat socket handling
    socket.on('join-chat', () => {
      socket.join('chat');
      // Send chat history to new user
      socket.emit('chat-history', chatHistory);
    });
    
    socket.on('chat-message', (data) => {
      const messageData = {
        username: data.username,
        message: data.message,
        timestamp: data.timestamp
      };
      
      // Add to chat history
      chatHistory.push(messageData);
      
      // Keep only last 100 messages
      if (chatHistory.length > MAX_CHAT_HISTORY) {
        chatHistory = chatHistory.slice(-MAX_CHAT_HISTORY);
      }
      
      // Broadcast to all users in chat room (including sender)
      io.to('chat').emit('chat-message', messageData);
    });
    
    socket.on('disconnect', () => {
    });
  });
  app.get('/', function(req, res) {
    res.sendFile(path.join(__dirname, 'frontend', 'menu.html'));
  });
  app.get('/whiteboard', function(req, res) {
    res.sendFile(path.join(__dirname, 'frontend', 'Whiteboard.html'));
  });  
  app.get('/chat', function(req, res) {
    res.sendFile(path.join(__dirname, 'frontend', 'chat.html'));
  });
  
  server.listen(PORT, '0.0.0.0', function() {
  console.log('\n' + 
    '╔═══════════════════════════════════════════════════════════════╗\n' +
    '║                                                               ║\n' +
    '║        ███╗   ██╗ ██████╗ ███╗   ███╗ █████╗ ██████╗          ║\n' +
    '║        ████╗  ██║██╔═══██╗████╗ ████║██╔══██╗██╔══██╗         ║\n' +
    '║        ██╔██╗ ██║██║   ██║██╔████╔██║███████║██║  ██║         ║\n' +
    '║        ██║╚██╗██║██║   ██║██║╚██╔╝██║██╔══██║██║  ██║         ║\n' +
    '║        ██║ ╚████║╚██████╔╝██║ ╚═╝ ██║██║  ██║██████╔╝         ║\n' +
    '║        ╚═╝  ╚═══╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═════╝          ║\n' +
    '║                                                               ║\n' +
    '║                         Beta Ver. 1.0                         ║\n' +
    '║                 Developed By Jackson Studner                  ║\n' +
    '║                                                               ║\n' +
    '╚═══════════════════════════════════════════════════════════════╝\n');
  
  console.log('Server Status:');
  console.log('   Running on: http://localhost:' + PORT);
  console.log('   Media Directory: ' + (settings.mediaDirectory || config.storagePath));
  console.log('\nReady to serve media content!\n');
});
};

startServer();