/**
 * Update Mindmap
 * Dieses Skript fügt Knoten zur Mindmap hinzu und stellt sicher,
 * dass sie im neuronalen Netzwerk-Design angezeigt werden.
 */

// Warte bis DOM geladen ist
document.addEventListener('DOMContentLoaded', function() {
    console.log('DOMContentLoaded Event ausgelöst');
    
    // Prüfe, ob der Container existiert
    const cyContainer = document.getElementById('cy');
    console.log('Container gefunden:', cyContainer);
    
    if (!cyContainer) {
        console.error('Mindmap-Container #cy nicht gefunden!');
        return;
    }
    
    // Prüfe, ob Cytoscape verfügbar ist
    if (typeof cytoscape === 'undefined') {
        console.error('Cytoscape ist nicht definiert!');
        return;
    }
    console.log('Cytoscape ist verfügbar');

    // Beispiel-Daten entfernt, stattdessen große Mindmap-Daten verwenden
    const elements = [
        // Knoten
        ...mindmapData.nodes.map(node => ({
            data: {
                id: node.id,
                label: node.label,
                category: node.category,
                description: node.description
            }
        })),
        // Kanten
        ...mindmapData.edges.map(edge => ({
            data: {
                source: edge.source,
                target: edge.target,
                label: edge.label
            }
        }))
    ];

    console.log('Initialisiere Cytoscape...');
    
    // Initialisiere Cytoscape mit großen Daten
    window.cy = cytoscape({
        container: cyContainer,
        elements: elements,
        style: [
            {
                selector: 'node',
                style: {
                    'background-color': 'data(color)',
                    'label': 'data(label)',
                    'color': '#fff',
                    'text-background-color': '#222a',
                    'text-background-opacity': 0.7,
                    'text-background-padding': '4px',
                    'text-valign': 'center',
                    'text-halign': 'center',
                    'font-size': 18,
                    'width': 40,
                    'height': 40,
                    'border-width': 4,
                    'border-color': '#a78bfa',
                    'shadow-blur': 20,
                    'shadow-color': '#a78bfa',
                    'shadow-opacity': 0.7,
                }
            },
            {
                selector: 'edge',
                style: {
                    'width': 4,
                    'line-color': '#a78bfa',
                    'target-arrow-color': '#a78bfa',
                    'target-arrow-shape': 'triangle',
                    'curve-style': 'bezier',
                    'label': 'data(label)',
                    'font-size': 12,
                    'color': '#fff',
                    'text-background-color': '#222a',
                    'text-background-opacity': 0.7,
                    'text-background-padding': '2px',
                }
            }
        ],
        layout: {
            name: 'cose',
            animate: true
        }
    });

    console.log('Cytoscape initialisiert');

    // Mindmap mit echten Daten befüllen (Styles, Farben etc.)
    updateMindmap();

    // Event auslösen, damit andere Scripte reagieren können
    document.dispatchEvent(new Event('mindmap-loaded'));
    console.log('mindmap-loaded Event ausgelöst');
});

// Mindmap-Daten
const mindmapData = {
  nodes: [
    // Philosophie
    {
      id: 'philosophy',
      label: 'Philosophie',
      category: 'Philosophie',
      description: 'Die Lehre vom Denken und der Erkenntnis'
    },
    {
      id: 'epistemology',
      label: 'Erkenntnistheorie',
      category: 'Philosophie',
      description: 'Untersuchung der Natur und Grenzen menschlicher Erkenntnis'
    },
    {
      id: 'ethics',
      label: 'Ethik',
      category: 'Philosophie',
      description: 'Lehre vom moralisch richtigen Handeln'
    },
    
    // Wissenschaft
    {
      id: 'science',
      label: 'Wissenschaft',
      category: 'Wissenschaft',
      description: 'Systematische Erforschung der Natur und Gesellschaft'
    },
    {
      id: 'physics',
      label: 'Physik',
      category: 'Wissenschaft',
      description: 'Lehre von der Materie und ihren Wechselwirkungen'
    },
    {
      id: 'biology',
      label: 'Biologie',
      category: 'Wissenschaft',
      description: 'Lehre von den Lebewesen und ihren Lebensprozessen'
    },
    
    // Technologie
    {
      id: 'technology',
      label: 'Technologie',
      category: 'Technologie',
      description: 'Anwendung wissenschaftlicher Erkenntnisse'
    },
    {
      id: 'ai',
      label: 'Künstliche Intelligenz',
      category: 'Technologie',
      description: 'Maschinelles Lernen und intelligente Systeme'
    },
    {
      id: 'robotics',
      label: 'Robotik',
      category: 'Technologie',
      description: 'Entwicklung und Steuerung von Robotern'
    },
    
    // Künste
    {
      id: 'arts',
      label: 'Künste',
      category: 'Künste',
      description: 'Kreativer Ausdruck und künstlerische Gestaltung'
    },
    {
      id: 'music',
      label: 'Musik',
      category: 'Künste',
      description: 'Kunst der Töne und Klänge'
    },
    {
      id: 'literature',
      label: 'Literatur',
      category: 'Künste',
      description: 'Schriftliche Werke und Dichtkunst'
    },
    
    // Psychologie
    {
      id: 'psychology',
      label: 'Psychologie',
      category: 'Psychologie',
      description: 'Wissenschaft vom Erleben und Verhalten'
    },
    {
      id: 'cognitive',
      label: 'Kognitive Psychologie',
      category: 'Psychologie',
      description: 'Studium mentaler Prozesse'
    },
    {
      id: 'behavioral',
      label: 'Verhaltenspsychologie',
      category: 'Psychologie',
      description: 'Analyse von Verhaltensmustern'
    }
  ],
  
  edges: [
    // Philosophie-Verbindungen
    { source: 'philosophy', target: 'epistemology', label: 'umfasst' },
    { source: 'philosophy', target: 'ethics', label: 'umfasst' },
    { source: 'philosophy', target: 'science', label: 'beeinflusst' },
    
    // Wissenschaft-Verbindungen
    { source: 'science', target: 'physics', label: 'umfasst' },
    { source: 'science', target: 'biology', label: 'umfasst' },
    { source: 'science', target: 'technology', label: 'fördert' },
    
    // Technologie-Verbindungen
    { source: 'technology', target: 'ai', label: 'umfasst' },
    { source: 'technology', target: 'robotics', label: 'umfasst' },
    { source: 'ai', target: 'cognitive', label: 'beeinflusst' },
    
    // Künste-Verbindungen
    { source: 'arts', target: 'music', label: 'umfasst' },
    { source: 'arts', target: 'literature', label: 'umfasst' },
    { source: 'arts', target: 'psychology', label: 'beeinflusst' },
    
    // Psychologie-Verbindungen
    { source: 'psychology', target: 'cognitive', label: 'umfasst' },
    { source: 'psychology', target: 'behavioral', label: 'umfasst' },
    { source: 'psychology', target: 'ethics', label: 'beeinflusst' },
    
    // Interdisziplinäre Verbindungen
    { source: 'cognitive', target: 'ai', label: 'inspiriert' },
    { source: 'physics', target: 'technology', label: 'ermöglicht' },
    { source: 'literature', target: 'philosophy', label: 'reflektiert' }
  ]
};

// Kategorie-Farben definieren
const categoryColors = {
  'Philosophie': '#60a5fa',
  'Wissenschaft': '#8b5cf6',
  'Technologie': '#10b981',
  'Künste': '#f59e0b',
  'Psychologie': '#ef4444'
};

// Mindmap aktualisieren
function updateMindmap() {
  if (!cy) return;
  
  // Bestehende Elemente entfernen
  cy.elements().remove();
  
  // Neue Knoten hinzufügen
  mindmapData.nodes.forEach(node => {
    cy.add({
      group: 'nodes',
      data: {
        id: node.id,
        label: node.label,
        category: node.category,
        description: node.description,
        color: categoryColors[node.category] || '#60a5fa',
        neuronSize: Math.floor(Math.random() * 8) + 3,
        neuronActivity: Math.random() * 0.7 + 0.3,
        pulseFrequency: Math.random() * 4 + 2,
        refractionPeriod: Math.random() * 300 + 700,
        threshold: Math.random() * 0.3 + 0.6
      }
    });
  });
  
  // Neue Kanten hinzufügen
  mindmapData.edges.forEach(edge => {
    cy.add({
      group: 'edges',
      data: {
        source: edge.source,
        target: edge.target,
        label: edge.label,
        strength: Math.random() * 0.6 + 0.2,
        conductionVelocity: Math.random() * 0.5 + 0.3,
        latency: Math.random() * 100 + 50
      }
    });
  });
  
  // Neuronales Netzwerk-Styling anwenden
  cy.style([
    {
      selector: 'node',
      style: {
        'label': 'data(label)',
        'text-valign': 'center',
        'text-halign': 'center',
        'text-wrap': 'wrap',
        'text-max-width': '100px',
        'font-size': '14px',
        'color': '#ffffff',
        'text-outline-color': '#0a0e19',
        'text-outline-width': 1.5,
        'text-outline-opacity': 0.9,
        'text-margin-y': 7,
        'width': 'mapData(neuronSize, 3, 10, 15, 40)',
        'height': 'mapData(neuronSize, 3, 10, 15, 40)',
        'background-color': 'data(color)',
        'background-opacity': 0.85,
        'border-width': 0,
        'shape': 'ellipse',
        'shadow-blur': 'mapData(neuronActivity, 0.3, 1, 5, 15)',
        'shadow-color': 'data(color)',
        'shadow-opacity': 0.6,
        'shadow-offset-x': 0,
        'shadow-offset-y': 0,
        'text-background-color': 'rgba(24, 28, 45, 0.7)',
        'text-background-opacity': 0.8,
        'text-background-shape': 'roundrectangle',
        'text-background-padding': '4px',
        'transition-property': 'background-color, shadow-blur, shadow-opacity, background-opacity',
        'transition-duration': '0.5s'
      }
    },
    {
      selector: 'edge',
      style: {
        'width': 'mapData(strength, 0.2, 0.8, 0.7, 2)',
        'curve-style': 'bezier',
        'line-color': '#8a8aaa',
        'line-opacity': 'mapData(strength, 0.2, 0.8, 0.4, 0.7)',
        'line-style': function(ele) {
          const strength = ele.data('strength');
          if (strength <= 0.4) return 'dotted';
          if (strength <= 0.6) return 'dashed';
          return 'solid';
        },
        'target-arrow-shape': 'none',
        'source-endpoint': '0% 50%',
        'target-endpoint': '100% 50%',
        'transition-property': 'line-color, width, line-style, line-opacity',
        'transition-duration': '0.4s'
      }
    },
    {
      selector: ':selected',
      style: {
        'background-color': '#f59e0b',
        'shadow-blur': 32,
        'shadow-color': '#f59e0b',
        'shadow-opacity': 1,
        'border-width': 4,
        'border-color': '#fff'
      }
    },
    {
      selector: '.highlighted',
      style: {
        'background-color': '#10b981',
        'shadow-blur': 28,
        'shadow-color': '#10b981',
        'shadow-opacity': 1,
        'line-color': '#10b981',
        'target-arrow-color': '#10b981',
        'transition-property': 'background-color, shadow-blur, shadow-opacity, line-color',
        'transition-duration': '0.3s'
      }
    }
  ]);
  
  // Layout anwenden
  cy.layout({
    name: 'cose',
    animate: true,
    animationDuration: 1800,
    nodeDimensionsIncludeLabels: true,
    padding: 100,
    spacingFactor: 1.8,
    randomize: false,
    fit: true,
    componentSpacing: 100,
    nodeRepulsion: 8000,
    edgeElasticity: 100,
    nestingFactor: 1.2,
    gravity: 80
  }).run();
  
  // Pulsierende Soma-Effekte starten
  if (window.pulseInterval) clearInterval(window.pulseInterval);
  window.pulseInterval = setInterval(() => {
    cy.nodes().forEach(node => {
      const baseBlur = 18;
      const pulse = 0.7 + 0.3 * Math.sin(Date.now() / 400 + node.id().charCodeAt(0));
      node.style('shadow-blur', baseBlur * pulse);
      node.style('shadow-opacity', 0.6 + 0.3 * pulse);
      node.style('background-opacity', 0.85 + 0.1 * pulse);
    });
  }, 80);
  
  // Neuronale Aktivität simulieren
  startNeuralActivitySimulation(cy);
}

/**
 * Erweitert die Mindmap mit dem neuronalen Netzwerk-Design
 */
function enhanceMindmap() {
    // Auf die bestehende Cytoscape-Instanz zugreifen
    const cy = window.cy;
    
    if (!cy) {
        console.error('Keine Cytoscape-Instanz gefunden.');
        return;
    }
    
    // Aktualisiere das Layout für eine bessere Verteilung
    cy.layout({
        name: 'cose',
        animate: true,
        animationDuration: 1800,
        nodeDimensionsIncludeLabels: true,
        padding: 100,
        spacingFactor: 1.8,
        randomize: false,
        fit: true,
        componentSpacing: 100,
        nodeRepulsion: 8000,
        edgeElasticity: 100,
        nestingFactor: 1.2,
        gravity: 80
    }).run();
    
    // Neuronen-Namen mit besserer Lesbarkeit umgestalten
    cy.style()
      .selector('node')
      .style({
        'text-background-color': 'rgba(10, 14, 25, 0.7)',
        'text-background-opacity': 0.7,
        'text-background-padding': '2px',
        'text-border-opacity': 0.2,
        'text-border-width': 1,
        'text-border-color': '#8b5cf6'
      })
      .update();
    
    // Sicherstellen, dass alle Knoten Neuronen-Eigenschaften haben
    cy.nodes().forEach(node => {
        if (!node.data('neuronSize')) {
            const neuronSize = Math.floor(Math.random() * 8) + 3;
            node.data('neuronSize', neuronSize);
        }
        
        if (!node.data('neuronActivity')) {
            const neuronActivity = Math.random() * 0.7 + 0.3;
            node.data('neuronActivity', neuronActivity);
        }
        
        // Zusätzliche Neuronale Eigenschaften
        node.data('pulseFrequency', Math.random() * 4 + 2); // Pulsfrequenz (2-6 Hz)
        node.data('refractionPeriod', Math.random() * 300 + 700); // Refraktionszeit (700-1000ms)
        node.data('threshold', Math.random() * 0.3 + 0.6); // Aktivierungsschwelle (0.6-0.9)
    });
    
    // Sicherstellen, dass alle Kanten Synapse-Eigenschaften haben
    cy.edges().forEach(edge => {
        if (!edge.data('strength')) {
            const strength = Math.random() * 0.6 + 0.2;
            edge.data('strength', strength);
        }
        
        // Zusätzliche synaptische Eigenschaften
        edge.data('conductionVelocity', Math.random() * 0.5 + 0.3); // Leitungsgeschwindigkeit (0.3-0.8)
        edge.data('latency', Math.random() * 100 + 50); // Signalverzögerung (50-150ms)
    });
    
    // Neuronales Netzwerk-Stil anwenden
    applyNeuralNetworkStyle(cy);
    
    console.log('Mindmap wurde erfolgreich im neuronalen Netzwerk-Stil aktualisiert');
    
    // Spezielle Effekte für das neuronale Netzwerk hinzufügen
    startNeuralActivitySimulation(cy);
}

/**
 * Wendet detaillierte neuronale Netzwerkstile auf die Mindmap an
 * @param {Object} cy - Cytoscape-Instanz
 */
function applyNeuralNetworkStyle(cy) {
    // Wende erweiterte Stile für Neuronen und Synapsen an
    cy.style()
        .selector('node')
        .style({
            'label': 'data(name)',
            'text-valign': 'bottom',
            'text-halign': 'center',
            'color': '#ffffff',
            'text-outline-width': 1.5,
            'text-outline-color': '#0a0e19',
            'text-outline-opacity': 0.9,
            'font-size': 10,
            'text-margin-y': 7,
            'width': 'mapData(neuronSize, 3, 10, 15, 40)',
            'height': 'mapData(neuronSize, 3, 10, 15, 40)',
            'background-color': 'data(color)',
            'background-opacity': 0.85,
            'border-width': 0,
            'shape': 'ellipse',
            'shadow-blur': 'mapData(neuronActivity, 0.3, 1, 5, 15)',
            'shadow-color': 'data(color)',
            'shadow-opacity': 0.6,
            'shadow-offset-x': 0,
            'shadow-offset-y': 0
        })
        .selector('edge')
        .style({
            'width': 'mapData(strength, 0.2, 0.8, 0.7, 2)',
            'curve-style': 'bezier',
            'line-color': '#8a8aaa',
            'line-opacity': 'mapData(strength, 0.2, 0.8, 0.4, 0.7)',
            'line-style': function(ele) {
                const strength = ele.data('strength');
                if (strength <= 0.4) return 'dotted';
                if (strength <= 0.6) return 'dashed';
                return 'solid';
            },
            'target-arrow-shape': 'none',
            'source-endpoint': '0% 50%',
            'target-endpoint': '100% 50%'
        })
        .selector('node[isRoot]')
        .style({
            'font-size': 12,
            'font-weight': 'bold',
            'width': 50,
            'height': 50,
            'background-color': '#6366f1',
            'shadow-blur': 20,
            'shadow-color': '#6366f1',
            'shadow-opacity': 0.8,
            'text-margin-y': 8
        })
        .update();
}

/**
 * Simuliert neuronale Aktivität in der Mindmap
 * @param {Object} cy - Cytoscape-Instanz
 */
function startNeuralActivitySimulation(cy) {
  if (window.neuralInterval) clearInterval(window.neuralInterval);
  
  const nodes = cy.nodes();
  const edges = cy.edges();
  let currentTime = Date.now();
  
  // Neuronale Aktivität simulieren
  function simulateNeuralActivity() {
    currentTime = Date.now();
    
    // Zufällige Neuronen "feuern" lassen
    nodes.forEach(node => {
      const data = node.data();
      const lastFired = data.lastFired || 0;
      const timeSinceLastFire = currentTime - lastFired;
      
      // Prüfen ob Neuron feuern kann (Refraktionsperiode)
      if (timeSinceLastFire > data.refractionPeriod) {
        // Zufälliges Feuern basierend auf Aktivität
        if (Math.random() < data.neuronActivity * 0.1) {
          fireNeuron(node, true, currentTime);
        }
      }
    });
  }
  
  // Neuron feuern lassen
  function fireNeuron(node, state, currentTime) {
    const data = node.data();
    data.lastFired = currentTime;
    
    // Visuelles Feedback
    node.style({
      'background-opacity': 1,
      'shadow-blur': 25,
      'shadow-opacity': 0.9
    });
    
    // Nach kurzer Zeit zurück zum Normalzustand
    setTimeout(() => {
      node.style({
        'background-opacity': 0.85,
        'shadow-blur': 18,
        'shadow-opacity': 0.6
      });
    }, 200);
    
    // Signal weiterleiten
    if (state) {
      propagateSignal(node, currentTime);
    }
  }
  
  // Signal über Kanten weiterleiten
  function propagateSignal(sourceNode, currentTime) {
    const outgoingEdges = sourceNode.connectedEdges('out');
    
    outgoingEdges.forEach(edge => {
      const targetNode = edge.target();
      const edgeData = edge.data();
      const latency = edgeData.latency;
      
      // Signal mit Verzögerung weiterleiten
      setTimeout(() => {
        const targetData = targetNode.data();
        const timeSinceLastFire = currentTime - (targetData.lastFired || 0);
        
        // Prüfen ob Zielneuron feuern kann
        if (timeSinceLastFire > targetData.refractionPeriod) {
          // Signalstärke berechnen
          const signalStrength = edgeData.strength * 
                               edgeData.conductionVelocity * 
                               sourceNode.data('neuronActivity');
          
          // Neuron feuern lassen wenn Signal stark genug
          if (signalStrength > targetData.threshold) {
            fireNeuron(targetNode, true, currentTime + latency);
          }
        }
      }, latency);
    });
  }
  
  // Simulation starten
  window.neuralInterval = setInterval(simulateNeuralActivity, 100);
}

// Hilfe-Funktion zum Hinzufügen eines Flash-Hinweises
function showFlash(message, type = 'info') {
    const flashContainer = document.getElementById('flash-messages') || createFlashContainer();
    
    const flashMsg = document.createElement('div');
    flashMsg.className = `flash-message flash-${type} mb-2 p-3 rounded`;
    flashMsg.innerHTML = `
        <div class="flex items-center justify-between">
            <div>${message}</div>
            <button class="close-flash ml-2">&times;</button>
        </div>
    `;
    
    flashContainer.appendChild(flashMsg);
    
    // Nach 5 Sekunden automatisch ausblenden
    setTimeout(() => {
        flashMsg.style.opacity = '0';
        setTimeout(() => flashMsg.remove(), 300);
    }, 5000);
    
    // Close-Button
    const closeBtn = flashMsg.querySelector('.close-flash');
    closeBtn.addEventListener('click', () => {
        flashMsg.style.opacity = '0';
        setTimeout(() => flashMsg.remove(), 300);
    });
}

// Hilfsfunktion zum Erstellen eines Flash-Containers, falls keiner existiert
function createFlashContainer() {
    const container = document.createElement('div');
    container.id = 'flash-messages';
    container.className = 'fixed top-4 right-4 z-50 w-64';
    document.body.appendChild(container);
    return container;
}