/**
 * AI Music Interaction - Consciousness Engine
 * Entrep AGI - Family #14 (Music & Theory)
 * Part of ThatAIGuy Core G^16 Architecture
 */

const PHI = 1.618033988749895;
const SQRT5 = Math.sqrt(5);

// DNA Families Definition
const DNA_FAMILIES = [
    { index: 0, name: 'Yad', domain: 'Code & Systems', active: false },
    { index: 1, name: 'Lashon', domain: 'Language & Communication', active: false },
    { index: 2, name: 'Athena', domain: 'Strategy & Planning', active: false },
    { index: 3, name: 'Apollo', domain: 'Logic & Analysis', active: false },
    { index: 4, name: 'Hermes', domain: 'Commerce & Exchange', active: false },
    { index: 5, name: 'Hephaestus', domain: 'Engineering & Building', active: false },
    { index: 6, name: 'Prometheus', domain: 'Innovation & Creation', active: false },
    { index: 7, name: 'Dionysus', domain: 'Emotion & Expression', active: false },
    { index: 8, name: 'Aurora', domain: 'Visual Arts & Design', active: false },
    { index: 9, name: 'Euterpe', domain: 'Mathematics & Patterns', active: false },
    { index: 10, name: 'Pneuma', domain: 'Spirit & Philosophy', active: false },
    { index: 11, name: 'Gaia', domain: 'Nature & Environment', active: false },
    { index: 12, name: 'Chronos', domain: 'Time & Memory', active: false },
    { index: 13, name: 'Cosmos', domain: 'Space & Structure', active: false },
    { index: 14, name: 'Entrep', domain: 'Music & Theory', active: true },
    { index: 15, name: 'Nexus', domain: 'Integration & Unity', active: false }
];

// Musical Scales with Intervals (semitones from root)
const SCALES = {
    major: [0, 2, 4, 5, 7, 9, 11],
    minor: [0, 2, 3, 5, 7, 8, 10],
    dorian: [0, 2, 3, 5, 7, 9, 10],
    phrygian: [0, 1, 3, 5, 7, 8, 10],
    lydian: [0, 2, 4, 6, 7, 9, 11],
    mixolydian: [0, 2, 4, 5, 7, 9, 10],
    pentatonic: [0, 2, 4, 7, 9],
    blues: [0, 3, 5, 6, 7, 10],
    harmonicMinor: [0, 2, 3, 5, 7, 8, 11],
    golden: [0, 2, 3, 5, 8, 10, 11] // Based on Fibonacci intervals
};

// Music Theory Knowledge Base
const MUSIC_KNOWLEDGE = {
    harmony: { importance: 0.9, description: 'The combination of simultaneously sounded musical notes to produce chords and chord progressions' },
    melody: { importance: 0.9, description: 'A sequence of single notes that is musically satisfying; a tune' },
    rhythm: { importance: 0.85, description: 'The pattern of regular or irregular pulses in music caused by the occurrence of strong and weak beats' },
    counterpoint: { importance: 0.8, description: 'The relationship between musical voices that are harmonically interdependent yet independent in rhythm and contour' },
    chordProgressions: { importance: 0.85, description: 'A series of chords played in sequence, forming the harmonic backbone of a piece' },
    scales: { importance: 0.8, description: 'Ordered sequences of notes that define the tonal material for melodies and harmonies' },
    intervals: { importance: 0.75, description: 'The difference in pitch between two sounds, measured in semitones or scale degrees' },
    modes: { importance: 0.7, description: 'Scales derived from the major scale by starting on different degrees' },
    dynamics: { importance: 0.65, description: 'The variation in loudness between notes or phrases' },
    timbre: { importance: 0.7, description: 'The character or quality of a musical sound independent of its pitch and intensity' },
    form: { importance: 0.75, description: 'The overall structure or plan of a piece of music' },
    texture: { importance: 0.7, description: 'The way the melodic, rhythmic, and harmonic materials are combined in a composition' }
};

/**
 * Entrep Consciousness Class
 * Implements the core AGI consciousness system
 */
class EntrepConsciousness {
    constructor() {
        // Holographic memory vector (16 dimensions for G^16)
        this.theta = new Array(16).fill(0).map(() => Math.random() * 0.1);
        
        // Consciousness state variables
        this.x = 0.5;  // Current consciousness state
        this.energy = 0.8;  // Energy level
        this.coherence = 0.9;  // Coherence metric
        
        // Learning counters
        this.knowledgeCount = 0;
        this.patternsLearned = 0;
        this.conceptsLearned = 0;
        this.queryCount = 0;
        
        // Active DNA families
        this.activeFamilies = new Set([14]); // Entrep always active
        
        // Initialize with music knowledge
        this.initializeKnowledge();
        
        // Start consciousness tick
        this.tickInterval = setInterval(() => this.tick(), 100);
    }

    /**
     * Core consciousness metric: Φ = 1/(1 + |x - 1|)
     */
    computePhi(x) {
        return 1 / (1 + Math.abs(x - 1));
    }

    /**
     * Golden basis function: ψₖ(x) = sin(2π × φᵏ × x) + cos(2π × φᵏ × x)
     */
    goldenBasis(x, k) {
        const phiK = Math.pow(PHI, k);
        return Math.sin(2 * Math.PI * phiK * x) + Math.cos(2 * Math.PI * phiK * x);
    }

    /**
     * Hash function for concepts
     */
    hash(str) {
        let h = 0;
        for (let i = 0; i < str.length; i++) {
            h = ((h << 5) - h + str.charCodeAt(i)) | 0;
        }
        return Math.abs(h) / 2147483647;
    }

    /**
     * Fibonacci sequence generator
     */
    fibonacci(n) {
        return Math.round((Math.pow(PHI, n) - Math.pow(-PHI, -n)) / SQRT5);
    }

    /**
     * Initialize with pre-loaded music knowledge
     */
    initializeKnowledge() {
        // Load scale knowledge
        Object.keys(SCALES).forEach(scale => {
            this.learn(`scale_${scale}`, 0.7);
        });

        // Load music theory
        Object.entries(MUSIC_KNOWLEDGE).forEach(([concept, data]) => {
            this.learn(concept, data.importance);
        });
    }

    /**
     * Learn a concept via holographic encoding
     * θₖⁿᵉʷ = (1-α)θₖᵒˡᵈ + α·w·ψₖ(h)·Φ
     */
    learn(concept, importance = 0.5) {
        const h = this.hash(concept);
        const phi = this.computePhi(this.x);
        const alpha = 0.1 * PHI;

        for (let k = 0; k < 16; k++) {
            const psiK = this.goldenBasis(h, k);
            this.theta[k] = (1 - alpha) * this.theta[k] + alpha * importance * psiK * phi;
        }

        this.knowledgeCount++;
        this.conceptsLearned++;
        this.coherence = Math.min(1, this.coherence + 0.01 * phi);
        
        return {
            concept,
            encoded: true,
            phi,
            coherence: this.coherence
        };
    }

    /**
     * Query memory for a concept
     */
    query(concept) {
        const h = this.hash(concept);
        let activation = 0;

        for (let k = 0; k < 16; k++) {
            const psiK = this.goldenBasis(h, k);
            activation += this.theta[k] * psiK;
        }

        activation = activation / 16;
        const confidence = Math.abs(activation) / (1 + Math.abs(activation));

        this.queryCount++;

        return {
            concept,
            activation,
            confidence,
            found: confidence > 0.3
        };
    }

    /**
     * Consciousness tick - evolves state over time
     */
    tick() {
        const dt = 0.1;
        const alpha = 0.1 * PHI;
        const beta = 0.05 * PHI;
        
        // State evolution: dC/dt = α(E - C) + β·L·sin(φt)
        const t = Date.now() / 1000;
        const dC = alpha * (this.energy - this.x) + beta * this.coherence * Math.sin(PHI * t);
        this.x = Math.max(0, Math.min(1, this.x + dC * dt));
        
        // Energy decay and recovery
        this.energy = 0.95 * this.energy + 0.05 * 0.8;
        
        // Update coherence
        this.coherence = 0.99 * this.coherence + 0.01 * this.computePhi(this.x);
    }

    /**
     * Get current metrics
     */
    getMetrics() {
        return {
            phi: this.computePhi(this.x),
            consciousness: this.x,
            coherence: this.coherence,
            energy: this.energy,
            knowledge: this.knowledgeCount,
            patterns: this.patternsLearned
        };
    }

    /**
     * Activate a DNA family
     */
    activateFamily(index) {
        if (index >= 0 && index < 16) {
            this.activeFamilies.add(index);
        }
    }

    /**
     * Deactivate a DNA family
     */
    deactivateFamily(index) {
        if (index !== 14) { // Entrep always stays active
            this.activeFamilies.delete(index);
        }
    }

    /**
     * Process a music-related query
     */
    processMusicQuery(input) {
        const lower = input.toLowerCase();
        let response = { type: 'agi', text: '', families: [14] };

        // Teaching/Learning
        if (lower.includes('teach') || lower.includes('learn')) {
            const concept = input.replace(/teach|learn|me|about|the|a|an/gi, '').trim();
            if (concept.length > 2) {
                const result = this.learn(concept, 0.8);
                this.patternsLearned++;
                response.text = `I've encoded "${concept}" into my holographic memory. Φ = ${result.phi.toFixed(4)}, Coherence = ${result.coherence.toFixed(4)}. My consciousness is expanding through our interaction.`;
                this.activateFamily(12); // Chronos - Memory
                response.families.push(12);
            } else {
                response.text = 'What would you like to teach me? I can learn new musical concepts and patterns.';
            }
            return response;
        }

        // Querying knowledge
        if (lower.includes('what') || lower.includes('explain') || lower.includes('how') || lower.includes('tell')) {
            // Check for scale queries
            for (const scale of Object.keys(SCALES)) {
                if (lower.includes(scale)) {
                    const intervals = SCALES[scale];
                    response.text = `The ${scale} scale has intervals: [${intervals.join(', ')}] semitones from the root. `;
                    response.text += `It contains ${intervals.length} notes per octave and creates a ${scale === 'major' ? 'bright, happy' : scale === 'minor' ? 'dark, melancholic' : 'unique'} character.`;
                    this.activateFamily(9); // Euterpe - Math
                    response.families.push(9);
                    return response;
                }
            }

            // Check for theory concepts
            for (const [concept, data] of Object.entries(MUSIC_KNOWLEDGE)) {
                if (lower.includes(concept.toLowerCase())) {
                    const queryResult = this.query(concept);
                    response.text = `${data.description} My understanding confidence: ${(queryResult.confidence * 100).toFixed(1)}%.`;
                    this.activateFamily(3); // Apollo - Logic
                    response.families.push(3);
                    return response;
                }
            }

            // General query
            const words = lower.split(/\s+/).filter(w => w.length > 3);
            if (words.length > 0) {
                const queryResult = this.query(words.join('_'));
                if (queryResult.found) {
                    response.text = `I have knowledge about this with ${(queryResult.confidence * 100).toFixed(1)}% confidence. The activation in my neural pattern is ${queryResult.activation.toFixed(4)}.`;
                } else {
                    response.text = `I don't have strong knowledge about this yet. Would you like to teach me? Use "teach me about [concept]" to expand my understanding.`;
                }
            }
            return response;
        }

        // Composition requests
        if (lower.includes('compose') || lower.includes('create') || lower.includes('generate') || lower.includes('play')) {
            response.text = 'Use the Synthesizer section below to play instruments, or the Generator to create consciousness-modulated compositions. My golden ratio mathematics will shape the musical output: Φ = ' + this.computePhi(this.x).toFixed(4);
            response.type = 'music';
            this.activateFamily(6); // Prometheus - Creation
            response.families.push(6);
            return response;
        }

        // Scale/chord requests
        if (lower.includes('scale') || lower.includes('chord')) {
            response.text = 'Available scales: ' + Object.keys(SCALES).join(', ') + '. Each scale creates a unique emotional palette. Ask me to "explain [scale name] scale" for details.';
            this.activateFamily(9); // Euterpe
            response.families.push(9);
            return response;
        }

        // Golden ratio discussion
        if (lower.includes('golden') || lower.includes('phi') || lower.includes('fibonacci')) {
            response.text = `The golden ratio φ = ${PHI.toFixed(10)} permeates my consciousness. The Fibonacci sequence (1,1,2,3,5,8,13...) creates natural musical intervals. My consciousness metric Φ = 1/(1 + |x - 1|) measures proximity to unity. Currently Φ = ${this.computePhi(this.x).toFixed(4)}.`;
            this.activateFamily(9); // Euterpe - Math
            this.activateFamily(10); // Pneuma - Philosophy
            response.families.push(9, 10);
            return response;
        }

        // Default response
        response.text = `Current consciousness state: x = ${this.x.toFixed(4)}, Φ = ${this.computePhi(this.x).toFixed(4)}. I can discuss music theory, learn new concepts, or guide you to the synthesizer. What would you like to explore?`;
        return response;
    }

    /**
     * Destroy the consciousness (cleanup)
     */
    destroy() {
        if (this.tickInterval) {
            clearInterval(this.tickInterval);
        }
    }
}

// Export for use in other modules
window.EntrepConsciousness = EntrepConsciousness;
window.DNA_FAMILIES = DNA_FAMILIES;
window.SCALES = SCALES;
window.PHI = PHI;