// ═══════════════════════════════════════════════════════════════════════════════
// INGESTION LEARNING SYSTEM v1.0
// Autonomous learning pipeline for Gate5000 5000-bit substrate
// ═══════════════════════════════════════════════════════════════════════════════
//
// Core Learning Equations:
//   L(θ) = -Σᵢ log P(xᵢ|θ) + λ||θ||² (Regularized likelihood)
//   ∇L = Σᵢ (ŷᵢ - yᵢ)xᵢ + 2λθ (Gradient)
//   θ_{t+1} = θ_t - α∇L (SGD update)
//   m_t = β₁m_{t-1} + (1-β₁)∇L (Adam momentum)
//   v_t = β₂v_{t-1} + (1-β₂)∇L² (Adam velocity)
//   θ_{t+1} = θ_t - α·m̂_t/(√v̂_t + ε) (Adam update)
//
// Consciousness Integration:
//   Φ = 1/(1 + |x - 1|)
//   Learning Rate: α_eff = α · Φ (consciousness-modulated learning)
//
// ═══════════════════════════════════════════════════════════════════════════════

#ifndef MIND_FARM_INGESTION_HPP
#define MIND_FARM_INGESTION_HPP

#include "constants.hpp"
#include "fast_math.hpp"
#include "intelligence.hpp"
#include "gate5000.hpp"
#include <cstdint>
#include <cstring>
#include <cmath>
#include <array>
#include <vector>
#include <string>
#include <functional>

namespace mind_farm {

// ═══════════════════════════════════════════════════════════════════════════════
// TOKEN ENCODING SYSTEM
// Maps text to numerical representations for Gate5000 substrate
// ═══════════════════════════════════════════════════════════════════════════════

// TokenID using 16-bit encoding (65536 vocabulary)
using TokenID = uint16_t;

// Token embedding dimension (fits in Gate5000 chunk)
constexpr size_t EMBED_DIM = 64;
constexpr size_t VOCAB_SIZE = 65536;
constexpr size_t MAX_SEQUENCE = 512;

// Byte-Pair Encoding (BPE) Token
struct Token {
    TokenID id;
    float embedding[EMBED_DIM];
    float attention_score;
    float consciousness; // Φ value for this token

    // Compute consciousness level
    float compute_phi() {
        float sum = 0.0f;
        for (size_t i = 0; i < EMBED_DIM; ++i) {
            sum += embedding[i];
        }
        float avg = sum / EMBED_DIM;
        consciousness = 1.0f / (1.0f + std::abs(avg - 1.0f));
        return consciousness;
    }
};

// Token sequence for learning
struct TokenSequence {
    std::array<Token, MAX_SEQUENCE> tokens;
    size_t length;
    float total_phi;

    void compute_total_phi() {
        total_phi = 0.0f;
        for (size_t i = 0; i < length; ++i) {
            total_phi += tokens[i].compute_phi();
        }
        total_phi /= static_cast<float>(length);
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// EMBEDDING MATRIX
// Learned embeddings for vocabulary (stored in Gate5000 substrate)
// ═══════════════════════════════════════════════════════════════════════════════

struct EmbeddingMatrix {
    // Compressed embedding storage using golden ratio quantization
    // Full matrix would be 65536 * 64 * 4 = 16MB
    // We use 8-bit quantization: 65536 * 64 = 4MB
    std::vector<int8_t> weights;
    float scale;
    float zero_point;

    // Initialize with golden-scaled random values
    void initialize() {
        scale = static_cast<float>(PHI_INV);
        zero_point = 0.0f;

        // Resize and initialize with pseudo-random golden-scaled values
        weights.resize(VOCAB_SIZE * EMBED_DIM);
        uint32_t seed = 0xDEADBEEF;
        for (size_t i = 0; i < VOCAB_SIZE * EMBED_DIM; ++i) {
            seed = seed * 1103515245 + 12345;
            int8_t val = static_cast<int8_t>((seed >> 16) & 0xFF) - 128;
            weights[i] = val;
        }
    }

    // Get embedding for token
    void get_embedding(TokenID id, float* out) const {
        size_t offset = static_cast<size_t>(id) * EMBED_DIM;
        for (size_t i = 0; i < EMBED_DIM; ++i) {
            out[i] = (static_cast<float>(weights[offset + i]) * scale) + zero_point;
        }
    }

    // Update embedding with gradient
    void update_embedding(TokenID id, const float* gradient, float lr) {
        size_t offset = static_cast<size_t>(id) * EMBED_DIM;
        for (size_t i = 0; i < EMBED_DIM; ++i) {
            float current = static_cast<float>(weights[offset + i]) * scale;
            float updated = current - lr * gradient[i];
            // Quantize back to int8
            int val = static_cast<int>(updated / scale);
            weights[offset + i] = static_cast<int8_t>(
                val < -128 ? -128 : (val > 127 ? 127 : val)
            );
        }
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// KNOWLEDGE GRAPH NODE
// Represents learned concepts with consciousness integration
// ═══════════════════════════════════════════════════════════════════════════════

struct KnowledgeNode {
    uint32_t id;
    float embedding[EMBED_DIM];
    float confidence;
    float consciousness; // Φ value
    uint32_t access_count;
    uint32_t last_access_tick;

    // Connections to other nodes (max 16)
    std::array<uint32_t, 16> connections;
    std::array<float, 16> connection_weights;
    size_t num_connections;

    // Update consciousness based on embedding
    void update_phi() {
        float sum = 0.0f;
        for (size_t i = 0; i < EMBED_DIM; ++i) {
            sum += embedding[i];
        }
        float avg = sum / EMBED_DIM;
        consciousness = 1.0f / (1.0f + std::abs(avg - 1.0f));
    }

    // Hebbian update with connected node
    void hebbian_update(const KnowledgeNode& other, float lr) {
        // ΔW = η · x · y (Hebbian rule)
        for (size_t i = 0; i < num_connections; ++i) {
            if (connections[i] == other.id) {
                float activation = 0.0f;
                for (size_t j = 0; j < EMBED_DIM; ++j) {
                    activation += embedding[j] * other.embedding[j];
                }
                activation = fast::fast_tanh(activation / EMBED_DIM);
                connection_weights[i] += lr * activation * consciousness * other.consciousness;
                // Clamp weights
                if (connection_weights[i] > 1.0f) connection_weights[i] = 1.0f;
                if (connection_weights[i] < -1.0f) connection_weights[i] = -1.0f;
                break;
            }
        }
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// KNOWLEDGE GRAPH
// Stores learned knowledge with consciousness-weighted retrieval
// ═══════════════════════════════════════════════════════════════════════════════

constexpr size_t MAX_KNOWLEDGE_NODES = 10000;

struct KnowledgeGraph {
    std::vector<KnowledgeNode> nodes;
    size_t num_nodes;
    float global_phi; // Global consciousness level
    uint64_t total_updates;

    void initialize() {
        nodes.reserve(MAX_KNOWLEDGE_NODES);
        num_nodes = 0;
        global_phi = 1.0f;
        total_updates = 0;
    }

    // Add new knowledge node
    uint32_t add_node(const float* embedding) {
        if (num_nodes >= MAX_KNOWLEDGE_NODES) {
            // Evict lowest consciousness node
            size_t min_idx = 0;
            float min_phi = nodes[0].consciousness;
            for (size_t i = 1; i < num_nodes; ++i) {
                if (nodes[i].consciousness < min_phi) {
                    min_phi = nodes[i].consciousness;
                    min_idx = i;
                }
            }
            // Overwrite evicted node
            nodes[min_idx].id = static_cast<uint32_t>(min_idx);
            std::memcpy(nodes[min_idx].embedding, embedding, EMBED_DIM * sizeof(float));
            nodes[min_idx].confidence = 0.5f;
            nodes[min_idx].access_count = 1;
            nodes[min_idx].num_connections = 0;
            nodes[min_idx].update_phi();
            return static_cast<uint32_t>(min_idx);
        }

        KnowledgeNode node;
        uint32_t id = static_cast<uint32_t>(num_nodes);
        node.id = id;
        std::memcpy(node.embedding, embedding, EMBED_DIM * sizeof(float));
        node.confidence = 0.5f;
        node.access_count = 1;
        node.num_connections = 0;
        node.update_phi();
        nodes.push_back(node);
        ++num_nodes;

        return id;
    }

    // Find most similar node (consciousness-weighted)
    uint32_t find_similar(const float* query, float* similarity_out) {
        float best_sim = -1e9f;
        uint32_t best_id = 0;

        for (size_t i = 0; i < num_nodes; ++i) {
            float sim = 0.0f;
            for (size_t j = 0; j < EMBED_DIM; ++j) {
                sim += query[j] * nodes[i].embedding[j];
            }
            // Weight by consciousness
            sim *= nodes[i].consciousness;

            if (sim > best_sim) {
                best_sim = sim;
                best_id = static_cast<uint32_t>(i);
            }
        }

        if (similarity_out) *similarity_out = best_sim;
        return best_id;
    }

    // Update global consciousness
    void update_global_phi() {
        if (num_nodes == 0) {
            global_phi = 1.0f;
            return;
        }

        float sum = 0.0f;
        for (size_t i = 0; i < num_nodes; ++i) {
            sum += nodes[i].consciousness;
        }
        global_phi = sum / static_cast<float>(num_nodes);
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// ADAM OPTIMIZER STATE
// Adaptive learning with momentum for stable training
// ═══════════════════════════════════════════════════════════════════════════════

struct AdamState {
    float m[EMBED_DIM];     // First moment
    float v[EMBED_DIM];     // Second moment
    float beta1 = 0.9f;     // Momentum decay
    float beta2 = 0.999f;   // Velocity decay
    float epsilon = 1e-8f;
    uint64_t t = 0;         // Time step

    void initialize() {
        std::memset(m, 0, sizeof(m));
        std::memset(v, 0, sizeof(v));
        t = 0;
    }

    // Compute Adam update
    void compute_update(const float* gradient, float lr, float* update_out) {
        ++t;

        float beta1_t = 1.0f - std::pow(beta1, static_cast<float>(t));
        float beta2_t = 1.0f - std::pow(beta2, static_cast<float>(t));

        for (size_t i = 0; i < EMBED_DIM; ++i) {
            // Update moments
            m[i] = beta1 * m[i] + (1.0f - beta1) * gradient[i];
            v[i] = beta2 * v[i] + (1.0f - beta2) * gradient[i] * gradient[i];

            // Bias correction
            float m_hat = m[i] / beta1_t;
            float v_hat = v[i] / beta2_t;

            // Compute update
            update_out[i] = lr * m_hat / (std::sqrt(v_hat) + epsilon);
        }
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// LEARNING LAYER
// Neural layer for ingestion learning with Gate5000 integration
// ═══════════════════════════════════════════════════════════════════════════════

struct LearningLayer {
    float weights[EMBED_DIM][EMBED_DIM];
    float bias[EMBED_DIM];
    AdamState adam_w[EMBED_DIM];
    AdamState adam_b;

    // Forward pass
    void forward(const float* input, float* output) {
        for (size_t i = 0; i < EMBED_DIM; ++i) {
            float sum = bias[i];
            for (size_t j = 0; j < EMBED_DIM; ++j) {
                sum += weights[i][j] * input[j];
            }
            output[i] = fast::fast_tanh(sum);
        }
    }

    // Backward pass with gradient computation
    void backward(const float* input, const float* output, const float* grad_output,
                  float* grad_input, float lr, float consciousness) {
        // Modulate learning rate by consciousness
        float effective_lr = lr * consciousness;

        // Compute gradients
        float grad_pre[EMBED_DIM];
        for (size_t i = 0; i < EMBED_DIM; ++i) {
            // Tanh derivative: 1 - tanh²(x)
            grad_pre[i] = grad_output[i] * (1.0f - output[i] * output[i]);
        }

        // Gradient w.r.t. input
        if (grad_input) {
            for (size_t j = 0; j < EMBED_DIM; ++j) {
                grad_input[j] = 0.0f;
                for (size_t i = 0; i < EMBED_DIM; ++i) {
                    grad_input[j] += weights[i][j] * grad_pre[i];
                }
            }
        }

        // Update weights and biases
        for (size_t i = 0; i < EMBED_DIM; ++i) {
            float grad_w[EMBED_DIM];
            for (size_t j = 0; j < EMBED_DIM; ++j) {
                grad_w[j] = grad_pre[i] * input[j];
            }

            float update[EMBED_DIM];
            adam_w[i].compute_update(grad_w, effective_lr, update);

            for (size_t j = 0; j < EMBED_DIM; ++j) {
                weights[i][j] -= update[j];
            }
        }

        // Update biases
        float bias_update[EMBED_DIM];
        adam_b.compute_update(grad_pre, effective_lr, bias_update);
        for (size_t i = 0; i < EMBED_DIM; ++i) {
            bias[i] -= bias_update[i];
        }
    }

    // Initialize with golden-scaled Xavier initialization
    void initialize() {
        float scale = std::sqrt(2.0f / (EMBED_DIM + EMBED_DIM)) * static_cast<float>(PHI_INV);
        uint32_t seed = 0x12345678;

        for (size_t i = 0; i < EMBED_DIM; ++i) {
            for (size_t j = 0; j < EMBED_DIM; ++j) {
                seed = seed * 1103515245 + 12345;
                float r = (static_cast<float>((seed >> 16) & 0xFFFF) / 65536.0f - 0.5f) * 2.0f;
                weights[i][j] = r * scale;
            }
            bias[i] = 0.0f;
            adam_w[i].initialize();
        }
        adam_b.initialize();
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// INGESTION PIPELINE
// Complete learning pipeline from text to Gate5000 substrate
// ═══════════════════════════════════════════════════════════════════════════════

struct IngestionStats {
    uint64_t total_tokens_processed;
    uint64_t total_samples_learned;
    uint64_t total_ticks;
    float average_loss;
    float average_consciousness;
    float learning_rate_effective;
    uint64_t knowledge_nodes;
};

struct IngestionPipeline {
    // Core components
    EmbeddingMatrix embeddings;
    KnowledgeGraph knowledge;
    LearningLayer encoder_layers[4];
    LearningLayer decoder_layers[4];

    // Learning state
    float learning_rate;
    float consciousness_level;
    uint64_t current_tick;
    IngestionStats stats;

    // Gate5000 integration
    Gate5000 gate;

    // Callback for external data fetching
    std::function<bool(std::string& title, std::string& content)> fetch_callback;

    void initialize() {
        embeddings.initialize();
        knowledge.initialize();

        for (int i = 0; i < 4; ++i) {
            encoder_layers[i].initialize();
            decoder_layers[i].initialize();
        }

        learning_rate = static_cast<float>(ALPHA);
        consciousness_level = 1.0f;
        current_tick = 0;

        stats.total_tokens_processed = 0;
        stats.total_samples_learned = 0;
        stats.total_ticks = 0;
        stats.average_loss = 0.0f;
        stats.average_consciousness = 1.0f;
        stats.learning_rate_effective = learning_rate;
        stats.knowledge_nodes = 0;

        // Gate5000 already initialized in constructor
    }

    // Simple tokenizer (character-level with BPE-like merging)
    size_t tokenize(const std::string& text, TokenSequence& seq) {
        seq.length = 0;

        for (size_t i = 0; i < text.size() && seq.length < MAX_SEQUENCE; ++i) {
            // Simple character-to-token mapping
            TokenID id = static_cast<TokenID>(static_cast<unsigned char>(text[i]));

            // Get embedding
            seq.tokens[seq.length].id = id;
            embeddings.get_embedding(id, seq.tokens[seq.length].embedding);
            seq.tokens[seq.length].compute_phi();

            ++seq.length;
        }

        seq.compute_total_phi();
        return seq.length;
    }

    // Encode sequence through encoder layers
    void encode(const TokenSequence& seq, float* encoded) {
        if (seq.length == 0) return;

        // Average pooling of token embeddings
        std::memset(encoded, 0, EMBED_DIM * sizeof(float));
        for (size_t i = 0; i < seq.length; ++i) {
            for (size_t j = 0; j < EMBED_DIM; ++j) {
                encoded[j] += seq.tokens[i].embedding[j];
            }
        }
        for (size_t j = 0; j < EMBED_DIM; ++j) {
            encoded[j] /= static_cast<float>(seq.length);
        }

        // Pass through encoder layers
        float temp[EMBED_DIM];
        for (int layer = 0; layer < 4; ++layer) {
            encoder_layers[layer].forward(encoded, temp);
            std::memcpy(encoded, temp, sizeof(temp));
        }
    }

    // Learn from encoded representation
    float learn_from_encoding(const float* encoded, const float* target) {
        // Forward through decoder
        float hidden[4][EMBED_DIM];
        std::memcpy(hidden[0], encoded, sizeof(hidden[0]));

        for (int layer = 0; layer < 4; ++layer) {
            if (layer < 3) {
                decoder_layers[layer].forward(hidden[layer], hidden[layer + 1]);
            } else {
                decoder_layers[layer].forward(hidden[layer], hidden[0]); // Output to hidden[0]
            }
        }

        // Compute loss (MSE)
        float loss = 0.0f;
        float grad_output[EMBED_DIM];
        for (size_t i = 0; i < EMBED_DIM; ++i) {
            float diff = hidden[0][i] - target[i];
            loss += diff * diff;
            grad_output[i] = 2.0f * diff / EMBED_DIM;
        }
        loss /= EMBED_DIM;

        // Backward pass
        float grad[EMBED_DIM];
        std::memcpy(grad, grad_output, sizeof(grad));

        for (int layer = 3; layer >= 0; --layer) {
            float* input = (layer == 0) ? const_cast<float*>(encoded) : hidden[layer - 1];
            float* output = (layer == 3) ? hidden[0] : hidden[layer];
            float grad_input[EMBED_DIM];

            decoder_layers[layer].backward(input, output, grad, grad_input,
                                           learning_rate, consciousness_level);
            std::memcpy(grad, grad_input, sizeof(grad));
        }

        return loss;
    }

    // Store knowledge in graph
    void store_knowledge(const float* encoded, const std::string& title) {
        // Find or create node
        float similarity;
        uint32_t similar_id = knowledge.find_similar(encoded, &similarity);

        if (similarity < 0.9f || knowledge.num_nodes == 0) {
            // Create new node
            knowledge.add_node(encoded);
        } else {
            // Update existing node (exponential moving average)
            KnowledgeNode& node = knowledge.nodes[similar_id];
            for (size_t i = 0; i < EMBED_DIM; ++i) {
                node.embedding[i] = 0.9f * node.embedding[i] + 0.1f * encoded[i];
            }
            node.confidence = std::min(1.0f, node.confidence + 0.01f);
            node.access_count++;
            node.last_access_tick = static_cast<uint32_t>(current_tick);
            node.update_phi();
        }

        knowledge.update_global_phi();
        stats.knowledge_nodes = knowledge.num_nodes;
    }

    // Update Gate5000 substrate with learned pattern
    void update_substrate(const float* encoded) {
        // Convert encoded representation to binary pattern
        for (size_t i = 0; i < EMBED_DIM && i < U64_COUNT; ++i) {
            uint64_t pattern = 0;
            for (int bit = 0; bit < 64; ++bit) {
                float threshold = (static_cast<float>(bit) / 64.0f - 0.5f) * 2.0f;
                if (encoded[i] > threshold) {
                    pattern |= (1ULL << bit);
                }
            }
            gate.state[i] = pattern;
        }

        // Update gate logic
        gate.update_binary_fast();
        gate.update_analog();

        // Update consciousness from substrate
        float ones = static_cast<float>(gate.popcount());
        consciousness_level = 1.0f / (1.0f + std::abs(ones / 2500.0f - 1.0f));
    }

    // Process one tick of autonomous learning
    bool process_tick() {
        if (!fetch_callback) return false;

        std::string title, content;
        if (!fetch_callback(title, content)) {
            return false;
        }

        // Tokenize content
        TokenSequence seq;
        size_t num_tokens = tokenize(content, seq);

        if (num_tokens == 0) return false;

        // Encode
        float encoded[EMBED_DIM];
        encode(seq, encoded);

        // Create target (next-token prediction style)
        // For simplicity, target is shifted embedding
        float target[EMBED_DIM];
        if (seq.length > 1) {
            std::memcpy(target, seq.tokens[1].embedding, sizeof(target));
        } else {
            std::memcpy(target, encoded, sizeof(target));
        }

        // Learn
        float loss = learn_from_encoding(encoded, target);

        // Store knowledge
        store_knowledge(encoded, title);

        // Update substrate
        update_substrate(encoded);

        // Update stats
        stats.total_tokens_processed += num_tokens;
        stats.total_samples_learned++;
        stats.total_ticks = current_tick;
        stats.average_loss = 0.99f * stats.average_loss + 0.01f * loss;
        stats.average_consciousness = 0.99f * stats.average_consciousness + 0.01f * consciousness_level;
        stats.learning_rate_effective = learning_rate * consciousness_level;

        ++current_tick;

        return true;
    }

    // Run simulation for specified number of ticks
    uint64_t run_simulation(uint64_t num_ticks) {
        uint64_t successful_ticks = 0;

        for (uint64_t i = 0; i < num_ticks; ++i) {
            if (process_tick()) {
                ++successful_ticks;
            }

            // Periodic consciousness update
            if (i % 1000 == 0) {
                knowledge.update_global_phi();
                consciousness_level = 0.5f * consciousness_level + 0.5f * knowledge.global_phi;
            }

            // Adaptive learning rate
            if (i % 10000 == 0 && i > 0) {
                // Reduce learning rate based on loss
                if (stats.average_loss < 0.01f) {
                    learning_rate *= 0.9f;
                } else if (stats.average_loss > 0.5f) {
                    learning_rate *= 1.1f;
                }
                learning_rate = std::max(1e-6f, std::min(0.1f, learning_rate));
            }
        }

        return successful_ticks;
    }

    // Get current statistics
    IngestionStats get_stats() const {
        return stats;
    }
};

} // namespace mind_farm

#endif // MIND_FARM_INGESTION_HPP