server.js

import express from 'express';
import cors from 'cors';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import WebSocket from 'ws';
import multer from 'multer';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const app = express();
const PORT = 3001;
const WS_PORT = 24; // WebSocket port from config.ini

// Middleware
app.use(cors());
app.use(express.json());

// WebSocket connection to machine
let ws = null;
let wsConnected = false;

const connectWebSocket = () => {
  ws = new WebSocket(`ws://localhost:${WS_PORT}`);

  ws.on('open', () => {
    wsConnected = true;
    console.log(`Connected to machine at ws://localhost:${WS_PORT}`);
  });

  ws.on('message', (data) => {
    console.log('Machine response:', data.toString());
  });

  ws.on('error', (error) => {
    console.error('Machine connection error:', error.message);
    wsConnected = false;
  });

  ws.on('close', () => {
    console.log('Machine disconnected. Reconnecting in 5s...');
    wsConnected = false;
    setTimeout(connectWebSocket, 5000);
  });
};

// Initialize WebSocket connection
connectWebSocket();

// Ensure config directory exists
const configDir = path.join(__dirname, 'config');
if (!fs.existsSync(configDir)) {
  fs.mkdirSync(configDir, { recursive: true });
}

// Ensure gcode directory exists
const gcodeDir = path.join(__dirname, 'gcode');
if (!fs.existsSync(gcodeDir)) {
  fs.mkdirSync(gcodeDir, { recursive: true });
}

// Configure multer for file uploads
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, gcodeDir);
  },
  filename: (req, file, cb) => {
    // Keep original filename
    cb(null, file.originalname);
  }
});

const upload = multer({ 
  storage: storage,
  fileFilter: (req, file, cb) => {
    // Accept .gcode, .nc, .txt, .g, .gc files
    const ext = path.extname(file.originalname).toLowerCase();
    if (ext === '.gcode' || ext === '.nc' || ext === '.txt' || ext === '.g' || ext === '.gc') {
      cb(null, true);
    } else {
      cb(new Error('Only .gcode, .nc, .g, .gc, or .txt files are allowed'));
    }
  }
});

// POST endpoint to save config.ini
app.post('/api/config/save', (req, res) => {
  try {
    const { content, filename } = req.body;

    if (!content || !filename) {
      return res.status(400).json({ error: 'Missing content or filename' });
    }

    const filePath = path.join(configDir, filename);
    
    // Write the config file
    fs.writeFileSync(filePath, content, 'utf8');
    
    console.log(`Config saved successfully to: ${filePath}`);
    res.json({ 
      success: true, 
      message: 'Config saved successfully',
      path: filePath 
    });
  } catch (error) {
    console.error('Error saving config:', error);
    res.status(500).json({ 
      error: 'Failed to save config', 
      details: error.message 
    });
  }
});

// GET endpoint to read config.ini
app.get('/api/config/load', (req, res) => {
  try {
    const filePath = path.join(configDir, 'config.ini');
    
    if (!fs.existsSync(filePath)) {
      return res.status(404).json({ error: 'Config file not found' });
    }

    const content = fs.readFileSync(filePath, 'utf8');
    res.json({ success: true, content });
  } catch (error) {
    console.error('Error loading config:', error);
    res.status(500).json({ 
      error: 'Failed to load config', 
      details: error.message 
    });
  }
});

// POST endpoint to upload G-code file
app.post('/api/gcode/upload', upload.single('file'), (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ error: 'No file uploaded' });
    }

    console.log(`G-code file uploaded: ${req.file.filename} (${req.file.size} bytes)`);
    
    res.json({ 
      success: true, 
      message: 'File uploaded successfully',
      fileName: req.file.filename,
      fileSize: `${(req.file.size / 1024).toFixed(1)}kb`
    });
  } catch (error) {
    console.error('Error uploading file:', error);
    res.status(500).json({ 
      error: 'Failed to upload file', 
      details: error.message 
    });
  }
});

// GET endpoint to list all G-code files
app.get('/api/gcode/files', (req, res) => {
  try {
    const files = fs.readdirSync(gcodeDir).map(filename => {
      const filePath = path.join(gcodeDir, filename);
      const stats = fs.statSync(filePath);
      return {
        name: filename,
        size: `${(stats.size / 1024).toFixed(1)}kb`,
        modified: stats.mtime
      };
    });
    
    res.json({ success: true, files });
  } catch (error) {
    console.error('Error listing files:', error);
    res.status(500).json({ 
      error: 'Failed to list files', 
      details: error.message 
    });
  }
});

// GET endpoint to load a specific G-code file
app.get('/api/gcode/load/:filename', (req, res) => {
  try {
    const filename = req.params.filename;
    const filePath = path.join(gcodeDir, filename);
    
    if (!fs.existsSync(filePath)) {
      return res.status(404).json({ error: 'File not found' });
    }

    const fileContent = fs.readFileSync(filePath, 'utf8');
    const lines = fileContent.split('\n').filter(line => line.trim());
    const stats = fs.statSync(filePath);
    
    res.json({ 
      success: true,
      fileName: filename,
      fileSize: `${(stats.size / 1024).toFixed(1)}kb`,
      totalLines: lines.length,
      gCodeLines: lines
    });
  } catch (error) {
    console.error('Error loading file:', error);
    res.status(500).json({ 
      error: 'Failed to load file', 
      details: error.message 
    });
  }
});

// GET endpoint to download a G-code file
app.get('/api/gcode/download/:filename', (req, res) => {
  try {
    const filename = req.params.filename;
    const filePath = path.join(gcodeDir, filename);
    
    if (!fs.existsSync(filePath)) {
      return res.status(404).json({ error: 'File not found' });
    }

    res.download(filePath, filename);
  } catch (error) {
    console.error('Error downloading file:', error);
    res.status(500).json({ 
      error: 'Failed to download file', 
      details: error.message 
    });
  }
});

// DELETE endpoint to delete a G-code file
app.delete('/api/gcode/delete/:filename', (req, res) => {
  try {
    const filename = req.params.filename;
    const filePath = path.join(gcodeDir, filename);
    
    if (!fs.existsSync(filePath)) {
      return res.status(404).json({ error: 'File not found' });
    }

    fs.unlinkSync(filePath);
    console.log(`G-code file deleted: ${filename}`);
    
    res.json({ 
      success: true, 
      message: 'File deleted successfully' 
    });
  } catch (error) {
    console.error('Error deleting file:', error);
    res.status(500).json({ 
      error: 'Failed to delete file', 
      details: error.message 
    });
  }
});

// POST endpoint to send G-code commands
app.post('/api/gcode/send', (req, res) => {
  try {
    const { command } = req.body;

    if (!command) {
      return res.status(400).json({ error: 'Missing command' });
    }

    console.log(`G-code: ${command}`);
    
    // Send command via WebSocket
    if (wsConnected && ws.readyState === WebSocket.OPEN) {
      ws.send(command);
      console.log(`Sent to machine: ${command}`);
      res.json({ 
        success: true, 
        message: 'Command sent',
        command: command
      });
    } else {
      console.warn('Machine not connected. Command logged only.');
      res.json({ 
        success: false, 
        message: 'Machine not connected',
        command: command
      });
    }
  } catch (error) {
    console.error('Error sending G-code:', error);
    res.status(500).json({ 
      error: 'Failed to send command', 
      details: error.message 
    });
  }
});

app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
  console.log(`Config directory: ${configDir}`);
  console.log(`G-code directory: ${gcodeDir}`);
});