// Simplified Discovery Integration
// Updated for simplified signal names + tags architecture

class SimplifiedProtocolDiscovery {
    constructor() {
        this.currentScanId = 'simplified-scan-123';
        this.isScanning = false;
    }

    init() {
        this.bindDiscoveryEvents();
    }

    bindDiscoveryEvents() {
        // Auto-fill signal form from discovery
        document.addEventListener('click', (e) => {
            if (e.target.classList.contains('use-discovered-endpoint')) {
                this.useDiscoveredEndpoint(e.target.dataset.endpointId);
            }
        });
    }

    async useDiscoveredEndpoint(endpointId) {
        console.log('Using discovered endpoint:', endpointId);
        
        // Mock endpoint data (in real implementation, this would come from discovery service)
        const endpoints = {
            'device_001': {
                device_id: 'device_001',
                protocol_type: 'modbus_tcp',
                device_name: 'Water Pump Controller',
                address: '192.168.1.100',
                port: 502,
                data_point: 'Speed',
                protocol_address: '40001'
            },
            'device_002': {
                device_id: 'device_002',
                protocol_type: 'opcua',
                device_name: 'Temperature Sensor',
                address: '192.168.1.101',
                port: 4840,
                data_point: 'Temperature',
                protocol_address: 'ns=2;s=Temperature'
            },
            'device_003': {
                device_id: 'device_003',
                protocol_type: 'modbus_tcp',
                device_name: 'Pressure Transmitter',
                address: '192.168.1.102',
                port: 502,
                data_point: 'Pressure',
                protocol_address: '30001'
            }
        };
        
        const endpoint = endpoints[endpointId];
        if (!endpoint) {
            this.showNotification(`Endpoint ${endpointId} not found`, 'error');
            return;
        }
        
        // Convert to simplified signal format
        const signalData = this.convertEndpointToSignal(endpoint);
        
        // Auto-populate the signal form
        this.autoPopulateSignalForm(signalData);
        
        this.showNotification(`Endpoint ${endpoint.device_name} selected for signal creation`, 'success');
    }

    convertEndpointToSignal(endpoint) {
        // Generate human-readable signal name
        const signalName = `${endpoint.device_name} ${endpoint.data_point}`;
        
        // Generate meaningful tags
        const tags = [
            `device:${endpoint.device_name.toLowerCase().replace(/[^a-z0-9]/g, '_')}`,
            `protocol:${endpoint.protocol_type}`,
            `data_point:${endpoint.data_point.toLowerCase().replace(/[^a-z0-9]/g, '_')}`,
            'discovered:true'
        ];
        
        // Add device-specific tags
        if (endpoint.device_name.toLowerCase().includes('pump')) {
            tags.push('equipment:pump');
        }
        if (endpoint.device_name.toLowerCase().includes('sensor')) {
            tags.push('equipment:sensor');
        }
        if (endpoint.device_name.toLowerCase().includes('controller')) {
            tags.push('equipment:controller');
        }
        
        // Add protocol-specific tags
        if (endpoint.protocol_type === 'modbus_tcp') {
            tags.push('interface:modbus');
        } else if (endpoint.protocol_type === 'opcua') {
            tags.push('interface:opcua');
        }
        
        // Generate database source
        const dbSource = `measurements.${endpoint.device_name.toLowerCase().replace(/[^a-z0-9]/g, '_')}_${endpoint.data_point.toLowerCase().replace(/[^a-z0-9]/g, '_')}`;
        
        return {
            signal_name: signalName,
            tags: tags,
            protocol_type: endpoint.protocol_type,
            protocol_address: endpoint.protocol_address,
            db_source: dbSource
        };
    }

    autoPopulateSignalForm(signalData) {
        console.log('Auto-populating signal form with:', signalData);
        
        // Use the simplified protocol mapping function
        if (typeof autoPopulateSignalForm === 'function') {
            autoPopulateSignalForm(signalData);
        } else {
            console.error('Simplified protocol mapping functions not loaded');
            this.showNotification('Protocol mapping system not available', 'error');
        }
    }

    // Advanced discovery features
    async discoverAndSuggestSignals(networkRange = '192.168.1.0/24') {
        console.log(`Starting discovery scan on ${networkRange}`);
        this.isScanning = true;
        
        try {
            // Mock discovery results
            const discoveredEndpoints = await this.mockDiscoveryScan(networkRange);
            
            // Convert to suggested signals
            const suggestedSignals = discoveredEndpoints.map(endpoint => 
                this.convertEndpointToSignal(endpoint)
            );
            
            this.displayDiscoveryResults(suggestedSignals);
            this.isScanning = false;
            
            return suggestedSignals;
            
        } catch (error) {
            console.error('Discovery scan failed:', error);
            this.showNotification('Discovery scan failed', 'error');
            this.isScanning = false;
            return [];
        }
    }

    async mockDiscoveryScan(networkRange) {
        // Simulate network discovery delay
        await new Promise(resolve => setTimeout(resolve, 2000));
        
        // Return mock discovered endpoints
        return [
            {
                device_id: 'discovered_001',
                protocol_type: 'modbus_tcp',
                device_name: 'Booster Pump',
                address: '192.168.1.110',
                port: 502,
                data_point: 'Flow Rate',
                protocol_address: '30002'
            },
            {
                device_id: 'discovered_002',
                protocol_type: 'modbus_tcp',
                device_name: 'Level Sensor',
                address: '192.168.1.111',
                port: 502,
                data_point: 'Tank Level',
                protocol_address: '30003'
            },
            {
                device_id: 'discovered_003',
                protocol_type: 'opcua',
                device_name: 'PLC Controller',
                address: '192.168.1.112',
                port: 4840,
                data_point: 'System Status',
                protocol_address: 'ns=2;s=SystemStatus'
            }
        ];
    }

    displayDiscoveryResults(suggestedSignals) {
        const resultsContainer = document.getElementById('discovery-results');
        if (!resultsContainer) return;
        
        resultsContainer.innerHTML = '<h3>Discovery Results</h3>';
        
        suggestedSignals.forEach((signal, index) => {
            const signalCard = document.createElement('div');
            signalCard.className = 'discovery-result-card';
            signalCard.innerHTML = `
                <div class="signal-info">
                    <strong>${signal.signal_name}</strong>
                    <div class="signal-tags">
                        ${signal.tags.map(tag => `<span class="tag">${tag}</span>`).join('')}
                    </div>
                    <div class="signal-details">
                        <span>Protocol: ${signal.protocol_type}</span>
                        <span>Address: ${signal.protocol_address}</span>
                    </div>
                </div>
                <button class="use-signal-btn" data-signal-index="${index}">
                    Use This Signal
                </button>
            `;
            
            resultsContainer.appendChild(signalCard);
        });
        
        // Add event listeners for use buttons
        resultsContainer.addEventListener('click', (e) => {
            if (e.target.classList.contains('use-signal-btn')) {
                const signalIndex = parseInt(e.target.dataset.signalIndex);
                const signal = suggestedSignals[signalIndex];
                this.autoPopulateSignalForm(signal);
            }
        });
    }

    // Tag-based signal search
    async searchSignalsByTags(tags) {
        try {
            const params = new URLSearchParams();
            tags.forEach(tag => params.append('tags', tag));
            
            const response = await fetch(`/api/v1/dashboard/protocol-signals?${params}`);
            const data = await response.json();
            
            if (data.success) {
                return data.signals;
            } else {
                console.error('Failed to search signals by tags:', data.detail);
                return [];
            }
        } catch (error) {
            console.error('Error searching signals by tags:', error);
            return [];
        }
    }

    // Signal name suggestions based on device type
    generateSignalNameSuggestions(deviceName, dataPoint) {
        const baseName = `${deviceName} ${dataPoint}`;
        
        const suggestions = [
            baseName,
            `${dataPoint} of ${deviceName}`,
            `${deviceName} ${dataPoint} Reading`,
            `${dataPoint} Measurement - ${deviceName}`
        ];
        
        // Add context-specific suggestions
        if (dataPoint.toLowerCase().includes('speed')) {
            suggestions.push(`${deviceName} Motor Speed`);
            suggestions.push(`${deviceName} RPM`);
        }
        
        if (dataPoint.toLowerCase().includes('temperature')) {
            suggestions.push(`${deviceName} Temperature`);
            suggestions.push(`Temperature at ${deviceName}`);
        }
        
        if (dataPoint.toLowerCase().includes('pressure')) {
            suggestions.push(`${deviceName} Pressure`);
            suggestions.push(`Pressure Reading - ${deviceName}`);
        }
        
        return suggestions;
    }

    // Tag suggestions based on device and protocol
    generateTagSuggestions(deviceName, protocolType, dataPoint) {
        const suggestions = new Set();
        
        // Device type tags
        if (deviceName.toLowerCase().includes('pump')) {
            suggestions.add('equipment:pump');
            suggestions.add('fluid:water');
        }
        if (deviceName.toLowerCase().includes('sensor')) {
            suggestions.add('equipment:sensor');
            suggestions.add('type:measurement');
        }
        if (deviceName.toLowerCase().includes('controller')) {
            suggestions.add('equipment:controller');
            suggestions.add('type:control');
        }
        
        // Protocol tags
        suggestions.add(`protocol:${protocolType}`);
        if (protocolType === 'modbus_tcp' || protocolType === 'modbus_rtu') {
            suggestions.add('interface:modbus');
        } else if (protocolType === 'opcua') {
            suggestions.add('interface:opcua');
        }
        
        // Data point tags
        suggestions.add(`data_point:${dataPoint.toLowerCase().replace(/[^a-z0-9]/g, '_')}`);
        
        if (dataPoint.toLowerCase().includes('speed')) {
            suggestions.add('unit:rpm');
            suggestions.add('type:setpoint');
        }
        if (dataPoint.toLowerCase().includes('temperature')) {
            suggestions.add('unit:celsius');
            suggestions.add('type:measurement');
        }
        if (dataPoint.toLowerCase().includes('pressure')) {
            suggestions.add('unit:psi');
            suggestions.add('type:measurement');
        }
        if (dataPoint.toLowerCase().includes('status')) {
            suggestions.add('type:status');
            suggestions.add('format:boolean');
        }
        
        // Discovery tag
        suggestions.add('discovered:true');
        
        return Array.from(suggestions);
    }

    showNotification(message, type = 'info') {
        const notification = document.createElement('div');
        notification.className = `discovery-notification ${type}`;
        notification.textContent = message;
        
        document.body.appendChild(notification);
        
        // Auto-remove after 5 seconds
        setTimeout(() => {
            if (notification.parentNode) {
                notification.remove();
            }
        }, 5000);
    }
}

// Global instance
const simplifiedDiscovery = new SimplifiedProtocolDiscovery();

// Initialize when DOM is loaded
document.addEventListener('DOMContentLoaded', function() {
    simplifiedDiscovery.init();
});