// ICoreListener.h

#pragma once

#include <onepiece/models/TickData.h>
#include <onepiece/models/OrderData.h>
#include <onepiece/models/TradeData.h>
#include <onepiece/models/StatusInfoFieldData.h>

#include <memory>

#include <onepiece/templates/IMarketApi.h>
#include <onepiece/templates/ITraderApi.h>

#include <spdlog/spdlog.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <unordered_map>


class ICoreListener {

public:
    virtual void OnTraderReady(StatusInfoFieldSPtr statusInfoFieldDataSPtr) = 0;

    virtual void OnMarketReady(StatusInfoFieldSPtr statusInfoFieldDataSPtr) = 0;

    virtual void OnTickReceived(TickSPtr tickSPtr) = 0;

    virtual void OnOrderReceived(OrderSPtr orderSPtr) = 0;
    virtual void OnErrorOrderReceived(OrderSPtr orderSPtr) = 0;
    
    virtual void OnTradeReceived(TradeSPtr tradeSPtr) = 0;

    virtual void Run() = 0;

    virtual const shared_ptr<vector<string>> SysInstruments() = 0;

    virtual ContractSPtr GetSysContractSPtr(const string & instrumentID) = 0; // <- for market spi.

    virtual void HandleTick(TickSPtr tickSPtr) { this->m_ticksQueue.Push(tickSPtr); };

    virtual bool IsTdYdExchange(const shared_ptr<string> exchangeID) {
        return 0 != this->m_tdYd_exchange_set.count(exchangeID->data());
    }

    virtual OrderSPtr EnterLong(const shared_ptr<string> instrumentID, double price, int lots) {
        ContractSPtr contractSPtr = this->m_traderApi->GetSysContractSPtr(instrumentID->data());
        if (!contractSPtr) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("EnterLong: instrumentID({0}) is outside sys.", instrumentID->c_str());
            }
            return nullptr;
        }

        OrderSPtr orderSPtr = this->MakeOrderSPtr(contractSPtr, lots, OPDirection::LONG, price, OPOpenClose::OPEN);
        if (!orderSPtr){
            if (this->m_coreLogger) {
                this->m_coreLogger->error("EnterLong: make order({0}) price({1}) lots({2}) failed.", instrumentID->c_str(), price, lots);
            }
            return nullptr;
        }

        bool ret = this->m_traderApi->InsertOrder(orderSPtr);
        if (!ret) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("EnterLong: instrumentID({0}) insert order failed.", instrumentID->c_str());
            }
            return nullptr;
        }

        return orderSPtr;
    };

    virtual OrderSPtr EnterShort(const shared_ptr<string> instrumentID, double price, int lots) {
        ContractSPtr contractSPtr = this->m_traderApi->GetSysContractSPtr(instrumentID->data());
        if (!contractSPtr) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("EnterShort: instrumentID({0}) is outside sys.", instrumentID->c_str());
            }
            return nullptr;
        }

        OrderSPtr orderSPtr = this->MakeOrderSPtr(contractSPtr, lots, OPDirection::SHORT, price, OPOpenClose::OPEN);
        if (!orderSPtr) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("EnterShort: make order({0}) price({1}) lots({2}) failed.", instrumentID->c_str(), price, lots);
            }
            return nullptr;
        }

        bool ret = this->m_traderApi->InsertOrder(orderSPtr);
        if (!ret) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("EnterShort: instrumentID({0}) insert order failed.", instrumentID->c_str());
            }
            return nullptr;
        }

        return orderSPtr;
    };

    virtual OrderSPtr ExitLong(const shared_ptr<string> instrumentID, double price, int lots, OPOpenClose closeType = OPOpenClose::CLOSE) {
        ContractSPtr contractSPtr = this->m_traderApi->GetSysContractSPtr(instrumentID->data());
        if (!contractSPtr) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("ExitLong: instrumentID({0}) is outside sys.", instrumentID->c_str());
            }
            return nullptr;
        }

        OrderSPtr orderSPtr = this->MakeOrderSPtr(contractSPtr, lots, OPDirection::SHORT, price, closeType);
        if (!orderSPtr) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("ExitLong: make order({0}) price({1}) lots({2}) failed.", instrumentID->c_str(), price, lots);
            }
            return nullptr;
        }

        bool ret = this->m_traderApi->InsertOrder(orderSPtr);
        if (!ret) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("ExitLong: instrumentID({0}) insert order error.", instrumentID->c_str());
            }
            return nullptr;
        }
        
        return orderSPtr;
    };
    
    virtual OrderSPtr ExitShort(const shared_ptr<string> instrumentID, double price, int lots, OPOpenClose closeType = OPOpenClose::CLOSE) {
        ContractSPtr contractSPtr = this->m_traderApi->GetSysContractSPtr(instrumentID->data());
        if (!contractSPtr) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("ExitShort: instrumentID({0}) is outside sys.", instrumentID->c_str());
            }
            return nullptr;
        }

        OrderSPtr orderSPtr = this->MakeOrderSPtr(contractSPtr, lots, OPDirection::LONG, price, closeType);
        if (!orderSPtr) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("ExitShort: make order({0}) price({1}) lots({2}) failed.", instrumentID->c_str(), price, lots);
            }
            return nullptr;
        }

        bool ret = this->m_traderApi->InsertOrder(orderSPtr);
        if (!ret) {
            if (this->m_coreLogger) {
                this->m_coreLogger->error("ExitShort: instrumentID({0}) insert order error.", instrumentID->c_str());
            }
            return nullptr;
        }

        return orderSPtr;
    };

    virtual bool CancelOrder(const OrderSPtr orderSPtr) {
        return this->m_traderApi->CancelOrder(orderSPtr);
    }


private:
    virtual OrderSPtr MakeOrderSPtr(ContractSPtr contractSPtr, int lots, OPDirection direction, double price, OPOpenClose combOffsetFlag) {
        OrderSPtr orderSPtr = make_shared<OrderData>();

        orderSPtr->setCompletedOrderLots(0);
        orderSPtr->setCompletedTradeLots(0);
        orderSPtr->setLots(lots);
        orderSPtr->setDirection(direction);
        orderSPtr->setLimitPrice(price);
        orderSPtr->setCombOffsetFlag(combOffsetFlag);
        orderSPtr->setOrderStatus(OPOrderStatus::UN_KNOWN);

        orderSPtr->setInstrumentID(contractSPtr->InstrumentID());
        orderSPtr->setExchangeID(contractSPtr->ExchangeID());
        orderSPtr->setExchangeInstrument(contractSPtr->ExchangeInstrument());

        return orderSPtr;
    }

public:
    TraderUPtr m_traderApi;
    MarketUPtr m_marketApi;

protected:
    shared_ptr<spdlog::logger> m_coreLogger;

    ThreadSafeQueue<TickSPtr> m_ticksQueue;

    unordered_set<string> m_tdYd_exchange_set; // <- close pos include today pos & yestoday pos exchange set;
    unordered_set<string> m_stock_index_set; // <- eg: ["IC", "IH", "IF", "IM"]
    unordered_set<string> m_treasury_set; // <- eg: ["T", "TS", "TF"]

};