#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 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"
};

// Variables for PCA, GNN, and signals
vars volatilities[PAIRS];                   // Current volatilities
vars volChangeRate[PAIRS];                  // Volatility change rate
vars kernelMatrix[PAIRS][PAIRS];            // Kernel matrix for PCA
vars pcaReducedFeatures[PAIRS][COMPONENTS]; // PCA-reduced features
vars adjacencyMatrices[PAIRS][PAIRS];       // GNN adjacency matrices
vars gnnWeights[GNN_LAYERS][COMPONENTS][COMPONENTS]; // GNN weights
vars gnnOutputs[PAIRS][ACTIONS];            // GNN probabilities (Buy/Sell/Hold)
vars signals[PAIRS];                        // Final trading signals
vars eigenvalues[COMPONENTS];               // Eigenvalues from PCA

// Step 1: Calculate Volatility and Change Rate
function calculateVolatility() {
    for (int i = 0; i < PAIRS; i++) {
        asset(CurrencyPairs[i]);
        vars logReturns = series(priceClose(0) / priceClose(1) - 1); // Log returns
        volatilities[i] = sqrt(SMA(pow(logReturns, 2), 20));        // 20-bar rolling std dev
        volChangeRate[i] = volatilities[i] - volatilities[i+1];     // Change rate
    }
}

// Step 2: Perform Kernel PCA
function performKernelPCA() {
    // Construct Kernel Matrix
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            kernelMatrix[i][j] = exp(-pow(volatilities[i] - volatilities[j], 2) / (2 * 0.1 * 0.1)); // Gaussian kernel
        }
    }

    // Perform eigen decomposition (simplified example)
    vars eigenvectors;
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
    
    // Reduce dimensions using top COMPONENTS
    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];
            }
        }
    }
    // Final probabilities for Buy, Sell, Hold
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            gnnOutputs[i][k] = softmax(tempFeatures[i][k]); // Example output
        }
    }
}

// Step 5: Generate Trading Signals with PCA and GNN Thresholds
function generateSignals() {
    // Calculate PCA Variance Contribution
    var totalVariance = 0;
    for (int k = 0; k < COMPONENTS; k++) {
        totalVariance += eigenvalues[k];
    }
    var pcaContribution = eigenvalues[0] / totalVariance; // Contribution of the top component

    // Calculate GNN Entropy for each pair
    vars gnnEntropy[PAIRS];
    for (int i = 0; i < PAIRS; i++) {
        gnnEntropy[i] = 0;
        for (int k = 0; k < ACTIONS; k++) {
            gnnEntropy[i] -= gnnOutputs[i][k] * log(gnnOutputs[i][k] + 1e-8);
        }
    }

    // Calculate Dynamic Thresholds with PCA and GNN
    vars dynamicThresholdBuy[PAIRS];
    vars dynamicThresholdSell[PAIRS];
    for (int i = 0; i < PAIRS; i++) {
        var meanVolChangeRate = SMA(volChangeRate, PAIRS);
        var stddevVolChangeRate = StdDev(volChangeRate, PAIRS);

        // Adjust thresholds with PCA and GNN contributions
        dynamicThresholdBuy[i] = meanVolChangeRate + 0.5 * stddevVolChangeRate * pcaContribution * (1 - gnnEntropy[i]);
        dynamicThresholdSell[i] = meanVolChangeRate - 0.5 * stddevVolChangeRate * pcaContribution * (1 - gnnEntropy[i]);
    }

    // Generate Trading Signals
    for (int i = 0; i < PAIRS; i++) {
        var gnnBuyProb = gnnOutputs[i][0];
        var gnnSellProb = gnnOutputs[i][1];

        signals[i] = gnnBuyProb - gnnSellProb; // Base signal

        // Incorporate dynamic thresholds
        if (signals[i] > dynamicThresholdBuy[i]) signals[i] = 1; // Strong Buy
        else if (signals[i] < dynamicThresholdSell[i]) signals[i] = -1; // Strong Sell
        else signals[i] = 0; // Hold
    }
}

// Step 6: Execute Trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] == 1) enterLong(CurrencyPairs[i]); // Strong Buy
        else if (signals[i] == -1) enterShort(CurrencyPairs[i]); // Strong Sell
    }
}

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

    // Calculate volatility and change rate
    calculateVolatility();

    // Perform kernel PCA
    performKernelPCA();

    // Initialize GNN weights (once)
    if (is(INITRUN)) initializeGNNWeights();

    // Propagate GNN
    propagateGNN();

    // Generate signals
    generateSignals();

    // Execute trades
    executeTrades();
}