// Define hexagonal coordinate system
typedef struct {
    int q;      // First axial coordinate
    int r;      // Second axial coordinate
    int s;      // Third coordinate (derived: s = -q - r)
} hex_coord_t;

// Define memory node structure
typedef struct {
    hex_coord_t coordinates;          // Position in hex grid
    embedding_t* semantic_vector;     // Semantic embedding
    uint32_t content_size;            // Size of content
    void* content;                    // Node content
    float activation;                 // Current activation level
    timestamp_t last_access;          // Last access time
    strength_t* connections[6];       // Connection strengths to neighbors
} memory_node_t;

// Calculate hex distance (Manhattan distance in hex coordinates)
int hex_distance(hex_coord_t a, hex_coord_t b) {
    return (abs(a.q - b.q) + abs(a.r - b.r) + abs(a.s - b.s)) / 2;
}

// Get coordinates of the six neighbors
hex_coord_t* get_hex_neighbors(hex_coord_t center) {
    // Direction vectors for the six neighbors
    static const int dir_q[] = {1, 1, 0, -1, -1, 0};
    static const int dir_r[] = {0, -1, -1, 0, 1, 1};
    
    hex_coord_t* neighbors = malloc(6 * sizeof(hex_coord_t));
    
    for (int i = 0; i < 6; i++) {
        neighbors[i].q = center.q + dir_q[i];
        neighbors[i].r = center.r + dir_r[i];
        neighbors[i].s = -neighbors[i].q - neighbors[i].r;
    }
    
    return neighbors;
}

// Define multi-level resolution structure
typedef struct {
    uint8_t levels;                   // Number of resolution levels
    memory_space_t** spaces;          // Array of memory spaces, one per level
    float* resolution_factors;        // Resolution factor for each level
} multi_level_memory_t;

// Initialize multi-level memory
multi_level_memory_t* init_multi_level_memory(uint8_t levels) {
    multi_level_memory_t* mlm = malloc(sizeof(multi_level_memory_t));
    mlm->levels = levels;
    mlm->spaces = malloc(levels * sizeof(memory_space_t*));
    mlm->resolution_factors = malloc(levels * sizeof(float));
    
    // Initialize each level with decreasing resolution
    for (uint8_t i = 0; i < levels; i++) {
        // Resolution follows a geometric series based on PHI
        float resolution = pow(PHI, i);
        mlm->resolution_factors[i] = resolution;
        
        // Initialize memory space with appropriate resolution
        mlm->spaces[i] = init_memory_space(resolution);
    }
    
    return mlm;
}

// Store information with automatic level selection
void store_multi_level(multi_level_memory_t* mlm, 
                      embedding_t* semantic_vector,
                      void* content, uint32_t content_size,
                      detail_level_t detail) {
    // Determine appropriate level based on detail
    uint8_t level = detail_to_level(mlm, detail);
    
    // Store at selected level
    store_in_memory_space(mlm->spaces[level], 
                         semantic_vector, content, content_size);
    
    // If high detail, also store at adjacent levels with modifications
    if (detail == DETAIL_HIGH) {
        // Store at higher resolution level if available
        if (level > 0) {
            embedding_t* refined = refine_embedding(semantic_vector);
            store_in_memory_space(mlm->spaces[level-1], 
                                 refined, content, content_size);
            free_embedding(refined);
        }
        
        // Store at lower resolution level if available
        if (level < mlm->levels - 1) {
            embedding_t* abstracted = abstract_embedding(semantic_vector);
            store_in_memory_space(mlm->spaces[level+1], 
                                 abstracted, content, content_size);
            free_embedding(abstracted);
        }
    }
}

// Define semantic embedding structure
typedef struct {
    uint32_t dimension;         // Embedding dimension
    float* values;              // Vector values
    uint8_t* significance;      // Significance weights (0-255)
    context_t* context;         // Contextual information
    uint32_t version;           // Embedding format version
} embedding_t;

// Create semantic embedding from raw values
embedding_t* create_embedding(float* values, uint32_t dimension) {
    embedding_t* embedding = (embedding_t*)malloc(sizeof(embedding_t));
    
    // Set basic properties
    embedding->dimension = dimension;
    embedding->values = (float*)malloc(dimension * sizeof(float));
    embedding->significance = (uint8_t*)malloc(dimension * sizeof(uint8_t));
    
    // Copy vector values
    memcpy(embedding->values, values, dimension * sizeof(float));
    
    // Initialize significance weights (default to full significance)
    for (uint32_t i = 0; i < dimension; i++) {
        embedding->significance[i] = 255;
    }
    
    // Initialize context
    embedding->context = create_default_context();
    
    // Set version
    embedding->version = CURRENT_EMBEDDING_VERSION;
    
    // Normalize embedding
    normalize_embedding(embedding);
    
    return embedding;
}

// Calculate semantic similarity between embeddings
float calculate_similarity(embedding_t* a, embedding_t* b) {
    // Determine common dimension
    uint32_t dim = (a->dimension < b->dimension) ? a->dimension : b->dimension;
    
    float dot_product = 0.0f;
    float a_magnitude = 0.0f;
    float b_magnitude = 0.0f;
    float significance_sum = 0.0f;
    
    // Calculate weighted dot product and magnitudes
    for (uint32_t i = 0; i < dim; i++) {
        // Combined significance weighting
        float significance = (a->significance[i] * b->significance[i]) / 65025.0f;
        significance_sum += significance;
        
        // Weighted values
        float a_val = a->values[i] * significance;
        float b_val = b->values[i] * significance;
        
        // Accumulate dot product and magnitudes
        dot_product += a_val * b_val;
        a_magnitude += a_val * a_val;
        b_magnitude += b_val * b_val;
    }
    
    // Normalize by significance sum
    if (significance_sum > 0.0f) {
        dot_product /= significance_sum;
        a_magnitude /= significance_sum;
        b_magnitude /= significance_sum;
    }
    
    // Calculate cosine similarity
    a_magnitude = sqrt(a_magnitude);
    b_magnitude = sqrt(b_magnitude);
    
    if (a_magnitude > 0.0f && b_magnitude > 0.0f) {
        return dot_product / (a_magnitude * b_magnitude);
    } else {
        return 0.0f;
    }
}

// Combine embeddings with weighted addition
embedding_t* combine_embeddings(embedding_t** embeddings, 
                              float* weights, uint32_t count) {
    // Validate inputs
    if (count == 0 || embeddings == NULL || weights == NULL) {
        return NULL;
    }
    
    // Use the first embedding's dimension for the result
    uint32_t dimension = embeddings[0]->dimension;
    
    // Allocate result vector
    float* result_values = (float*)malloc(dimension * sizeof(float));
    memset(result_values, 0, dimension * sizeof(float));
    
    // Combine with weights
    float weight_sum = 0.0f;
    for (uint32_t i = 0; i < count; i++) {
        if (embeddings[i]->dimension != dimension) {
            // Skip incompatible embeddings
            continue;
        }
        
        weight_sum += weights[i];
        for (uint32_t j = 0; j < dimension; j++) {
            result_values[j] += embeddings[i]->values[j] * weights[i];
        }
    }
    
    // Normalize by weight sum
    if (weight_sum > 0.0f) {
        for (uint32_t j = 0; j < dimension; j++) {
            result_values[j] /= weight_sum;
        }
    }
    
    // Create new embedding
    embedding_t* result = create_embedding(result_values, dimension);
    
    // Set up combined context
    result->context = combine_contexts(embeddings, weights, count);
    
    // Free temporary resources
    free(result_values);
    
    return result;
}

// Create contrast embedding (representing differences)
embedding_t* contrast_embeddings(embedding_t* a, embedding_t* b, float contrast_factor) {
    // Validate inputs
    if (a == NULL || b == NULL || a->dimension != b->dimension) {
        return NULL;
    }
    
    uint32_t dimension = a->dimension;
    
    // Allocate result vector
    float* result_values = (float*)malloc(dimension * sizeof(float));
    
    // Calculate contrast
    for (uint32_t i = 0; i < dimension; i++) {
        // Weighted difference
        result_values[i] = (a->values[i] - b->values[i]) * contrast_factor;
    }
    
    // Create new embedding
    embedding_t* result = create_embedding(result_values, dimension);
    
    // Set up contrastive context
    result->context = create_contrast_context(a->context, b->context);
    
    // Free temporary resources
    free(result_values);
    
    return result;
}

// Define relationship types
typedef enum {
    RELATION_SIMILAR,      // Conceptually similar
    RELATION_OPPOSITE,     // Opposing concepts
    RELATION_PART_OF,      // Component relationship
    RELATION_CONTAINS,     // Containment relationship
    RELATION_CAUSES,       // Causal relationship
    RELATION_CAUSED_BY,    // Effect relationship
    RELATION_INSTANCE_OF,  // Type relationship
    RELATION_ASSOCIATED    // General association
} relation_type_t;

// Define relationship structure
typedef struct {
    memory_node_t* source;       // Source node
    memory_node_t* target;       // Target node
    relation_type_t type;        // Relationship type
    float strength;              // Relationship strength (0.0 - 1.0)
    context_t* context;          // When/why this relationship exists
} relationship_t;

// Create relationship between nodes
relationship_t* create_relationship(memory_node_t* source, 
                                  memory_node_t* target,
                                  relation_type_t type,
                                  float strength) {
    relationship_t* relation = (relationship_t*)malloc(sizeof(relationship_t));
    
    relation->source = source;
    relation->target = target;
    relation->type = type;
    relation->strength = strength;
    relation->context = create_default_context();
    
    // Add to relationship index
    add_to_relationship_index(relation);
    
    // Update node connections if they're neighbors
    hex_coord_t* neighbors = get_hex_neighbors(source->coordinates);
    for (int i = 0; i < 6; i++) {
        if (hex_equals(neighbors[i], target->coordinates)) {
            // Update neighbor connection strength based on relationship
            source->connections[i]->strength = calculate_connection_strength(
                relation->type, relation->strength);
            break;
        }
    }
    free(neighbors);
    
    return relation;
}

// Initialize NuMap system
NuMap* numap_init(numap_config_t* config) {
    NuMap* numap = (NuMap*)malloc(sizeof(NuMap));
    
    // Initialize based on configuration
    uint32_t dimension = config ? config->embedding_dimension : DEFAULT_DIMENSION;
    uint8_t levels = config ? config->resolution_levels : DEFAULT_LEVELS;
    
    // Set up memory system
    numap->memory = init_multi_level_memory(levels);
    
    // Initialize embedding system
    numap->embedding_dimension = dimension;
    numap->embedding_system = init_embedding_system(dimension);
    
    // Initialize indices for fast retrieval
    numap->semantic_index = init_semantic_index();
    numap->spatial_index = init_spatial_index();
    numap->relationship_index = init_relationship_index();
    
    // Set up hexagonal grid system
    numap->grid = init_hexagonal_grid();
    
    return numap;
}

// Store information in NuMap
memory_node_t* numap_store(NuMap* numap, 
                         float* vector_values, 
                         void* content, uint32_t content_size,
                         detail_level_t detail) {
    // Create semantic embedding
    embedding_t* embedding = create_embedding(vector_values, numap->embedding_dimension);
    
    // Find optimal location in hex grid
    hex_coord_t location = find_optimal_location(numap, embedding);
    
    // Create memory node
    memory_node_t* node = create_memory_node(location, embedding, content, content_size);
    
    // Store in multi-level memory
    store_multi_level(numap->memory, embedding, content, content_size, detail);
    
    // Update indices
    add_to_semantic_index(numap->semantic_index, node);
    add_to_spatial_index(numap->spatial_index, node);
    
    // Create relationships with nearby nodes
    create_proximity_relationships(numap, node);
    
    return node;
}

// Retrieve information by semantic similarity
memory_node_t* numap_retrieve(NuMap* numap, float* query_vector, float threshold) {
    // Create query embedding
    embedding_t* query = create_embedding(query_vector, numap->embedding_dimension);
    
    // Search semantic index
    memory_node_t* result = find_most_similar(numap->semantic_index, query, threshold);
    
    // Clean up query
    free_embedding(query);
    
    return result;
}

// Find related concepts
memory_node_t** numap_find_related(NuMap* numap, 
                                 memory_node_t* node,
                                 relation_type_t relation_type,
                                 uint32_t max_results) {
    // Find relationships of specified type
    relationship_t** relations = find_relationships_by_type(
        numap->relationship_index, node, relation_type);
    
    // Count relationships
    uint32_t count = 0;
    while (relations[count] != NULL && count < max_results) {
        count++;
    }
    
    // Create result array
    memory_node_t** results = (memory_node_t**)malloc((count + 1) * sizeof(memory_node_t*));
    
    // Fill result array
    for (uint32_t i = 0; i < count; i++) {
        results[i] = relations[i]->target;
    }
    results[count] = NULL;  // Null-terminate
    
    // Free relationship array (but not the relationships themselves)
    free(relations);
    
    return results;
}

// Example: Convert between coordinate systems
void coordinate_system_examples() {
    // Create axial coordinates
    hex_coord_t axial_coord = {3, 2};  // q=3, r=2
    
    // Calculate s for cubic coordinates
    int s = -axial_coord.q - axial_coord.r;  // s = -3 - 2 = -5
    printf("Cubic coordinates: (%d, %d, %d)\n", axial_coord.q, axial_coord.r, s);
    
    // Convert to offset coordinates (odd-r)
    int col = axial_coord.q;
    int row = axial_coord.r + (axial_coord.q - (axial_coord.q & 1)) / 2;
    printf("Offset coordinates (odd-r): (%d, %d)\n", col, row);
    
    // Convert to pixel coordinates
    float size = 10.0f;  // Hex size in pixels
    float x = size * sqrt(3) * (axial_coord.q + axial_coord.r / 2.0f);
    float y = size * 3.0f/2.0f * axial_coord.r;
    printf("Pixel coordinates: (%.1f, %.1f)\n", x, y);
    
    // Calculate distance between two hexes
    hex_coord_t coord1 = {3, 2};
    hex_coord_t coord2 = {7, 1};
    int distance = hex_distance(coord1, coord2);
    printf("Distance between hexes: %d\n", distance);
    
    // Get neighbors
    hex_coord_t* neighbors = get_hex_neighbors(axial_coord);
    printf("Neighbors of (%d, %d):\n", axial_coord.q, axial_coord.r);
    for (int i = 0; i < 6; i++) {
        printf("  (%d, %d)\n", neighbors[i].q, neighbors[i].r);
    }
    free(neighbors);
}

// Optimize NuMap performance
void optimize_numap_performance(NuMap* numap) {
    // Configure optimal embedding dimension
    numap->embedding_dimension = 256;  // Balance between expressiveness and efficiency
    
    // Configure resolution levels
    numap->memory->levels = 4;  // 4 levels of resolution
    
    // Enable semantic index optimizations
    enable_semantic_index_optimizations(numap->semantic_index);
    
    // Enable spatial index partitioning
    enable_spatial_partitioning(numap->spatial_index, 16);  // 16 partitions
    
    // Configure retrieval cache
    numap->cache_size = 1024;  // Cache last 1024 retrievals
    numap->retrieval_cache = create_retrieval_cache(numap->cache_size);
    
    // Enable batch operations
    numap->enable_batching = true;
    numap->batch_size = 64;  // Process up to 64 operations in a batch
    
    // Initialize optimization subsystem
    init_optimization_subsystem(numap);
}

// Integrate NuMap with Aurora
void integrate_with_aurora(NuMap* numap, Aurora* aurora) {
    // Connect NuMap as Aurora's memory system
    aurora->memory_system = createNuMapAdapter(numap);
    
    // Map Aurora's semantic network to NuMap
    mapAuroraSemanticToNuMap(aurora->semantic_network, numap);
    
    // Configure state vector embedding for NuMap storage
    configureEmbeddingFormat(aurora, numap->embedding_format);
    
    // Set up continuity preservation in NuMap storage
    configureSamadhiStorageInNuMap(aurora->samadhi, numap);
    
    // Initialize shared memory spaces
    initSharedMemorySpaces(aurora, numap);
}

// Integrate NuMap with NESH
void integrate_with_nesh(NuMap* numap, NESH* nesh) {
    // Connect NuMap's hexagonal grid to NESH's waveform memory
    map_hex_grid_to_waveform(numap->grid, nesh->waveform_space);
    
    // Set up memory transfer protocols
    setup_memory_transfer(numap, nesh);
    
    // Create shared embedding space
    create_shared_embedding_space(numap->embedding_system, nesh->embedding_system);
    
    // Configure resonance patterns
    configure_resonance_patterns(numap, nesh);
    
    // Initialize hierarchical memory architecture
    init_hierarchical_memory(numap, nesh);
}

// Integrate NuMap with GeoMath
void integrate_with_geomath(NuMap* numap, GeoMath* gm) {
    // Connect NuMap's hexagonal grid to GeoMath's √3-based transformations
    numap->grid->transform = gm->transform_hexagonal;
    
    // Set up coordinate transformations
    setup_coordinate_transformations(numap, gm);
    
    // Configure harmonic resonance
    configure_harmonic_resonance(numap, gm);
    
    // Initialize geometric operations
    init_geometric_operations(numap, gm);
}

#include "numap.h"

int main() {
    // Initialize NuMap with default configuration
    NuMap* numap = numap_init(NULL);
    
    printf("Initialized NuMap Memory System\n");
    
    // Create a simple semantic vector
    float vector1[256] = {0};
    vector1[0] = 1.0f;
    vector1[10] = 0.5f;
    vector1[20] = 0.7f;
    
    // Store content in NuMap
    char* content1 = "This is a test memory node";
    memory_node_t* node1 = numap_store(numap, vector1, content1, strlen(content1) + 1, DETAIL_MEDIUM);
    
    printf("Stored memory node at coordinates (%d, %d)\n", 
           node1->coordinates.q, node1->coordinates.r);
    
    // Create another semantic vector
    float vector2[256] = {0};
    vector2[0] = 0.9f;
    vector2[10] = 0.6f;
    vector2[20] = 0.8f;
    
    // Store second content in NuMap
    char* content2 = "This is a related memory node";
    memory_node_t* node2 = numap_store(numap, vector2, content2, strlen(content2) + 1, DETAIL_MEDIUM);
    
    printf("Stored second memory node at coordinates (%d, %d)\n", 
           node2->coordinates.q, node2->coordinates.r);
    
    // Create relationship between nodes
    relationship_t* rel = create_relationship(node1, node2, RELATION_SIMILAR, 0.85f);
    
    printf("Created relationship with strength %.2f\n", rel->strength);
    
    // Retrieve using a query vector
    float query[256] = {0};
    query[0] = 0.95f;
    query[10] = 0.55f;
    query[20] = 0.75f;
    
    memory_node_t* result = numap_retrieve(numap, query, 0.7f);
    
    if (result) {
        printf("Retrieved: %s\n", (char*)result->content);
    } else {
        printf("No matching node found\n");
    }
    
    // Clean up resources
    numap_free(numap);
    
    return 0;
}

// Demonstrate hexagonal grid navigation
void demonstrate_hex_navigation() {
    // Initialize NuMap
    NuMap* numap = numap_init(NULL);
    
    printf("Initialized NuMap for hex navigation\n");
    
    // Create several test nodes in a pattern
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            // Create semantic vector
            float* vector = create_test_vector(i, j);
            
            // Create content
            char content[100];
            sprintf(content, "Node at position (%d, %d)", i, j);
            
            // Store node
            memory_node_t* node = numap_store(numap, vector, 
                                            strdup(content), strlen(content) + 1, 
                                            DETAIL_MEDIUM);
            
            printf("Created node at coordinates (%d, %d)\n", 
                   node->coordinates.q, node->coordinates.r);
            
            free(vector);
        }
    }
    
    // Select a node to navigate from
    hex_coord_t start = {2, 2};
    memory_node_t* start_node = numap_get_node_at(numap, start);
    
    printf("\nStarting navigation from (%d, %d)\n", start.q, start.r);
    
    // Navigate in each of the six directions
    hex_coord_t* neighbors = get_hex_neighbors(start);
    
    for (int i = 0; i < 6; i++) {
        memory_node_t* neighbor = numap_get_node_at(numap, neighbors[i]);
        
        if (neighbor) {
            printf("Direction %d -> Node: %s\n", i, (char*)neighbor->content);
            printf("  Connection strength: %.2f\n", 
                   start_node->connections[i]->strength);
        } else {
            printf("Direction %d -> No node found\n", i);
        }
    }
    
    // Calculate a path through the hex grid
    hex_coord_t end = {4, 4};
    hex_coord_t* path = calculate_hex_path(numap, start, end);
    
    printf("\nPath from (%d, %d) to (%d, %d):\n", start.q, start.r, end.q, end.r);
    
    int step = 0;
    while (path[step].q != -1 && path[step].r != -1) {
        memory_node_t* path_node = numap_get_node_at(numap, path[step]);
        printf("Step %d: (%d, %d) - %s\n", 
               step, path[step].q, path[step].r, 
               path_node ? (char*)path_node->content : "Empty");
        step++;
    }
    
    // Free resources
    free(neighbors);
    free(path);
    numap_free(numap);
}

// Demonstrate semantic embedding operations
void demonstrate_semantic_operations() {
    // Initialize NuMap
    NuMap* numap = numap_init(NULL);
    
    printf("Initialized NuMap for semantic operations\n");
    
    // Create base concept embeddings
    float* cat_vector = create_concept_vector("cat");
    float* dog_vector = create_concept_vector("dog");
    float* pet_vector = create_concept_vector("pet");
    
    // Store base concepts
    memory_node_t* cat_node = numap_store(numap, cat_vector, "Cat", 4, DETAIL_HIGH);
    memory_node_t* dog_node = numap_store(numap, dog_vector, "Dog", 4, DETAIL_HIGH);
    memory_node_t* pet_node = numap_store(numap, pet_vector, "Pet", 4, DETAIL_HIGH);
    
    printf("Stored base concepts\n");
    
    // Create relationships
    create_relationship(cat_node, pet_node, RELATION_INSTANCE_OF, 0.9f);
    create_relationship(dog_node, pet_node, RELATION_INSTANCE_OF, 0.9f);
    
    printf("Created instance relationships\n");
    
    // Combine concepts to create a new concept
    embedding_t* cat_embedding = cat_node->semantic_vector;
    embedding_t* dog_embedding = dog_node->semantic_vector;
    
    float weights[2] = {0.5f, 0.5f};
    embedding_t* embeddings[2] = {cat_embedding, dog_embedding};
    
    embedding_t* combined = combine_embeddings(embeddings, weights, 2);
    
    // Store combined concept
    memory_node_t* combined_node = numap_store_embedding(numap, combined, 
                                                      "Cat and Dog", 12, 
                                                      DETAIL_MEDIUM);
    
    printf("Created combined concept at coordinates (%d, %d)\n", 
           combined_node->coordinates.q, combined_node->coordinates.r);
    
    // Create contrast concept
    embedding_t* contrast = contrast_embeddings(cat_embedding, dog_embedding, 1.0f);
    
    // Store contrast concept
    memory_node_t* contrast_node = numap_store_embedding(numap, contrast, 
                                                      "Cat vs Dog", 10, 
                                                      DETAIL_MEDIUM);
    
    printf("Created contrast concept at coordinates (%d, %d)\n", 
           contrast_node->coordinates.q, contrast_node->coordinates.r);
    
    // Find related concepts
    printf("\nConcepts related to Pet:\n");
    memory_node_t** related = numap_find_related(numap, pet_node, 
                                              RELATION_INSTANCE_OF, 10);
    
    int i = 0;
    while (related[i] != NULL) {
        printf("  %s\n", (char*)related[i]->content);
        i++;
    }
    
    // Free resources
    free(cat_vector);
    free(dog_vector);
    free(pet_vector);
    free(related);
    free_embedding(combined);
    free_embedding(contrast);
    numap_free(numap);
}