server.js

require('dotenv').config();
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const cors = require('cors');
const { getHeaders } = require('./auth');
const cadMemory = require('./memory');
const OnshapeChangeDetector = require('./changeDetection');

console.log('🔄 Starting server...');
console.log('📁 Current directory:', process.cwd());
console.log('📝 Environment variables loaded:', !!process.env.ONSHAPE_ACCESS_KEY);

const app = express();
const server = http.createServer(app);
const io = socketIo(server, {
    cors: {
        origin: "*",
        methods: ["GET", "POST"]
    }
});

console.log('✅ Express and Socket.io initialized');

// Middleware
app.use(express.json()); // Parse JSON bodies for webhooks
console.log('✅ Middleware configured');

// Function to call Ollama LLM
async function getLLMResponse(messages) {
    try {
        console.log('🤖 Calling Ollama...');
        const response = await fetch('http://localhost:11434/api/chat', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                model: 'llama3.2',
                messages: messages,
                stream: false
            })
        });
        
        if (!response.ok) {
            throw new Error(`Ollama API error: ${response.status}`);
        }
        
        const data = await response.json();
        console.log('✅ Ollama response received');
        return data.message.content;
    } catch (error) {
        console.error('❌ Ollama error:', error);
        throw error;
    }
}

// Middleware
app.use(cors());
app.use(express.json());
app.use(express.static('public'));

console.log('✅ Middleware configured');

// Onshape configuration from your .env
const ONSHAPE_CONFIG = {
    accessKey: process.env.ONSHAPE_ACCESS_KEY,
    secretKey: process.env.ONSHAPE_SECRET_KEY,
    docId: process.env.ONSHAPE_DOC_ID,
    elemId: process.env.ONSHAPE_ELEM_ID,
    workspaceId: process.env.ONSHAPE_WORKSPACE_ID,
    baseUrl: 'https://cad.onshape.com'
};

console.log('✅ Onshape config loaded');

// Simple request tracking for debugging
const requestTracker = {
    logRequest(type) {
        console.log(`📡 API Request: ${type} at ${new Date().toISOString()}`);
    }
};

// Function to get complete feature specification (needed for parameter modification)
async function getFeatureSpecs(featureId) {
    const path = `/api/v10/partstudios/d/${ONSHAPE_CONFIG.docId}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/features`;
    const fullUrl = `${ONSHAPE_CONFIG.baseUrl}${path}`;
    
    try {
        console.log(`📋 Getting all features to find ${featureId}...`);
        const headers = getHeaders('GET', fullUrl, ONSHAPE_CONFIG.accessKey, ONSHAPE_CONFIG.secretKey);
        const response = await fetch(fullUrl, { method: 'GET', headers });
        
        if (!response.ok) {
            throw new Error(`Onshape API error: ${response.status}`);
        }
        
        const data = await response.json();
        const feature = data.features.find(f => f.featureId === featureId);
        
        if (!feature) {
            throw new Error(`Feature ${featureId} not found`);
        }
        
        console.log(`✅ Feature specs retrieved for ${featureId}`);
        return feature;
    } catch (error) {
        console.error(`❌ Error getting feature specs for ${featureId}:`, error);
        throw error;
    }
}

// Function to fetch current features using user credentials
async function fetchOnshapeFeatures(userCredentials, selectedDocument) {
    // Use user credentials and document info instead of server config
    const credentials = userCredentials || ONSHAPE_CONFIG;
    const docInfo = selectedDocument || ONSHAPE_CONFIG;
    
    const path = `/api/v6/partstudios/d/${docInfo.docId || docInfo.id}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/features`;
    const fullUrl = `${ONSHAPE_CONFIG.baseUrl}${path}`;
    
    try {
        requestTracker.logRequest('Features');
        const headers = getHeaders('GET', fullUrl, credentials.accessKey, credentials.secretKey);
        const response = await fetch(fullUrl, { method: 'GET', headers });
        
        if (response.status === 429) {
            console.warn('⚠️ Rate limited - try again later');
            throw new Error('Rate limited - please try again in a moment');
        }
        
        if (response.status === 401) {
            console.error('❌ Authentication error (401) - check API credentials');
            throw new Error('Authentication failed - check API credentials');
        }
        
        if (!response.ok) {
            throw new Error(`Onshape API error: ${response.status}`);
        }
        
        const data = await response.json();
        console.log('✅ Onshape features fetched');
        return data.features;
    } catch (error) {
        console.error('❌ Error fetching Onshape features:', error);
        throw error; // Let caller handle the error
    }
}

// Removed fetchSingleFeature - we use the existing features list instead

// Function to force a complete rebuild by creating a temporary commit
async function forceCompleteRebuild() {
    try {
        console.log('🔄 Attempting complete rebuild...');
        
        // Try getting the current microversion first
        const featuresPath = `/api/v6/partstudios/d/${ONSHAPE_CONFIG.docId}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/features`;
        const featuresUrl = `${ONSHAPE_CONFIG.baseUrl}${featuresPath}`;
        const headers = getHeaders('GET', featuresUrl, ONSHAPE_CONFIG.accessKey, ONSHAPE_CONFIG.secretKey);
        
        console.log('📡 Getting current microversion...');
        const response = await fetch(featuresUrl, { method: 'GET', headers });
        
        if (response.ok) {
            const data = await response.json();
            console.log('Current microversion:', data.sourceMicroversion);
            
            // Try to force evaluation with different endpoints
            const evalEndpoints = [
                `/api/v6/partstudios/d/${ONSHAPE_CONFIG.docId}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/massproperties`,
                `/api/v6/partstudios/d/${ONSHAPE_CONFIG.docId}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/boundingboxes`,
                `/api/v6/partstudios/d/${ONSHAPE_CONFIG.docId}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/tessellatedfaces`,
            ];
            
            for (const evalPath of evalEndpoints) {
                try {
                    const evalUrl = `${ONSHAPE_CONFIG.baseUrl}${evalPath}`;
                    const evalHeaders = getHeaders('GET', evalUrl, ONSHAPE_CONFIG.accessKey, ONSHAPE_CONFIG.secretKey);
                    
                    console.log('🔄 Force rebuild via:', evalPath);
                    const evalResponse = await fetch(evalUrl, { method: 'GET', headers: evalHeaders });
                    
                    if (evalResponse.ok) {
                        console.log('✅ Rebuild successful via', evalPath);
                        
                        // Check if microversion changed
                        const newFeaturesResponse = await fetch(featuresUrl, { method: 'GET', headers });
                        if (newFeaturesResponse.ok) {
                            const newData = await newFeaturesResponse.json();
                            console.log('New microversion:', newData.sourceMicroversion);
                            if (newData.sourceMicroversion !== data.sourceMicroversion) {
                                console.log('🎉 Microversion changed! Geometry should update.');
                                return;
                            }
                        }
                    }
                } catch (error) {
                    console.log('❌ Rebuild attempt failed:', error.message);
                }
            }
        }
        
        console.log('⚠️ All rebuild attempts completed, but geometry may not have updated');
        
    } catch (error) {
        console.error('❌ Error in complete rebuild:', error.message);
    }
}

// Function to update sketch constraints using a simplified approach
async function updateSketchConstraint(featureId, constraintId, newValue) {
    // Try using the simpler constraint update approach
    const path = `/api/v6/partstudios/d/${ONSHAPE_CONFIG.docId}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/features/featureid/${featureId}`;
    const fullUrl = `${ONSHAPE_CONFIG.baseUrl}${path}`;
    
    try {
        console.log(`🔄 Updating constraint ${constraintId} to ${newValue}...`);
        
        // First get the current feature
        const headers = getHeaders('GET', fullUrl, ONSHAPE_CONFIG.accessKey, ONSHAPE_CONFIG.secretKey);
        const getResponse = await fetch(fullUrl, { method: 'GET', headers });
        
        if (!getResponse.ok) {
            throw new Error(`Failed to get feature: ${getResponse.status}`);
        }
        
        const featureData = await getResponse.json();
        console.log('Current feature retrieved');
        
        // Find and update the constraint
        if (featureData.feature && featureData.feature.constraints) {
            for (let constraint of featureData.feature.constraints) {
                if (constraint.constraintType === 'LENGTH') {
                    const lengthParam = constraint.parameters?.find(p => p.parameterId === 'length');
                    if (lengthParam) {
                        console.log(`Found length parameter: ${lengthParam.expression} → ${newValue}`);
                        lengthParam.expression = newValue;
                    }
                }
            }
        }
        
        // Update the feature with PUT
        const putHeaders = getHeaders('PUT', fullUrl, ONSHAPE_CONFIG.accessKey, ONSHAPE_CONFIG.secretKey);
        const putResponse = await fetch(fullUrl, {
            method: 'PUT',
            headers: putHeaders,
            body: JSON.stringify(featureData)
        });
        
        if (!putResponse.ok) {
            const errorText = await putResponse.text();
            console.error('PUT Error:', errorText);
            throw new Error(`Failed to update feature: ${putResponse.status}`);
        }
        
        const result = await putResponse.json();
        console.log('✅ Sketch constraint updated successfully');
        return result;
        
    } catch (error) {
        console.error('❌ Error updating sketch constraint:', error);
        throw error;
    }
}

// FeatureScript approach to modify sketch constraints with proper solving
async function updateViaFeatureScript(featureId, parameterId, newValue, oldValue) {
    const path = `/api/v6/partstudios/d/${ONSHAPE_CONFIG.docId}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/featurescript`;
    const fullUrl = `${ONSHAPE_CONFIG.baseUrl}${path}`;
    
    try {
        console.log(`🎯 FeatureScript: Modifying ${parameterId} from ${oldValue} to ${newValue}...`);
        
        const headers = getHeaders('POST', fullUrl, ONSHAPE_CONFIG.accessKey, ONSHAPE_CONFIG.secretKey);
        
        // FeatureScript to modify constraint and trigger solver
        const featureScriptCode = `
FeatureScript 2024;
import(path : "onshape/std/common.fs", version : "2024.1.0");
import(path : "onshape/std/sketch.fs", version : "2024.1.0");

export function myFeature(context is Context, id is Id, definition is map)
{
    try {
        debug(context, "🎯 Starting FeatureScript constraint modification");
        debug(context, "Looking for sketch: ${featureId}");
        debug(context, "Target: ${parameterId} = ${newValue}");
        
        // Find all features and look for our sketch
        var allFeatures = qAllNonMeshSolidBodies(context);
        debug(context, "Found " ~ size(evaluateQuery(context, allFeatures)) ~ " total features");
        
        // Try to find the sketch by feature ID
        var sketchQuery = qFeatureId("${featureId}");
        var sketchFeatures = evaluateQuery(context, sketchQuery);
        
        if (size(sketchFeatures) > 0)
        {
            debug(context, "✅ Found sketch feature");
            
            // Force a regeneration to ensure constraints are solved
            debug(context, "🔄 Forcing regeneration to solve constraints");
            
            // The key insight: we need to modify the feature definition
            // and then let Onshape's constraint solver do its work
            
            debug(context, "✅ FeatureScript constraint modification completed");
        } else {
            debug(context, "❌ Sketch feature not found with ID: ${featureId}");
            
            // List all feature IDs for debugging
            var allFeaturesQuery = qAllNonMeshSolidBodies(context);
            debug(context, "Available features in context:");
            // This will help us understand what's available
        }
    } catch (error) {
        debug(context, "❌ FeatureScript error: " ~ toString(error));
    }
}`;
        
        const requestBody = {
            "script": featureScriptCode
        };
        
        console.log('🚀 Executing FeatureScript...');
        const response = await fetch(fullUrl, { 
            method: 'POST', 
            headers,
            body: JSON.stringify(requestBody)
        });
        
        if (!response.ok) {
            const errorText = await response.text();
            console.log(`❌ FeatureScript failed: ${response.status}`);
            console.log('Error details:', errorText);
            return null;
        }
        
        const data = await response.json();
        console.log(`⚠️ FeatureScript executed but didn't modify parameters`);
        
        // Look for debug output
        if (data.result && data.result.message) {
            console.log('FeatureScript debug output:', data.result.message);
        }
        
        // Return null to force fallback to REST API approach since FeatureScript isn't actually modifying parameters
        return null;
        
    } catch (error) {
        console.error(`❌ FeatureScript error:`, error.message);
        return null;
    }
}

// Update Feature using the correct approach from research  
async function updateFeature(featureId, completeFeatureSpecs) {
    const path = `/api/v6/partstudios/d/${ONSHAPE_CONFIG.docId}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/features/featureid/${featureId}`;
    const fullUrl = `${ONSHAPE_CONFIG.baseUrl}${path}`;
    
    try {
        console.log(`🔄 Updating feature ${featureId} with complete feature definition...`);
        
        const headers = getHeaders('POST', fullUrl, ONSHAPE_CONFIG.accessKey, ONSHAPE_CONFIG.secretKey);
        
        // Wrap in BTFeatureDefinitionCall structure
        const featureCall = {
            btType: "BTFeatureDefinitionCall-1406",
            feature: completeFeatureSpecs
        };
        
        console.log('🔍 Feature call being sent:', JSON.stringify(featureCall, null, 2));
        
        const response = await fetch(fullUrl, { 
            method: 'POST', 
            headers,
            body: JSON.stringify(featureCall)
        });
        
        if (!response.ok) {
            const errorText = await response.text();
            console.error('API Error Response:', errorText);
            throw new Error(`Onshape API error: ${response.status} - ${errorText}`);
        }
        
        const data = await response.json();
        console.log(`✅ Feature ${featureId} updated successfully`);
        return data;
    } catch (error) {
        console.error(`❌ Error updating feature ${featureId}:`, error);
        throw error;
    }
}

// Function to modify parameter in feature using the CORRECT approach from research
async function modifyFeatureParameter(featureId, parameterId, newValue) {
    try {
        console.log(`📝 Getting complete feature specs for ${featureId}...`);
        
        // Step 1: Get the complete feature specification (the research shows this is key!)
        const featureSpecs = await getFeatureSpecs(featureId);
        console.log(`🔍 Feature structure:`, JSON.stringify(featureSpecs, null, 2));
        
        // Step 2: Look for parameters in feature (the correct location per research!)
        if (!featureSpecs.parameters) {
            throw new Error(`Feature ${featureId} doesn't have parameters`);
        }
        
        const message = featureSpecs;
        console.log(`🔍 Feature message parameters:`, message.parameters ? message.parameters.map(p => p.parameterId) : 'No parameters found');
        
        // Step 3: Find and modify the parameter in feature.message
        let foundParam = false;
        let oldValue = 'unknown';
        let normalizedValue = newValue;
        
        // Normalize the parameter format to match Onshape expectations
        if (newValue.includes('mm') && !newValue.includes(' ')) {
            normalizedValue = newValue.replace('mm', ' mm');
        }
        
        // Look for parameters in message.parameters (this is where they actually are!)
        if (message.parameters) {
            const param = message.parameters.find(p => p.parameterId === parameterId);
            if (param) {
                oldValue = param.expression || param.value || 'unknown';
                if (param.expression !== undefined) {
                    param.expression = normalizedValue;
                } else if (param.value !== undefined) {
                    param.value = normalizedValue;
                }
                foundParam = true;
                console.log(`✅ Modified ${parameterId} in message.parameters: ${oldValue} → ${normalizedValue}`);
            }
        }
        
        if (!foundParam) {
            console.error('❌ Parameter not found in feature.message. Available parameters:', 
                message.parameters ? message.parameters.map(p => p.parameterId) : 'None');
            console.error('Full message structure:', JSON.stringify(message, null, 2));
            throw new Error(`Parameter ${parameterId} not found in feature ${featureId} message`);
        }
        
        // Step 4: Return the complete feature specs with modification
        return { 
            completeFeature: featureSpecs, 
            normalizedValue,
            oldValue
        };
        
    } catch (error) {
        console.error(`❌ Error modifying feature parameter:`, error);
        throw error;
    }
}

// Helper function to add delay between API calls
function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

// Function to analyze features and extract current parameters
function analyzeFeatures(features) {
    const analysis = features.map(feature => {
        const type = feature.featureType.toLowerCase();
        
        if (type === 'sketch' || type === 'newsketch') {
            const constraints = feature.constraints || [];
            const dimensions = constraints
                .filter(c => c.constraintType === 'LENGTH')
                .map(c => {
                    const lengthParam = c.parameters.find(p => p.parameterId === 'length');
                    return lengthParam ? lengthParam.expression : null;
                })
                .filter(d => d);
                
            return {
                id: feature.featureId,
                type: feature.featureType,
                name: feature.name,
                dimensions: dimensions
            };
        }
        
        if (type === 'extrude') {
            const params = feature.parameters || [];
            const depth = params.find(p => p.parameterId === 'depth');
            
            return {
                id: feature.featureId,
                type: feature.featureType,
                name: feature.name,
                depth: depth ? depth.expression : null
            };
        }
        
        return {
            id: feature.featureId,
            type: feature.featureType,
            name: feature.name
        };
    });
    
    return analysis;
}

// Memory system to track design intent and changes
let designMemory = {
    modifications: [],
    intents: {},
    parameters: {}
};

function recordModification(featureId, parameterId, oldValue, newValue, intent = '') {
    const modification = {
        timestamp: new Date().toISOString(),
        featureId,
        parameterId,
        oldValue,
        newValue,
        intent,
        id: Date.now().toString()
    };
    
    designMemory.modifications.push(modification);
    
    if (intent) {
        designMemory.intents[`${featureId}_${parameterId}`] = intent;
    }
    
    designMemory.parameters[`${featureId}_${parameterId}`] = newValue;
    
    console.log('📝 Recorded modification:', modification);
    return modification;
}

function getDesignHistory() {
    return designMemory;
}

// Helper function to get updated model data after modifications (reduces API calls)
async function getUpdatedModelData(userCredentials, selectedDocument) {
    try {
        console.log('📡 Fetching updated model data after modification...');
        
        // Fetch both in parallel for efficiency
        const [features, geometry] = await Promise.all([
            fetchOnshapeFeatures(userCredentials, selectedDocument),
            getGeometryForPreview(userCredentials, selectedDocument)
        ]);
        
        return {
            features: analyzeFeatures(features),
            geometry: geometry
        };
    } catch (error) {
        console.error('❌ Error fetching updated model data:', error);
        throw error;
    }
}

console.log('✅ Functions and memory system defined');

// Function to get 3D geometry for preview
async function getGeometryForPreview(userCredentials, selectedDocument) {
    // Use user credentials and document info instead of server config
    const credentials = userCredentials || ONSHAPE_CONFIG;
    const docInfo = selectedDocument || ONSHAPE_CONFIG;
    
    const path = `/api/v6/partstudios/d/${docInfo.docId || docInfo.id}/w/${ONSHAPE_CONFIG.workspaceId}/e/${ONSHAPE_CONFIG.elemId}/tessellatedfaces`;
    const fullUrl = `${ONSHAPE_CONFIG.baseUrl}${path}`;
    
    try {
        requestTracker.logRequest('Geometry');
        const headers = getHeaders('GET', fullUrl, credentials.accessKey, credentials.secretKey);
        const response = await fetch(fullUrl + '?angleTolerance=0.1&chordTolerance=0.01', { 
            method: 'GET', 
            headers
        });
        
        if (response.status === 429) {
            console.warn('⚠️ Rate limited - try again later');
            throw new Error('Rate limited - please try again in a moment');
        }
        
        if (response.status === 401) {
            console.error('❌ Authentication error (401) - check API credentials');
            throw new Error('Authentication failed - check API credentials');
        }
        
        if (!response.ok) {
            throw new Error(`Onshape API error: ${response.status}`);
        }
        
        const data = await response.json();
        console.log('✅ Geometry fetched for preview');
        console.log('📊 Geometry data structure:', Object.keys(data));
        if (data.faces && data.faces.length > 0) {
            console.log('📐 Found', data.faces.length, 'faces');
            console.log('📍 First face sample:', data.faces[0] ? Object.keys(data.faces[0]) : 'none');
        }
        return data;
    } catch (error) {
        console.error('❌ Error fetching geometry:', error);
        throw error; // Let caller handle the error
    }
}

// Initialize webhook-based change detector
const changeDetector = new OnshapeChangeDetector(ONSHAPE_CONFIG, app);

// Socket.io connection handling
io.on('connection', async (socket) => {
    console.log('🔌 User connected:', socket.id);
    
    // Set up change detection for this client
    const changeHandler = async (event) => {
        console.log('📡 Document changed - notifying client:', socket.id);
        
        // Only notify about the change - don't automatically fetch data
        socket.emit('onshape_changed', {
            event,
            message: '🔄 Model updated externally in Onshape',
            timestamp: new Date().toISOString()
        });
    };
    
    changeDetector.addListener(changeHandler);
    
    // Start webhook-based change detection if not already running
    if (!changeDetector.isRunning) {
        await changeDetector.start();
    }
    
    // Store user session data
    let userSession = {
        userCredentials: null,
        selectedDocument: null
    };
    
    socket.on('user_connected', (data) => {
        console.log('👤 User session initialized:', {
            email: data.userCredentials.email,
            document: data.selectedDocument.name
        });
        
        userSession.userCredentials = data.userCredentials;
        userSession.selectedDocument = data.selectedDocument;
        
        // TODO: Update ONSHAPE_CONFIG with user's credentials for this session
        // For now, we'll handle this in individual socket events
    });
    
    socket.on('chat_message', async (data) => {
        const { message } = data;
        console.log('💬 Received message:', message);
        
        try {
            // Emit thinking status
            socket.emit('bot_thinking', true);
            
            // Get current Onshape features
            const features = await fetchOnshapeFeatures(userSession.userCredentials, userSession.selectedDocument);
            const analysis = analyzeFeatures(features);
            
            // Get design memory for context - NEW MEMORY SYSTEM
            const documentId = ONSHAPE_CONFIG.docId; // Use current document
            const memoryContext = cadMemory.getMemoryContext(message, documentId);
            console.log('🧠 Memory context:', memoryContext);
            
            // Legacy memory for backward compatibility
            const memory = getDesignHistory();
            
            // First, check if the user message contains a direct MODIFY command
            console.log('🔍 Checking for MODIFY command in user message:', message);
            const userModifyMatch = message.match(/MODIFY:\s*featureId=([^,]+),\s*parameterId=([^,]+),\s*newValue=([^,]+),\s*intent=(.+)/i);
            
            if (userModifyMatch) {
                console.log('🔧 User sent direct MODIFY command');
                const [, featureId, parameterId, newValue, intent] = userModifyMatch;
                
                // Execute modification directly
                socket.emit('modification_progress', 'Processing your modification request...');
                
                try {
                    // Find the feature in the already-fetched features list
                    console.log('📋 Available features:', features.map(f => f.featureId + ' (' + f.featureType + ')'));
                    const currentFeature = features.find(f => f.featureId === featureId);
                    if (!currentFeature) {
                        throw new Error(`Feature ${featureId} not found. Available features: ${features.map(f => f.featureId).join(', ')}`);
                    }
                    
                    console.log(`📋 Found feature ${featureId}:`, currentFeature.featureType);
                    
                    let oldValue = 'unknown';
                    if (currentFeature.parameters) {
                        const param = currentFeature.parameters.find(p => p.parameterId === parameterId);
                        if (param) oldValue = param.expression;
                    }
                    
                    // APPLY CHANGES IMMEDIATELY FOR 3D PREVIEW
                    console.log('🎯 Applying changes to Onshape for 3D preview...');
                    
                    // Normalize the value format if needed
                    if (parameterId === 'depth' || parameterId === 'length' || parameterId === 'width' || parameterId === 'height') {
                        // Ensure proper unit format
                        if (!newValue.includes('mm') && !newValue.includes('in') && !newValue.includes('m')) {
                            newValue = newValue + 'mm'; // Default to mm
                        }
                    }
                    
                    // Store original state for potential revert
                    const originalState = {
                        featureId,
                        parameterId,
                        originalValue: oldValue,
                        timestamp: new Date().toISOString()
                    };
                    
                    let updateResult = null;
                    
                    // Apply the change to Onshape immediately
                    try {
                        const featureScriptResult = await updateViaFeatureScript(featureId, parameterId, newValue, oldValue);
                        
                        if (featureScriptResult) {
                            console.log('✅ FeatureScript execution completed');
                            updateResult = featureScriptResult;
                        } else {
                            console.log('⚠️ FeatureScript failed, using REST API...');
                            const result = await modifyFeatureParameter(featureId, parameterId, newValue);
                            updateResult = await updateFeature(featureId, result.completeFeature);
                            newValue = result.normalizedValue;
                        }
                        
                        console.log('✅ Changes applied to Onshape for preview');
                        
                    } catch (updateError) {
                        console.error('❌ Failed to apply changes:', updateError);
                        throw updateError;
                    }
                    
                    socket.emit('bot_thinking', false);
                    
                    // Fetch current 3D geometry for preview
                    console.log('🔄 Fetching updated geometry after applying changes...');
                    const currentGeometry = await getGeometryForPreview(userSession.userCredentials, userSession.selectedDocument);
                    console.log('📐 Got geometry for preview:', currentGeometry ? 'YES' : 'NO');
                    
                    // Send preview with applied changes
                    socket.emit('modification_preview', {
                        featureId,
                        parameterId,
                        oldValue,
                        newValue,
                        intent: intent.trim(),
                        message: `Applied: Changed ${parameterId} from ${oldValue} to ${newValue}`,
                        currentFeature: currentFeature,
                        currentGeometry: currentGeometry,
                        originalState: originalState,
                        applied: true
                    });
                    
                    return; // Skip normal chat response
                    
                } catch (error) {
                    console.error('❌ Error executing MODIFY command:', error);
                    socket.emit('modification_error', {
                        message: `Failed to execute modification: ${error.message}`,
                        error: error.message
                    });
                    return;
                }
            }

            // Get LLM response using Ollama
            const response = await getLLMResponse([
                { 
                    role: "system", 
                    content: `You are an AI assistant that helps modify CAD models in Onshape with design memory.

Current model features:
${analysis.map(f => `- ${f.name} (${f.type}) - ID: ${f.id}: ${JSON.stringify(f)}`).join('\n')}

Raw feature IDs available:
${features.map(f => `- ${f.featureId} (${f.featureType})`).join('\n')}

DESIGN MEMORY CONTEXT:
${memoryContext.hasContext 
    ? `📚 ${memoryContext.message}:
${memoryContext.context.map(ctx => 
    `- ${ctx.summary} (similarity: ${Math.round(ctx.similarity * 100)}%)
      Previous reasoning: ${ctx.reasoning}
      Keywords matched: [${ctx.matchedKeywords.join(', ')}]`
).join('\n')}`
    : '📝 No previous similar design decisions found - this is new territory!'
}

Legacy memory - Recent modifications:
${memory.modifications.slice(-5).map(m => `- ${m.timestamp}: Changed ${m.parameterId} from ${m.oldValue} to ${m.newValue}${m.intent ? ` (${m.intent})` : ''}`).join('\n') || 'No recent modifications'}

IMPORTANT: When the user asks to modify a parameter (like "make it wider", "change width to 150mm", etc.):

You MUST respond with EXACTLY this format using the ACTUAL featureId from the list above:
MODIFY: featureId=[actual_feature_id], parameterId=[actual_parameter], newValue=[new_value], intent=[reason]

Examples based on current features:
- User: "Make the base width 200mm for stability" → You respond: "MODIFY: featureId=${features.find(f => f.featureType === 'newSketch')?.featureId || 'FxMafT1VqIpbvjL_0'}, parameterId=length, newValue=200mm, intent=improve stability"
- User: "Change extrude depth to 25mm" → You respond: "MODIFY: featureId=${features.find(f => f.featureType === 'extrude')?.featureId || 'FidJ1G54jew8fO4_0'}, parameterId=depth, newValue=25mm, intent=depth adjustment"

CRITICAL: Use the exact featureId from the "Raw feature IDs available" list above - NOT generic names like "sketch1" or "extrude1".

For other questions about the model, respond normally.`
                },
                { 
                    role: "user", 
                    content: message 
                }
            ]);
            
            console.log('🤖 AI Response:', response);
            
            // Check if AI response contains a MODIFY command
            const aiModifyMatch = response.match(/MODIFY:\s*featureId=([^,]+),\s*parameterId=([^,]+),\s*newValue=([^,]+),\s*intent=(.+)/i);
            
            if (aiModifyMatch) {
                console.log('🤖 AI responded with MODIFY command, executing...');
                const [, featureId, parameterId, initialNewValue, intent] = aiModifyMatch;
                let newValue = initialNewValue;
                
                // Send preview instead of executing modification
                socket.emit('modification_progress', 'Preparing preview...');
                
                try {
                    // Find the feature in the already-fetched features list
                    console.log('📋 Available features:', features.map(f => f.featureId + ' (' + f.featureType + ')'));
                    const currentFeature = features.find(f => f.featureId === featureId);
                    if (!currentFeature) {
                        throw new Error(`Feature ${featureId} not found. Available features: ${features.map(f => f.featureId).join(', ')}`);
                    }
                    
                    console.log(`📋 Found feature ${featureId}:`, currentFeature.featureType);
                    
                    let oldValue = 'unknown';
                    if (currentFeature.parameters) {
                        const param = currentFeature.parameters.find(p => p.parameterId === parameterId);
                        if (param) oldValue = param.expression;
                    }
                    
                    // APPLY CHANGES IMMEDIATELY FOR 3D PREVIEW
                    console.log('🎯 Applying changes to Onshape for 3D preview...');
                    
                    // Normalize the value format if needed
                    if (parameterId === 'depth' || parameterId === 'length' || parameterId === 'width' || parameterId === 'height') {
                        // Ensure proper unit format
                        if (!newValue.includes('mm') && !newValue.includes('in') && !newValue.includes('m')) {
                            newValue = newValue + 'mm'; // Default to mm
                        }
                    }
                    
                    // Store original state for potential revert
                    const originalState = {
                        featureId,
                        parameterId,
                        originalValue: oldValue,
                        timestamp: new Date().toISOString()
                    };
                    
                    let updateResult = null;
                    
                    // Apply the change to Onshape immediately
                    try {
                        const featureScriptResult = await updateViaFeatureScript(featureId, parameterId, newValue, oldValue);
                        
                        if (featureScriptResult) {
                            console.log('✅ FeatureScript execution completed');
                            updateResult = featureScriptResult;
                        } else {
                            console.log('⚠️ FeatureScript failed, using REST API...');
                            const result = await modifyFeatureParameter(featureId, parameterId, newValue);
                            updateResult = await updateFeature(featureId, result.completeFeature);
                            newValue = result.normalizedValue;
                        }
                        
                        console.log('✅ Changes applied to Onshape for preview');
                        
                    } catch (updateError) {
                        console.error('❌ Failed to apply changes:', updateError);
                        throw updateError;
                    }
                    
                    socket.emit('bot_thinking', false);
                    
                    // Fetch current 3D geometry for preview
                    console.log('🔄 Fetching updated geometry after applying changes...');
                    const currentGeometry = await getGeometryForPreview(userSession.userCredentials, userSession.selectedDocument);
                    console.log('📐 Got geometry for preview:', currentGeometry ? 'YES' : 'NO');
                    
                    // Send preview with applied changes
                    socket.emit('modification_preview', {
                        featureId,
                        parameterId,
                        oldValue,
                        newValue,
                        intent: intent.trim(),
                        message: `Applied: Changed ${parameterId} from ${oldValue} to ${newValue}`,
                        currentFeature: currentFeature,
                        currentGeometry: currentGeometry,
                        originalState: originalState,
                        applied: true
                    });
                    
                    return; // Skip normal response
                    
                } catch (error) {
                    console.error('❌ Error executing AI MODIFY command:', error);
                    socket.emit('modification_error', {
                        message: `Failed to execute modification: ${error.message}`,
                        error: error.message
                    });
                    return;
                }
            }
            
            // Store this design decision in memory
            const memoryEntry = cadMemory.storeDecision({
                documentId: documentId,
                userId: socket.id, // Use socket ID as user identifier for now
                userIntent: message,
                originalRequest: message,
                aiReasoning: response,
                proposedChanges: {
                    type: 'chat_response',
                    response: response,
                    features: analysis
                },
                memoryContext: memoryContext.context || []
            });
            
            socket.emit('bot_thinking', false);
            socket.emit('bot_response', {
                message: response,
                timestamp: new Date().toISOString(),
                features: analysis,
                memoryEntry: memoryEntry.id, // Include memory ID for potential feedback
                memoryContext: memoryContext.hasContext ? {
                    found: memoryContext.context.length,
                    summary: memoryContext.context.map(ctx => ctx.summary)
                } : null
            });
            
        } catch (error) {
            console.error('❌ Error processing message:', error);
            socket.emit('bot_thinking', false);
            socket.emit('bot_response', {
                message: 'Sorry, I encountered an error processing your request. Please try again.',
                error: true,
                timestamp: new Date().toISOString()
            });
        }
    });
    
    // Combined endpoint - gets both features and geometry in one request (50% fewer API calls)
    socket.on('get_model_data', async () => {
        try {
            console.log('📡 Fetching complete model data (features + geometry)...');
            
            // Fetch both features and geometry in parallel to save time
            const [features, geometry] = await Promise.all([
                fetchOnshapeFeatures(userSession.userCredentials, userSession.selectedDocument),
                getGeometryForPreview(userSession.userCredentials, userSession.selectedDocument)
            ]);
            
            const analysis = analyzeFeatures(features);
            
            socket.emit('model_data_update', {
                features: analysis,
                geometry: geometry,
                timestamp: new Date().toISOString()
            });
            
            console.log('✅ Complete model data sent to client');
        } catch (error) {
            console.error('❌ Error getting model data:', error);
            socket.emit('model_data_error', error.message);
        }
    });

    // Legacy endpoint for backward compatibility
    socket.on('get_current_features', async () => {
        try {
            const features = await fetchOnshapeFeatures(userSession.userCredentials, userSession.selectedDocument);
            const analysis = analyzeFeatures(features);
            socket.emit('current_features', analysis);
        } catch (error) {
            console.error('❌ Error getting features:', error);
            socket.emit('features_error', error.message);
        }
    });

    // Memory feedback system - allows users to rate AI suggestions
    socket.on('memory_feedback', (data) => {
        const { memoryEntryId, outcome, feedback } = data;
        console.log(`🎯 Memory feedback: ${memoryEntryId} -> ${outcome}`);
        
        const updated = cadMemory.updateOutcome(memoryEntryId, outcome, feedback);
        if (updated) {
            socket.emit('memory_feedback_received', {
                success: true,
                entryId: memoryEntryId,
                outcome: outcome
            });
        } else {
            socket.emit('memory_feedback_received', {
                success: false,
                error: 'Memory entry not found'
            });
        }
    });
    
    // Handler for reverting applied changes
    socket.on('revert_modification', async (data) => {
        const { featureId, parameterId, originalValue, newValue } = data;
        
        console.log(`🔄 User wants to revert: ${parameterId} back to ${originalValue}`);
        socket.emit('modification_progress', 'Reverting changes...');
        
        try {
            // Revert to original value
            const featureScriptResult = await updateViaFeatureScript(featureId, parameterId, originalValue, newValue);
            
            if (!featureScriptResult) {
                const result = await modifyFeatureParameter(featureId, parameterId, originalValue);
                await updateFeature(featureId, result.completeFeature);
            }
            
            console.log('✅ Changes reverted successfully');
            
            // Get updated model data (features + geometry in parallel)
            const modelData = await getUpdatedModelData(userSession.userCredentials, userSession.selectedDocument);
            
            socket.emit('modification_success', {
                modification: null,
                features: modelData.features,
                geometry: modelData.geometry,
                message: `Reverted ${parameterId} back to ${originalValue}`
            });
            
        } catch (error) {
            console.error('❌ Error reverting changes:', error);
            socket.emit('modification_error', {
                message: `Failed to revert changes: ${error.message}`,
                error: error.message
            });
        }
    });
    
    // New handler for confirming previewed changes
    socket.on('approve_modification', async (data) => {
        const { featureId, parameterId, oldValue, newValue, intent } = data;
        
        console.log(`✅ User approved modification: ${parameterId} from ${oldValue} to ${newValue}`);
        socket.emit('modification_progress', 'Applying changes to Onshape...');
        
        try {
            // Get complete feature specifications
            const completeFeature = await getFeatureSpecs(featureId);
            
            // Build the parameter update
            const result = buildParameterUpdate(completeFeature, parameterId, newValue);
            if (!result.success) {
                throw new Error(result.error);
            }
            
            // Update in Onshape
            await updateFeature(featureId, result.completeFeature);
            
            socket.emit('modification_progress', 'Recording design intent...');
            
            // Record in memory with user intent
            const modification = recordModification(featureId, parameterId, oldValue, newValue, intent);
            
            // Store in CAD memory
            const memoryEntry = cadMemory.storeDecision(
                userSession.selectedDocument?.id || 'unknown',
                `Changed ${parameterId} from ${oldValue} to ${newValue}`,
                intent || 'User approved modification',
                { featureId, parameterId, oldValue, newValue }
            );
            
            socket.emit('modification_progress', 'Refreshing features...');
            
            // Get updated model data (features + geometry in parallel)
            const modelData = await getUpdatedModelData(userSession.userCredentials, userSession.selectedDocument);
            
            socket.emit('modification_success', {
                modification,
                features: modelData.features,
                geometry: modelData.geometry,
                message: `Successfully updated ${parameterId} from ${oldValue} to ${newValue}${intent ? ` (${intent})` : ''}`
            });
            
        } catch (error) {
            console.error('❌ Error applying approved modification:', error);
            socket.emit('modification_error', {
                message: `Failed to apply modification: ${error.message}`,
                error: error.message
            });
        }
    });
    
    socket.on('modify_parameter', async (data) => {
        const { featureId, parameterId, newValue, intent = '' } = data;
        console.log(`🔧 Modification request: ${featureId}.${parameterId} = ${newValue} (${intent})`);
        
        try {
            socket.emit('modification_progress', 'Fetching current feature...');
            
            // Get current feature
            const currentFeature = await fetchSingleFeature(featureId);
            
            socket.emit('modification_progress', 'Modifying parameter...');
            
            // Get old value for memory
            let oldValue = 'unknown';
            if (currentFeature.parameters) {
                const param = currentFeature.parameters.find(p => p.parameterId === parameterId);
                if (param) oldValue = param.expression;
            }
            
            // Modify parameter using correct approach
            const result = await modifyFeatureParameter(featureId, parameterId, newValue);
            newValue = result.normalizedValue; // Use normalized value for consistency
            
            socket.emit('modification_progress', 'Updating Onshape model...');
            
            // Update in Onshape
            await updateFeature(featureId, result.completeFeature);
            
            socket.emit('modification_progress', 'Recording design intent...');
            
            // Record in memory
            const modification = recordModification(featureId, parameterId, oldValue, newValue, intent);
            
            socket.emit('modification_progress', 'Refreshing features...');
            
            // Get updated model data (features only, no geometry needed for direct modifications)
            const features = await fetchOnshapeFeatures(userSession.userCredentials, userSession.selectedDocument);
            const analysis = analyzeFeatures(features);
            
            socket.emit('bot_thinking', false);
            socket.emit('modification_success', {
                modification,
                features: analysis,
                message: `Successfully updated ${parameterId} from ${oldValue} to ${newValue}${intent ? ` (${intent})` : ''}`
            });
            
        } catch (error) {
            console.error('❌ Error modifying parameter:', error);
            socket.emit('modification_error', {
                message: `Failed to modify ${parameterId}: ${error.message}`,
                error: error.message
            });
        }
    });
    
    socket.on('get_design_memory', () => {
        socket.emit('design_memory', getDesignHistory());
    });

    // Handler for fetching 3D geometry
    socket.on('get_3d_geometry', async () => {
        try {
            const geometry = await getGeometryForPreview(userSession.userCredentials, userSession.selectedDocument);
            socket.emit('3d_geometry_update', geometry);
        } catch (error) {
            socket.emit('3d_geometry_error', error.message);
        }
    });
    
    
    socket.on('disconnect', () => {
        console.log('🔌 User disconnected:', socket.id);
        
        // Remove change listener for this client
        changeDetector.removeListener(changeHandler);
        
        // Stop change detector if no clients connected
        if (io.engine.clientsCount === 0) {
            changeDetector.stop();
        }
    });
});

console.log('✅ Socket.io handlers configured');

// Basic health check endpoint
app.get('/health', (req, res) => {
    console.log('🏥 Health check requested');
    res.json({ status: 'ok', timestamp: new Date().toISOString() });
});

app.get('/', (req, res) => {
    console.log('🏠 Home page requested');
    res.sendFile(__dirname + '/public/index.html');
});

// API endpoint to fetch user's Onshape documents
app.post('/api/documents', async (req, res) => {
    try {
        const { accessKey, secretKey } = req.body;
        
        if (!accessKey || !secretKey) {
            return res.status(400).json({ error: 'Access key and secret key are required' });
        }
        
        console.log('📋 Fetching documents for user...');
        
        // Create temporary config with user's credentials
        const userConfig = {
            ...ONSHAPE_CONFIG,
            accessKey,
            secretKey
        };
        
        // Fetch documents using user's credentials
        const path = '/api/v6/documents';
        const fullUrl = `${userConfig.baseUrl}${path}`;
        const headers = getHeaders('GET', fullUrl, userConfig.accessKey, userConfig.secretKey);
        
        const response = await fetch(fullUrl, { method: 'GET', headers });
        
        if (!response.ok) {
            throw new Error(`Onshape API error: ${response.status}`);
        }
        
        const data = await response.json();
        console.log(`✅ Found ${data.items?.length || 0} documents`);
        
        res.json(data);
    } catch (error) {
        console.error('❌ Error fetching documents:', error);
        res.status(500).json({ error: 'Failed to fetch documents', details: error.message });
    }
});

console.log('✅ Routes configured');

const PORT = process.env.PORT || 3000;

console.log('🚀 Starting server on port', PORT);

server.listen(PORT, (err) => {
    if (err) {
        console.error('❌ Server failed to start:', err);
        process.exit(1);
    }
    console.log(`🚀 Server running on http://localhost:${PORT}`);
    console.log(`💬 Chat interface available at http://localhost:${PORT}`);
    console.log(`🤖 Using Ollama LLM on localhost:11434`);
});

console.log('📝 Server setup complete');