#define PAIRS 28 // Number of 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"
};

vars kernelMatrix[PAIRS][PAIRS];     // Kernel matrix for Kernel PCA
vars ReducedMatrix[PAIRS][PAIRS];    // Reduced matrix for principal components
vars Thresholds[PAIRS];              // Neural network predicted thresholds
vars smoothedSignals[PAIRS];         // Smoothed signals for risk control
vars Predictions[PAIRS];             // Neural network predictions
vars volatilities[PAIRS];            // Volatility for each pair
vars eigenvalues[PAIRS];             // Eigenvalues from PCA
vars eigenvectors[PAIRS][PAIRS];     // Eigenvectors from PCA
int lookback = 50;                   // Lookback period for volatility calculation
int NeuralModelThreshold;            // Handle for neural network predicting thresholds
int NeuralModelSigma;                // Handle for neural network predicting kernel width

var sigma = 0.5;                     // Default kernel width parameter
var dynamicThreshold;                // Dynamic trading threshold

// Function to calculate volatilities for all pairs
function calculateVolatilities() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i]), lookback));
    }
}

// Function to calculate the kernel matrix using a Gaussian kernel
function calculateKernelMatrix(vars volatilities[PAIRS], vars kernelMatrix[PAIRS][PAIRS], var sigma) {
    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 * pow(sigma, 2))); // Gaussian kernel
        }
    }
}

// Perform Kernel PCA: Decompose the kernel matrix into eigenvalues and eigenvectors
function performKernelPCA(vars kernelMatrix[PAIRS][PAIRS], vars eigenvalues, vars eigenvectors) {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors); // Decompose the kernel matrix
}

// Reduce data using the top principal components
function reduceKernelData(vars kernelMatrix[PAIRS][PAIRS], vars eigenvectors[PAIRS][PAIRS], vars ReducedMatrix[PAIRS][PAIRS], int numComponents) {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < numComponents; j++) {
            ReducedMatrix[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Neural network training function for dynamic threshold prediction
function trainNeuralNetworks() {
    // Train for thresholds
    LayerPerceptron(10); // 10 nodes in hidden layer
    LayerNormalize();
    LayerPerceptron(1);  // Output layer for threshold prediction
    NeuralModelThreshold = Train(
        "threshold_model", // Model name
        Features,          // Input features (kernel matrix and volatilities)
        Targets,           // Target outputs (thresholds from historical data)
        NumSamples         // Number of samples
    );

    // Train for sigma adjustment
    LayerPerceptron(10); // 10 nodes in hidden layer
    LayerNormalize();
    LayerPerceptron(1);  // Output layer for kernel width (sigma) prediction
    NeuralModelSigma = Train(
        "sigma_model",    // Model name
        Features,         // Input features (historical volatilities and returns)
        Targets,          // Target outputs (optimal sigma values)
        NumSamples        // Number of samples
    );
}

// Predict dynamic thresholds using the neural network
function predictThresholds(vars kernelMatrix[PAIRS][PAIRS], vars Thresholds[PAIRS]) {
    for (int i = 0; i < PAIRS; i++) {
        Thresholds[i] = Predict(NeuralModelThreshold, kernelMatrix[i]); // Predict for each row in kernel matrix
    }
}

// Predict dynamic sigma using the neural network
function predictSigma(vars volatilities[PAIRS]) {
    return Predict(NeuralModelSigma, volatilities); // Predict sigma dynamically
}

// Calculate a dynamic threshold based on reduced signals
function calculateDynamicThreshold(int topComponents) {
    var sumSquares = 0;
    int count = 0;

    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < topComponents; j++) {
            sumSquares += ReducedMatrix[i][j] * ReducedMatrix[i][j];
            count++;
        }
    }
    return sqrt(sumSquares / count); // Standard deviation as threshold
}

// Smooth signals to reduce noise
function smoothSignals(vars Predictions[PAIRS], vars smoothedSignals[PAIRS]) {
    for (int i = 0; i < PAIRS; i++) {
        smoothedSignals[i] = SMA(series(Predictions[i]), lookback);
    }
}

// Trade logic with neural network-predicted thresholds
function tradeWithNeuralNetwork(vars smoothedSignals[PAIRS], vars Thresholds[PAIRS]) {
    for (int i = 0; i < PAIRS; i++) {
        if (smoothedSignals[i] > Thresholds[i]) {
            enterLong(CurrencyPairs[i]);
        } else if (smoothedSignals[i] < -Thresholds[i]) {
            enterShort(CurrencyPairs[i]);
        }
    }
}

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

    // Step 1: Calculate volatilities
    calculateVolatilities();

    // Step 2: Predict sigma using the neural network
    sigma = predictSigma(volatilities);

    // Step 3: Compute kernel matrix
    calculateKernelMatrix(volatilities, kernelMatrix, sigma);

    // Step 4: Perform Kernel PCA
    performKernelPCA(kernelMatrix, eigenvalues, eigenvectors);

    // Step 5: Optimize the number of components based on variance explained
    int optimalComponents = optimizeComponents(eigenvalues, PAIRS, 0.90);

    // Step 6: Reduce data using the top principal components
    reduceKernelData(kernelMatrix, eigenvectors, ReducedMatrix, optimalComponents);

    // Step 7: Predict thresholds using the neural network
    predictThresholds(kernelMatrix, Thresholds);

    // Step 8: Generate predictions (e.g., signal strength)
    for (int i = 0; i < PAIRS; i++) {
        Predictions[i] = dotProduct(kernelMatrix[i], Thresholds);
    }

    // Step 9: Smooth predictions for stable signals
    smoothSignals(Predictions, smoothedSignals);

    // Step 10: Execute trades based on predictions and thresholds
    tradeWithNeuralNetwork(smoothedSignals, Thresholds);
}