import puppeteer from 'puppeteer-core';
import { URLSearchParams } from 'url';
import 'dotenv/config';

class DexScreenerParser {
    private readonly baseUri: string = 'wss://io.dexscreener.com/dex/screener/v4/pairs/h24/1';
    private readonly params: URLSearchParams = new URLSearchParams({
        'rankBy[key]': 'trendingScoreH6',
        'rankBy[order]': 'desc',
        'filters[chainIds][0]': 'solana',
    });

    async startMainLoop(): Promise<void> {
        console.log('Starting DexScreener parser...');
        const connectionURL = `wss://browser.zenrows.com?apikey=${process.env.ZENROWS_API_KEY}`;
        const targetWsUrl = `${this.baseUri}?${this.params.toString()}`;

        const browser = await puppeteer.connect({
            browserWSEndpoint: connectionURL,
            defaultViewport: null
        });

        try {
            const page = await browser.newPage();
            console.log('Browser page created');

            // Expose functions for WebSocket communication
            await page.exposeFunction('onWebSocketData', (data: any, isBinary: boolean) => {
                if (isBinary) {
                    const binaryData = Buffer.from(data, 'base64');
                    console.log('Binary WebSocket data received:', binaryData);

                    if (binaryData[0] === 0x00) {
                        console.log('Received binary message type 0');
                    }
                } else {
                    console.log('Text WebSocket data received:', data);
                }
            });

            await page.exposeFunction('onWebSocketOpen', () => {
                console.log('WebSocket connection opened');
            });

            await page.exposeFunction('onWebSocketError', (error: any) => {
                console.error('WebSocket error:', error);
            });

            // Navigate to DexScreener first
            await page.goto('https://dexscreener.com', {
                waitUntil: 'networkidle0',
                timeout: 60000
            });
            console.log('Navigation complete');

            // Create WebSocket connection using page's context
            const wsResult = await page.evaluate(async (wsUrl) => {
                try {
                    const ws = new WebSocket(wsUrl);

                    ws.onopen = () => {
                        console.log('WebSocket opened in browser');
                        (window as any).onWebSocketOpen();
                    };

                    ws.onmessage = (event) => {
                        console.log('WebSocket message received in browser');
                        if (event.data instanceof Blob) {
                            const reader = new FileReader();
                            reader.onload = () => {
                                const base64 = (reader.result as string).split(',')[1];
                                (window as any).onWebSocketData(base64, true);
                            };
                            reader.readAsDataURL(event.data);
                        } else {
                            (window as any).onWebSocketData(event.data, false);
                        }
                    };

                    ws.onerror = (error) => {
                        console.error('WebSocket error in browser:', error);
                        (window as any).onWebSocketError(error);
                    };

                    ws.onclose = (event) => {
                        console.log('WebSocket closed in browser:', event.code, event.reason);
                    };

                    (window as any).ws = ws;
                    return 'WebSocket initialized';
                } catch (error: unknown) {
                    if (error instanceof Error) {
                        return `Error: ${error.message}`;
                    }
                    return `Error: ${String(error)}`;
                }
            }, targetWsUrl);

            console.log('WebSocket setup result:', wsResult);

            return new Promise<void>((resolve) => {
                process.on('SIGINT', async () => {
                    await browser.close();
                    resolve();
                });
            });

        } catch (error) {
            console.error('Error:', error);
            await browser.close();
            throw error;
        }
    }
}

console.log('Initializing parser...');
const parser = new DexScreenerParser();
parser.startMainLoop().catch(console.error);