"""
股票代码管理器
"""
import json

from code_atrribute.history_k_data_util import HistoryKDatasUtils
from db import redis_manager_delegate as redis_manager
from db.redis_manager_delegate import RedisUtils
from utils import tool
import decimal

__redisManager = redis_manager.RedisManager(0)
__db = 0


class CodesNameManager:
    __db = 0
    redisManager = redis_manager.RedisManager(0)
    __gp_list_names_first_cache = []

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

    @classmethod
    def list_code_name_dict(cls):
        dict_ = {}
        val = cls.list_first_code_name_dict()
        if val is not None:
            for k in val:
                dict_[k] = val[k]
        val = cls.list_second_code_name_dict()
        if val is not None:
            for k in val:
                dict_[k] = val[k]
        return dict_

    @classmethod
    def list_first_code_name_dict(cls):
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")
        if val is not None:
            val = json.loads(val)
            return val
        return None

    @classmethod
    def list_first_code_name_dict_cache(cls):
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")
        if val is not None:
            val = json.loads(val)
            return val
        return None

    @classmethod
    def get_first_code_name(cls, code):
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")
        if not val:
            return None
        val = json.loads(val)
        for k in val:
            if val[k] == code:
                return k
        return None

    @classmethod
    def get_first_name_code(cls, name):
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")
        if not val:
            return None
        val = json.loads(val)
        return val.get(name)

    @classmethod
    def add_first_code_name(cls, code, name):
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")
        if not val:
            return None
        val = json.loads(val)
        val[name] = code
        cls.set_first_code_names(val)

    # 设置首板代码名称
    @classmethod
    def set_first_code_names(cls, datas):
        RedisUtils.set_async(cls.__db, "gp_list_names_first", json.dumps(datas))

    # 删除首板代码名称
    @classmethod
    def clear_first_code_names(cls):
        RedisUtils.delete(cls.__get_redis(), "gp_list_names_first")

    @classmethod
    def list_second_code_name_dict(cls):
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")
        if val is not None:
            val = json.loads(val)
            return val
        return None

    @classmethod
    def get_second_code_name(cls, code):
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")
        if not val:
            return None
        val = json.loads(val)
        for k in val:
            if val[k] == code:
                return k

    @classmethod
    def get_second_name_code(cls, name):
        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")
        if not val:
            return None
        val = json.loads(val)
        return val.get(name)

    # 设置二板代码名称
    @classmethod
    def set_second_code_names(cls, datas):
        RedisUtils.set(cls.__get_redis(), "gp_list_names", json.dumps(datas))

    # 设置二板代码名称
    @classmethod
    def clear_second_code_names(cls):
        RedisUtils.delete(cls.__get_redis(), "gp_list_names")


# 获取二板代码
def get_second_gp_list():
    codes = RedisUtils.smembers(__redisManager.getRedis(), "gp_list")
    return codes


class CodePrePriceManager:
    __price_pre_cache = {}
    __redisManager = redis_manager.RedisManager(0)

    # 获取收盘价
    @classmethod
    def get_price_pre(cls, code):
        result = RedisUtils.get(cls.__redisManager.getRedis(), "price-pre-{}".format(code))
        if result is not None:
            return float(result)
        return None

    # 获取缓存
    @classmethod
    def get_price_pre_cache(cls, code):
        if code in cls.__price_pre_cache:
            return float(cls.__price_pre_cache[code])
        val = cls.get_price_pre(code)
        if val:
            cls.__price_pre_cache[code] = val
        return val

    # 设置收盘价
    @classmethod
    def set_price_pre(cls, code, price, force=False):
        RedisUtils.setex(cls.__redisManager.getRedis(), "price-pre-{}".format(code), tool.get_expire(), str(price))
        cls.__price_pre_cache[code] = float(price)


__limit_up_price_dict = {}


# 获取涨停价
def get_limit_up_price(code):
    # 读取内存中的值
    if code in __limit_up_price_dict:
        return __limit_up_price_dict[code]
    price = CodePrePriceManager.get_price_pre_cache(code)
    if price is None:
        return None
    limit_up_price = tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("1.1"))
    __limit_up_price_dict[code] = limit_up_price
    return limit_up_price


def get_price_pre_cache(code):
    price = CodePrePriceManager.get_price_pre_cache(code)
    return price


def set_price_pre(code, price):
    CodePrePriceManager.set_price_pre(code, price, force=True)


def request_price_pre(codes):
    k_results = HistoryKDatasUtils.get_gp_latest_info(codes, "pre_close,sec_id")
    for kr in k_results:
        set_price_pre(kr['sec_id'], round(kr['pre_close'], 2))


def get_limit_up_price_cache(code):
    if code in __limit_up_price_dict:
        return __limit_up_price_dict[code]
    return None


def get_limit_up_price_by_preprice(price):
    if price is None:
        return None
    return tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("1.1"))


def get_limit_down_price_by_preprice(price):
    if price is None:
        return None
    return tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("0.9"))


# 获取跌停价
def get_limit_down_price(code):
    price = CodePrePriceManager.get_price_pre_cache(code)
    if price is None:
        return None
    return tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("0.9"))