#define PAIRS 28
#define COMPONENTS 3     // Number of PCA components
#define GNN_LAYERS 2     // Number of GNN layers
#define ACTIONS 3        // Buy, Sell, Hold
#define LOOKBACK 100     // Lookback period for volatility calculation
#define VOL_KERNEL_WIDTH 0.5 // Width for Gaussian kernel
#define SIMILARITY_ALPHA 0.1 // Smoothing factor for similarity updates

// Declare currency pairs
string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

// Global Variables
vars kernelMatrix[PAIRS][PAIRS];            // Kernel matrix for PCA
vars pcaReducedFeatures[PAIRS][COMPONENTS]; // PCA-reduced features for each pair
vars adjacencyMatrices[PAIRS][PAIRS];       // Adjacency matrices for GNNs
vars gnnWeights[GNN_LAYERS][COMPONENTS][COMPONENTS]; // GNN weights
vars gnnOutputs[PAIRS][ACTIONS];            // GNN probabilities for Buy/Sell/Hold
vars similarityMatrix[PAIRS][PAIRS];        // Cross-Entropy similarity matrix
vars refinedOutputs[PAIRS][ACTIONS];        // Refined GNN probabilities
vars signals[PAIRS];                        // Final trading signals

// Utility Function: Calculate Rolling Volatility
function calcVolatility(string pair) {
    asset(pair);
    vars returns = series(log(priceClose() / priceClose(1)));
    return StdDev(returns, LOOKBACK);
}

// Step 1: Compute Kernel Matrix
function computeKernelMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            vars sigma_i = series(calcVolatility(CurrencyPairs[i]));
            vars sigma_j = series(calcVolatility(CurrencyPairs[j]));
            vars volatilitySpread = series(abs(sigma_i[0] - sigma_j[0]));
            kernelMatrix[i][j] = exp(-volatilitySpread[0]^2 / (2 * VOL_KERNEL_WIDTH^2));
        }
    }
}

// Step 2: Perform Enhanced PCA
function performEnhancedPCA() {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < COMPONENTS; j++) {
            pcaReducedFeatures[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 3: Initialize GNN Weights
function initializeGNNWeights() {
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < COMPONENTS; i++) {
            for (int j = 0; j < COMPONENTS; j++) {
                gnnWeights[l][i][j] = random() * 0.1; // Small random initialization
            }
        }
    }
}

// Step 4: GNN Propagation
function propagateGNN() {
    vars tempFeatures[PAIRS][COMPONENTS];
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                tempFeatures[i][k] = 0;
                for (int j = 0; j < PAIRS; j++) {
                    for (int m = 0; m < COMPONENTS; m++) {
                        tempFeatures[i][k] += adjacencyMatrices[i][j] * pcaReducedFeatures[j][m] * gnnWeights[l][m][k];
                    }
                }
                tempFeatures[i][k] = max(0, tempFeatures[i][k]); // ReLU activation
            }
        }
        // Update PCA features for the next layer
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                pcaReducedFeatures[i][k] = tempFeatures[i][k];
            }
        }
    }
    // Generate probabilities (Buy/Sell/Hold) based on final GNN outputs
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            gnnOutputs[i][k] = random() * 0.1; // Placeholder for GNN probability outputs
        }
    }
}

// Step 5: Compute Cross-Entropy Similarity
function computeCrossEntropySimilarity() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            similarityMatrix[i][j] = 0;
            for (int k = 0; k < ACTIONS; k++) {
                similarityMatrix[i][j] -= gnnOutputs[i][k] * log(gnnOutputs[j][k] + 1e-8);
            }
        }
    }
}

// Step 6: Refine GNN Outputs Using Similarity
function refineGNNOutputs() {
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            refinedOutputs[i][k] = 0;
            double weightSum = 0;
            for (int j = 0; j < PAIRS; j++) {
                refinedOutputs[i][k] += similarityMatrix[i][j] * gnnOutputs[j][k];
                weightSum += similarityMatrix[i][j];
            }
            refinedOutputs[i][k] /= (weightSum + 1e-8); // Normalize
        }
    }
}

// Step 7: Generate Trading Signals
function generateSignals() {
    for (int i = 0; i < PAIRS; i++) {
        signals[i] = refinedOutputs[i][0] - refinedOutputs[i][1]; // Buy-Sell difference
    }
}

// Step 8: Execute Trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] > 0) enterLong(CurrencyPairs[i]);
        else if (signals[i] < 0) enterShort(CurrencyPairs[i]);
    }
}

// Main Function
function run() {
    set(PLOTNOW);

    // Step 1: Compute Kernel Matrix
    computeKernelMatrix();

    // Step 2: Perform Enhanced PCA
    performEnhancedPCA();

    // Step 3: Initialize GNN weights
    initializeGNNWeights();

    // Step 4: Propagate GNN
    propagateGNN();

    // Step 5: Compute Cross-Entropy Similarity
    computeCrossEntropySimilarity();

    // Step 6: Refine GNN outputs
    refineGNNOutputs();

    // Step 7: Generate trading signals
    generateSignals();

    // Step 8: Execute trades
    executeTrades();
}