const express = require('express');
const http = require('http');
const WebSocket = require('ws');
const cors = require('cors');
const path = require('path');

const app = express();

app.use(cors());

app.use(
    express.static(
        path.join(__dirname, 'public')
    )
);

const server = http.createServer(app);

const wss = new WebSocket.Server({
    server
});

const PORT = process.env.PORT || 3000;

const coins = [

    'BTCUSDT',
    'ETHUSDT',
    'SOLUSDT',
    'XRPUSDT',
    'DOGEUSDT',
    'TRXUSDT',
    'LINKUSDT',
    'LTCUSDT',
    'AVAXUSDT',
    'BCHUSDT'
];

const market = {};

function initMarket(){

    coins.forEach(symbol=>{

        market[symbol] = {

            BINANCE : {

                ask : 0,
                bid : 0
            },

            BYBIT : {

                ask : 0,
                bid : 0
            }
        };
    });
}

initMarket();

function connectBinance(){

    const streams =

    coins
    .map(
        c =>
        `${c.toLowerCase()}@bookTicker`
    )
    .join('/');

    const url =

    `wss://stream.binance.com:9443/stream?streams=${streams}`;

    const ws =
    new WebSocket(url);

    ws.on('open',()=>{

        console.log(
            'BINANCE CONNECTED'
        );
    });

    ws.on('message',(msg)=>{

        try{

            const json =
            JSON.parse(msg);

            if(!json.data){
                return;
            }

            const data =
            json.data;

            const symbol =
            data.s;

            if(!market[symbol]){
                return;
            }

            market[symbol]
            .BINANCE = {

                ask :
                parseFloat(
                    data.a || 0
                ),

                bid :
                parseFloat(
                    data.b || 0
                )
            };

        }catch(err){

            console.log(
                'BINANCE ERROR',
                err.message
            );
        }
    });

    ws.on('close',()=>{

        console.log(
            'BINANCE RECONNECT'
        );

        setTimeout(
            connectBinance,
            3000
        );
    });

    ws.on('error',(err)=>{

        console.log(
            'BINANCE WS ERROR',
            err.message
        );
    });
}

function connectBybit(){

    const ws =
    new WebSocket(
        'wss://stream.bybit.com/v5/public/spot'
    );

    ws.on('open',()=>{

        console.log(
            'BYBIT CONNECTED'
        );

        ws.send(
            JSON.stringify({

                op : 'subscribe',

                args :

                coins.map(
                    c =>
                    `tickers.${c}`
                )
            })
        );
    });

    ws.on('message',(msg)=>{

        try{

            const json =
            JSON.parse(msg);

            if(
                !json.topic ||
                !json.data
            ){
                return;
            }

            if(
                !json.topic.startsWith(
                    'tickers.'
                )
            ){
                return;
            }

            const data =
            json.data;

            const symbol =
            data.symbol;

            if(!market[symbol]){
                return;
            }

            market[symbol]
            .BYBIT = {

                ask :
                parseFloat(
                    data.ask1Price || 0
                ),

                bid :
                parseFloat(
                    data.bid1Price || 0
                )
            };

        }catch(err){

            console.log(
                'BYBIT ERROR',
                err.message
            );
        }
    });

    ws.on('close',()=>{

        console.log(
            'BYBIT RECONNECT'
        );

        setTimeout(
            connectBybit,
            3000
        );
    });

    ws.on('error',(err)=>{

        console.log(
            'BYBIT WS ERROR',
            err.message
        );
    });
}

connectBinance();

connectBybit();

function calculateArbitrage(){

    const result = [];

    const fee =
    0.001;

    const modal =
    1000;

    for(const symbol in market){

        const data =
        market[symbol];

        if(

            !data.BINANCE.ask ||
            !data.BINANCE.bid ||

            !data.BYBIT.ask ||
            !data.BYBIT.bid
        ){
            continue;
        }

        const buyBinance =
        data.BINANCE.ask;

        const sellBybit =
        data.BYBIT.bid;

        const spread1 =

        (
            (
                (
                    sellBybit *
                    (1-fee)
                )

                -

                (
                    buyBinance *
                    (1+fee)
                )
            )

            /

            buyBinance
        )

        * 100;

        const profit1 =
        (
            modal *
            spread1
        ) / 100;

        result.push({

            id :

            symbol +
            '_BINANCE_BYBIT',

            coin :

            symbol.replace(
                'USDT',
                ''
            ),

            buy_ex :
            'BINANCE',

            sell_ex :
            'BYBIT',

            pct :
            spread1.toFixed(3),

            buy_avg :
            buyBinance.toFixed(6),

            sell_avg :
            sellBybit.toFixed(6),

            chain :
            'MAINNET',

            deposit :
            'Yes',

            withdraw :
            'Yes',

            fee_chain :
            '0.1',

            transfer_time :
            '1-3 min',

            modal :
            modal.toFixed(2),

            profit :
            profit1.toFixed(2),

            time :
            new Date()
            .toLocaleTimeString()
        });

        const buyBybit =
        data.BYBIT.ask;

        const sellBinance =
        data.BINANCE.bid;

        const spread2 =

        (
            (
                (
                    sellBinance *
                    (1-fee)
                )

                -

                (
                    buyBybit *
                    (1+fee)
                )
            )

            /

            buyBybit
        )

        * 100;

        const profit2 =
        (
            modal *
            spread2
        ) / 100;

        result.push({

            id :

            symbol +
            '_BYBIT_BINANCE',

            coin :

            symbol.replace(
                'USDT',
                ''
            ),

            buy_ex :
            'BYBIT',

            sell_ex :
            'BINANCE',

            pct :
            spread2.toFixed(3),

            buy_avg :
            buyBybit.toFixed(6),

            sell_avg :
            sellBinance.toFixed(6),

            chain :
            'MAINNET',

            deposit :
            'Yes',

            withdraw :
            'Yes',

            fee_chain :
            '0.1',

            transfer_time :
            '1-3 min',

            modal :
            modal.toFixed(2),

            profit :
            profit2.toFixed(2),

            time :
            new Date()
            .toLocaleTimeString()
        });
    }

    result.sort((a,b)=>{

        return (
            Math.abs(
                parseFloat(b.pct)
            )
            -
            Math.abs(
                parseFloat(a.pct)
            )
        );
    });

    return result.slice(0,50);
}

wss.on('connection',(ws)=>{

    console.log(
        'CLIENT CONNECTED'
    );

    ws.send(
        JSON.stringify([])
    );
});

setInterval(()=>{

    const data =
    calculateArbitrage();

    console.log(
        'TOTAL DATA:',
        data.length
    );

    const payload =
    JSON.stringify(data);

    wss.clients.forEach(client=>{

        if(
            client.readyState ===
            WebSocket.OPEN
        ){

            client.send(payload);
        }
    });

},1000);

server.listen(PORT,()=>{

    console.log(

        `SERVER RUNNING ON PORT ${PORT}`
    );
});