const axios = require('axios');
const { Web3 } = require('web3');
const fs = require('fs');
require('dotenv').config();

// Constants
const CHAINSTACK_API_KEY = process.env.CHAINSTACK_API_KEY;
const OUTPUT_FILE_NAME = 'rpc.env';

// Fetch data from Chainstack API
async function fetchChainstackData(apiKey) {
    const url = "https://api.chainstack.com/v1/nodes/";
    const headers = {
        "accept": "application/json",
        "authorization": `Bearer ${apiKey}`
    };

    try {
        const response = await axios.get(url, { headers });
        console.log(`Fetched ${response.data.results.length} items from Chainstack.`);
        return response.data;
    } catch (error) {
        console.error(`Failed to fetch data from Chainstack: ${error}`);
        return null;
    }
}

// Process a single item from Chainstack data
function processChainstackItem(item) {
    console.debug(`Processing item: ${item.name} with ID ${item.id}`);
    return {
        id: item.id,
        name: item.name,
        details: item.details,
        http_endpoint: item.details.https_endpoint,
        auth_key: item.details.auth_key,
        configuration: item.configuration,
        client: item.configuration.client
    };
}

// Connect to a Web3 endpoint
async function connectToWeb3(reconstructedEndpoint) {
    console.debug(`Attempting to connect to Web3 endpoint: ${reconstructedEndpoint}`);
    try {
        const web3 = new Web3(new Web3.providers.HttpProvider(reconstructedEndpoint));
        const chainId = await web3.eth.getChainId();
        console.info(`Connected to ${reconstructedEndpoint} with chain ID: ${chainId}`);
        return true;
    } catch (error) {
        console.error(`Failed to connect to ${reconstructedEndpoint}: ${error}`);
        return false;
    }
}


// Sanitize the endpoint name for use as an environment variable key
function sanitizeName(name) {
    return name.replace(/\s|-|\//g, "_").toUpperCase();
}

// Create a .env file from the endpoint info dictionary
function createEnvFile(endpointInfoDict, filename = OUTPUT_FILE_NAME) {
    console.info(`Preparing to write ${Object.keys(endpointInfoDict).length} endpoints to .env file.`);
    const lines = Object.entries(endpointInfoDict).map(([endpoint, info]) => {
        const sanitized_name = sanitizeName(info.name);
        return `${sanitized_name}_URL="${endpoint}"\n`;
    });

    fs.writeFileSync(filename, lines.join(''));
    console.info(`.env file created successfully at ${filename}`);
}

// Main function to orchestrate the process
async function main() {
    console.info("Starting main process.");
    if (!CHAINSTACK_API_KEY) {
        console.error("Chainstack API key not found.");
        return;
    }

    const json_data = await fetchChainstackData(CHAINSTACK_API_KEY);
    if (!json_data) {
        return;
    }

    const endpointInfoDict = {};
    for (const item of json_data.results) {
        const data = processChainstackItem(item);
        const reconstructedEndpoint = `${data.http_endpoint}/${data.auth_key}`;
        if (await connectToWeb3(reconstructedEndpoint)) {
            endpointInfoDict[reconstructedEndpoint] = { name: data.name };
        }
    }

    if (Object.keys(endpointInfoDict).length > 0) {
        createEnvFile(endpointInfoDict);
    } else {
        console.info("No endpoint information to write to .env file.");
    }
    console.info("Main process completed.");
}

// Run the main function
main();