//import APIConfig from "../js/apiwrapper/APIConfig.js";
import SerializableHelper from "../js/util/SerializableHelper.js";
import BinanceApiClient from "./apis/binance/BinanceApiClient.js";
import BinanceApiConfig from "./apis/binance/BinanceApiConfig.js";
import TradingPairs from "./apiwrapper/assets/TraidingPairs.js";
import Transaction from "./apiwrapper/transaction/Transaction.js";
import TransactionSettings from "./apiwrapper/transaction/TransactionSettings.js";
import Logger from "./logging/Logger.js";
import AssetDataCollector from "./tradingbot/AssetDataCollector.js";
import BotConfig from "./tradingbot/config/BotConfig.js";
import RestClient from "./webview/RestClient.js";
//import BinanceApiConfig from "./apis/binance/BinanceApiConfig.js";
//import TradingPair from "./apiwrapper/assets/TradingPair.js";
//import TradingPairs from "./apiwrapper/assets/TraidingPairs.js";
//import BotConfig from "./tradingbot/config/BotConfig.js";
import TradingBot from "./tradingbot/TradingBot.js";
import DefaultWorker from "./tradingbot/worker/DefaultWorker.js";
import AbstractStrategy from "./tradingbot/strategy/AbstractStrategy.js";
import StatisticWorker from "./tradingbot/worker/StatisticWorker.js";
import PeakDetector from "./tradingbot/data/asset/PeakDetector.js";
import OrderBookEntry from "./apiwrapper/orderbook/OrderBookEntry.js";
import TestStrategy from "./tradingbot/strategy/TestStrategy.js";
import AvgMinMaxStrategy from "./tradingbot/strategy/AvgMinMaxStrategy.js";
import AvgEmaStrategy from "./tradingbot/strategy/AvgEmaStrategy.js";
import SingleTransactionTestWorker from "./tradingbot/worker/SingleTransactionTestWorker.js";

try{

    const tradingBot = new TradingBot("C:/Users/Wlad/Projekte/BinanceBot/binance_bot/data/conf", "config-main.sjson");
    const galaWorker = new DefaultWorker("gala_avgema", TradingPairs.GALAUSDT, new AvgEmaStrategy());
    const statWorker = new StatisticWorker("gala_stats", TradingPairs.GALAUSDT, new TestStrategy());

    const algoWorker = new DefaultWorker("algo_avgema", TradingPairs.ALGOUSDT, new AvgEmaStrategy());
    const dogeWorker = new DefaultWorker("doge_avgema", TradingPairs.DOGEUSDT, new AvgEmaStrategy());
    const xrpWorker = new DefaultWorker("xrp_avgema", TradingPairs.XRPUSDT, new AvgEmaStrategy());
    const adaWorker = new DefaultWorker("ada_avgema", TradingPairs.ADAUSDT, new AvgEmaStrategy());

    //const testWorker = new SingleTransactionTestWorker("gala_test", TradingPairs.GALAUSDT, new AvgEmaStrategy());
    //tradingBot.registerWorker(testWorker);

    //tradingBot.registerWorker(galaWorker);
    //tradingBot.registerWorker(statWorker);
    //tradingBot.registerWorker(dogeWorker);
    //tradingBot.registerWorker(xrpWorker);
    //tradingBot.registerWorker(algoWorker);
    //tradingBot.registerWorker(adaWorker);
    
    tradingBot.start();
} catch (e){
    console.log(e);
}

/*const logger = new Logger("C:/Users/Wlad/Projekte/BinanceBot/binance_bot/data/log");
const api = new BinanceApiClient(BinanceApiConfig.createTestNetConfig(), logger);
const listener = {
    handleAssetUpdate: function(accountUpdateEvent){
        //;
    },

    handleAccountUpdate: function(accountUpdateEvent){
        console.log(accountUpdateEvent);
    }
};
api.registerAccountEventListener(listener);
api.registerAssetEventListener(listener);
const transaction = new Transaction("test", TradingPairs.GALAUSDT);
transaction.buySettings = new TransactionSettings(0.0343, 874.89064);
setTimeout(() => {api.requestBuy(transaction);}, 5000);*/






// ############################
// ##        API TESTS       ##
// ############################
/*try{
    const conf = new BotConfig();
    const logger = new Logger("C:/Users/Wlad/Projekte/BinanceBot/binance_bot/data/log");
    const collector = new AssetDataCollector(logger, conf);
    const restClient = new RestClient();
    
    conf.setApiConfig(BinanceApiConfig.createTestNetConfig());
    const listener = {
        handleAssetUpdate: function(accountUpdateEvent){
            collector.pushAssetEvent(accountUpdateEvent);
        },

        handleAccountUpdate: function(accountUpdateEvent){
            console.log(accountUpdateEvent);
        }
    };
    const client = new BinanceApiClient(conf.getApiConfig(), logger);
    const testTransaction = new Transaction("test", TradingPairs.GALAUSDT);
    testTransaction.buySettings = new TransactionSettings(0.03644, 150);
    //client.requestBuy(testTransaction);
    //client.requestBuyCancel(testTransaction);
    setInterval(() => {
        client.requestTransactionStatus(testTransaction, "buy");
        client.requestTransactionDetails(testTransaction, "buy");
    }, 10000)
    
    client.registerAccountEventListener(listener);
    client.registerAssetEventListener(listener);
    client.subscribeTrades(TradingPairs.GALAUSDT);
    client.subscribe24hTicker(TradingPairs.GALAUSDT);
    client.subscribeKLines(TradingPairs.GALAUSDT);
    client.subscribeOrderBookUpdates(TradingPairs.GALAUSDT);

    restClient.start({
        getAvailableAssets(){            
            return collector.getManagedAssets().map(tp => tp.getKey());
        },
        getOrderBook(symbol){
            return collector.getAssetData(TradingPairs.fromString(symbol)).getOrderBook();
        }
    });

    setInterval(() => {
        const assetData = collector.getAssetData(TradingPairs.GALAUSDT);
        console.log(assetData.getHigh(), assetData.getLow(), assetData.getOrderBook().getBestAsk(), assetData.getOrderBook().getBestBid());
        console.log(assetData.getSubData()[assetData.getSubData().length - 1]);
    }, 10000);
} catch (e){
    console.log(e);
}*/

// ############################
// ##      write config      ##
// ############################
/*const path = 'C:/Users/Wlad/Projekte/BinanceBot/binance_bot/data/conf';
const conf = new BotConfig();
conf.setApiConfig(BinanceApiConfig.createMainNetConfig());
conf.setWorkingDirectory('C:/Users/Wlad/Projekte/BinanceBot/binance_bot/data');
conf.setRelativeDataPath('data');
conf.setRelativeLogPath('logs');
conf.setRelativeTmpPath('tmp');
conf.setUsdTradeLimit(500);
conf.setPerTradeLimit(50);
SerializableHelper.save(path, "config-main.sjson", conf);*/

// ############################
// ##    SERIALIZER TESTS    ##
// ############################

/*let confMain = BinanceApiConfig.createMainNetConfig();
let confTest = BinanceApiConfig.createTestNetConfig();
let confAlt = new BinanceApiConfig("testKey", "testSecret");

console.log("before main:", confMain.getKey(), confMain.getRestUrl());
console.log("before test:", confTest.getKey(), confTest.getRestUrl());
console.log("before alt:", confAlt.getKey(), confAlt.getRestUrl());

SerializableHelper.save(".", "api.conf", [confMain, confTest, confAlt]);
[confMain, confTest, confAlt] = SerializableHelper.load(".", "api.conf", BinanceApiConfig);

console.log("after main:", confMain.getKey(), confMain.getRestUrl());
console.log("after test:", confTest.getKey(), confTest.getRestUrl());
console.log("after alt:", confAlt.getKey(), confAlt.getRestUrl());

let tp = TradingPairs.GALAUSDT;
SerializableHelper.save(".", "pair.json", tp);
tp = SerializableHelper.load(".", "pair.json", TradingPair);
console.log(tp.getKey());*/