"""
交易管理器，
对一系列的代码交易变量，下单，撤单进行管理
"""
# 交易管理器
import copy

from db import redis_manager_delegate as redis_manager
from db.redis_manager_delegate import RedisUtils
from log_module import async_log_util
from trade import trade_constant


from log_module.log import *
from utils import import_util, tool, huaxin_util

trade_gui = import_util.import_lib("trade.trade_gui")

__db = 12
__redis_manager = redis_manager.RedisManager(__db)

guiTrade = None  # trade_gui.THSGuiTrade() if trade_gui is not None else None

latest_trade_delegate_data = []


# 关闭购买入口
# 开启购买入口
class TradeStateManager:
    __instance = None
    __db = 12
    redisManager = redis_manager.RedisManager(12)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(TradeStateManager, cls).__new__(cls, *args, **kwargs)
            cls.__instance.__trade_buy_state_cache = cls.is_can_buy()
        return cls.__instance

    @classmethod
    def __get_redis(cls):
        return cls.redisManager.getRedis()

    def sync(self):
        self.__trade_buy_state_cache = self.is_can_buy()

    # 开启购买入口
    def open_buy(self):
        self.__trade_buy_state_cache = True
        RedisUtils.setex_async(self.__db, "trade_buy_state", tool.get_expire(), 1)

    # 关闭购买入口
    def close_buy(self):
        self.__trade_buy_state_cache = False
        RedisUtils.setex_async(self.__db, "trade_buy_state", tool.get_expire(), 0)

    # 是否可以下单
    @classmethod
    def is_can_buy(cls):
        # 默认设置为可交易
        val = RedisUtils.get(cls.__get_redis(), "trade_buy_state")
        if val is None:
            return True
        if int(val) == 1:
            return True
        else:
            return False

        # 是否可以下单

    def is_can_buy_cache(self):
        # 默认设置为可交易
        return self.__trade_buy_state_cache


# 代码的交易状态管理
class CodesTradeStateManager:
    __trade_state_cache = {}
    __db = 12
    __redis_manager = redis_manager.RedisManager(12)
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(CodesTradeStateManager, cls).__new__(cls, *args, **kwargs)
            cls.__load_datas()

        return cls.__instance

    @classmethod
    def __get_redis(cls):
        return cls.__redis_manager.getRedis()

    @classmethod
    def __load_datas(cls):
        __redis = cls.__get_redis()
        try:
            # 初始化数据
            keys = RedisUtils.keys(__redis, "trade-state-*", auto_free=False)
            if keys:
                for key in keys:
                    code = key.replace("trade-state-", '')
                    cls.__trade_state_cache[code] = int(RedisUtils.get(__redis, key, auto_free=False))
        finally:
            RedisUtils.realse(__redis)

    # 获取交易状态
    def get_trade_state(self, code):
        state = RedisUtils.get(self.__get_redis(), "trade-state-{}".format(code))
        if state is None:
            return trade_constant.TRADE_STATE_NOT_TRADE
        return int(state)

    def get_trade_state_cache(self, code):
        cache_result = tool.CodeDataCacheUtil.get_cache(self.__trade_state_cache, code)
        if cache_result[0]:
            return cache_result[1]
        return trade_constant.TRADE_STATE_NOT_TRADE

    def get_trade_state_dict(self):
        return copy.deepcopy(self.__trade_state_cache)

    # 设置交易状态
    def set_trade_state(self, code, state):
        async_log_util.info(logger_trade, "set_trade_state {}-{}".format(code, state))
        tool.CodeDataCacheUtil.set_cache(self.__trade_state_cache, code, state)
        RedisUtils.setex_async(self.__db, "trade-state-{}".format(code), tool.get_expire(), state)

    def get_codes_by_trade_state(self, state):
        redis = self.__get_redis()
        try:
            keys = RedisUtils.keys(redis, "trade-state-*", auto_free=False)
            codes = []
            if keys is not None:
                for key in keys:
                    if int(RedisUtils.get(redis, key, auto_free=False)) == state:
                        codes.append(key.replace("trade-state-", ''))
            return codes
        finally:
            RedisUtils.realse(redis)

    def get_codes_by_trade_states(self, states):
        redis = self.__get_redis()
        try:
            keys = RedisUtils.keys(redis, "trade-state-*", auto_free=False)
            codes = []
            if keys is not None:
                for key in keys:
                    if int(RedisUtils.get(redis, key, auto_free=False)) in states:
                        codes.append(key.replace("trade-state-", ''))
            return codes
        finally:
            RedisUtils.realse(redis)

    def get_codes_by_trade_states_cache(self, states):
        # 获取
        codes = []
        for code in self.__trade_state_cache:
            if self.__trade_state_cache[code] in states:
                codes.append(code)
        return codes

    # 设置交易账户的可用金额


__CodesTradeStateManager = CodesTradeStateManager()