package memory

import (
	"github.com/allegro/bigcache"
	"github.com/shopspring/decimal"
	"matchmaking-system/internal/pkg/utils"
)

var (
	// 美股
	ShareUsCache         *bigcache.BigCache // 美股行情缓存
	ShareUsChgMark       *bigcache.BigCache // 美股买涨|买跌-涨跌幅标识
	ShareUsClosePrice    *bigcache.BigCache // 美股闭盘价格
	ShareUsPriceSetUp    *bigcache.BigCache // 美股设置盘前|盘后价格
	ShareUsForcedClosure *bigcache.BigCache // 美股设置强平阈值
	ShareUsFloating      *bigcache.BigCache // 美股统计总浮动盈亏
	// 印尼股
	ShareIdnCache         *bigcache.BigCache // 印尼股行情缓存
	ShareIdnChgMark       *bigcache.BigCache // 印尼股买涨|买跌-涨跌幅标识
	ShareIdnClosePrice    *bigcache.BigCache // 印尼闭盘价格
	ShareIdnPriceSetUp    *bigcache.BigCache // 印尼股设置盘前|盘后价格
	ShareIdnForcedClosure *bigcache.BigCache // 印尼设置强平阈值
	ShareIdnFloating      *bigcache.BigCache // 印尼股统计总浮动盈亏
	// 马股
	ShareMysCache         *bigcache.BigCache // 马股行情缓存
	ShareMysChgMark       *bigcache.BigCache // 马股买涨|买跌-涨跌幅标识
	ShareMysClosePrice    *bigcache.BigCache // 马股闭盘价格
	ShareMysPriceSetUp    *bigcache.BigCache // 马股设置盘前|盘后价格
	ShareMysForcedClosure *bigcache.BigCache // 马股设置强平阈值
	ShareMysFloating      *bigcache.BigCache // 马股统计总浮动盈亏
	// 泰股
	ShareThaCache         *bigcache.BigCache // 泰股行情缓存
	ShareThaChgMark       *bigcache.BigCache // 泰股买涨|买跌-涨跌幅标识
	ShareThaClosePrice    *bigcache.BigCache // 泰股闭盘价格
	ShareThaPriceSetUp    *bigcache.BigCache // 泰股设置盘前|盘后价格
	ShareThaForcedClosure *bigcache.BigCache // 泰股设置强平阈值
	ShareThaFloating      *bigcache.BigCache // 泰股统计总浮动盈亏
	// 印度股
	ShareInrCache         *bigcache.BigCache // 印度股行情缓存
	ShareInrChgMark       *bigcache.BigCache // 印度股买涨|买跌-涨跌幅标识
	ShareInrClosePrice    *bigcache.BigCache // 印度股闭盘价格
	ShareInrPriceSetUp    *bigcache.BigCache // 印度股设置盘前|盘后价格
	ShareInrForcedClosure *bigcache.BigCache // 印度股设置强平阈值
	ShareInrFloating      *bigcache.BigCache // 印度股统计总浮动盈亏
	// 新加坡股
	ShareSgdCache         *bigcache.BigCache // 新加坡股行情缓存
	ShareSgdChgMark       *bigcache.BigCache // 新加坡股买涨|买跌-涨跌幅标识
	ShareSgdClosePrice    *bigcache.BigCache // 新加坡股闭盘价格
	ShareSgdPriceSetUp    *bigcache.BigCache // 新加坡股设置盘前|盘后价格
	ShareSgdForcedClosure *bigcache.BigCache // 新加坡股设置强平阈值
	ShareSgdFloating      *bigcache.BigCache // 新加坡股统计总浮动盈亏
	// 港股
	ShareHkdCache         *bigcache.BigCache // 港股行情缓存
	ShareHkdChgMark       *bigcache.BigCache // 港股买涨|买跌-涨跌幅标识
	ShareHkdClosePrice    *bigcache.BigCache // 港股闭盘价格
	ShareHkdPriceSetUp    *bigcache.BigCache // 港股设置盘前|盘后价格
	ShareHkdForcedClosure *bigcache.BigCache // 港股设置强平阈值
	ShareHkdFloating      *bigcache.BigCache // 港股统计总浮动盈亏
	// 英股
	ShareGbxCache         *bigcache.BigCache // 英股行情缓存
	ShareGbxChgMark       *bigcache.BigCache // 英股买涨|买跌-涨跌幅标识
	ShareGbxClosePrice    *bigcache.BigCache // 英股闭盘价格
	ShareGbxPriceSetUp    *bigcache.BigCache // 英股设置盘前|盘后价格
	ShareGbxForcedClosure *bigcache.BigCache // 英股设置强平阈值
	ShareGbxFloating      *bigcache.BigCache // 英股统计总浮动盈亏
	// 德股
	ShareEurCache         *bigcache.BigCache // 德股行情缓存
	ShareEurChgMark       *bigcache.BigCache // 德股买涨|买跌-涨跌幅标识
	ShareEurClosePrice    *bigcache.BigCache // 德股闭盘价格
	ShareEurPriceSetUp    *bigcache.BigCache // 德股设置盘前|盘后价格
	ShareEurForcedClosure *bigcache.BigCache // 德股设置强平阈值
	ShareEurFloating      *bigcache.BigCache // 德股统计总浮动盈亏
	// 法股
	ShareFurCache         *bigcache.BigCache // 法股行情缓存
	ShareFurChgMark       *bigcache.BigCache // 法股买涨|买跌-涨跌幅标识
	ShareFurClosePrice    *bigcache.BigCache // 法股闭盘价格
	ShareFurPriceSetUp    *bigcache.BigCache // 法股设置盘前|盘后价格
	ShareFurForcedClosure *bigcache.BigCache // 法股设置强平阈值
	ShareFurFloating      *bigcache.BigCache // 法股统计总浮动盈亏
	// 巴西股
	ShareBrlCache         *bigcache.BigCache // 巴西股行情缓存
	ShareBrlChgMark       *bigcache.BigCache // 巴西股买涨|买跌-涨跌幅标识
	ShareBrlClosePrice    *bigcache.BigCache // 巴西股闭盘价格
	ShareBrlPriceSetUp    *bigcache.BigCache // 巴西股设置盘前|盘后价格
	ShareBrlForcedClosure *bigcache.BigCache // 巴西股设置强平阈值
	ShareBrlFloating      *bigcache.BigCache // 巴西股统计总浮动盈亏
	// 日本股
	ShareJpyCache         *bigcache.BigCache // 日本股行情缓存
	ShareJpyChgMark       *bigcache.BigCache // 日本股买涨|买跌-涨跌幅标识
	ShareJpyClosePrice    *bigcache.BigCache // 日本股闭盘价格
	ShareJpyPriceSetUp    *bigcache.BigCache // 日本股设置盘前|盘后价格
	ShareJpyForcedClosure *bigcache.BigCache // 日本股设置强平阈值
	ShareJpyFloating      *bigcache.BigCache // 日本股统计总浮动盈亏
	// 大宗交易
	ShareBlkFloating *bigcache.BigCache // 大宗交易统计总浮动盈亏
)

// init
//
//	@Description: 初始化股票-内存缓存
func init() {
	// 股票-美股
	ShareUsCache = NewBigCache()
	ShareUsChgMark = NewBigCache()
	ShareUsClosePrice = NewBigCache()
	ShareUsPriceSetUp = NewBigCache()
	ShareUsForcedClosure = NewBigCache()
	ShareUsFloating = NewBigCache()
	// 股票-印尼股
	ShareIdnCache = NewBigCache()
	ShareIdnChgMark = NewBigCache()
	ShareIdnClosePrice = NewBigCache()
	ShareIdnPriceSetUp = NewBigCache()
	ShareIdnForcedClosure = NewBigCache()
	ShareIdnFloating = NewBigCache()
	// 股票-马股
	ShareMysCache = NewBigCache()
	ShareMysChgMark = NewBigCache()
	ShareMysClosePrice = NewBigCache()
	ShareMysPriceSetUp = NewBigCache()
	ShareMysForcedClosure = NewBigCache()
	ShareMysFloating = NewBigCache()
	// 股票-泰股
	ShareThaCache = NewBigCache()
	ShareThaChgMark = NewBigCache()
	ShareThaClosePrice = NewBigCache()
	ShareThaPriceSetUp = NewBigCache()
	ShareThaForcedClosure = NewBigCache()
	ShareThaFloating = NewBigCache()
	// 股票-印度股
	ShareInrCache = NewBigCache()
	ShareInrChgMark = NewBigCache()
	ShareInrClosePrice = NewBigCache()
	ShareInrPriceSetUp = NewBigCache()
	ShareInrForcedClosure = NewBigCache()
	ShareInrFloating = NewBigCache()
	// 股票-新加坡股
	ShareSgdCache = NewBigCache()
	ShareSgdChgMark = NewBigCache()
	ShareSgdClosePrice = NewBigCache()
	ShareSgdPriceSetUp = NewBigCache()
	ShareSgdForcedClosure = NewBigCache()
	ShareSgdFloating = NewBigCache()
	// 股票-港股
	ShareHkdCache = NewBigCache()
	ShareHkdChgMark = NewBigCache()
	ShareHkdClosePrice = NewBigCache()
	ShareHkdPriceSetUp = NewBigCache()
	ShareHkdForcedClosure = NewBigCache()
	ShareHkdFloating = NewBigCache()
	// 股票-英股
	ShareGbxCache = NewBigCache()
	ShareGbxChgMark = NewBigCache()
	ShareGbxClosePrice = NewBigCache()
	ShareGbxPriceSetUp = NewBigCache()
	ShareGbxForcedClosure = NewBigCache()
	ShareGbxFloating = NewBigCache()
	// 股票-德股
	ShareEurCache = NewBigCache()
	ShareEurChgMark = NewBigCache()
	ShareEurClosePrice = NewBigCache()
	ShareEurPriceSetUp = NewBigCache()
	ShareEurForcedClosure = NewBigCache()
	ShareEurFloating = NewBigCache()
	// 股票-法股
	ShareFurCache = NewBigCache()
	ShareFurChgMark = NewBigCache()
	ShareFurClosePrice = NewBigCache()
	ShareFurPriceSetUp = NewBigCache()
	ShareFurForcedClosure = NewBigCache()
	ShareFurFloating = NewBigCache()
	// 股票-巴西股
	ShareBrlCache = NewBigCache()
	ShareBrlChgMark = NewBigCache()
	ShareBrlClosePrice = NewBigCache()
	ShareBrlPriceSetUp = NewBigCache()
	ShareBrlForcedClosure = NewBigCache()
	ShareBrlFloating = NewBigCache()
	// 股票-日本股
	ShareJpyCache = NewBigCache()
	ShareJpyChgMark = NewBigCache()
	ShareJpyClosePrice = NewBigCache()
	ShareJpyPriceSetUp = NewBigCache()
	ShareJpyForcedClosure = NewBigCache()
	ShareJpyFloating = NewBigCache()
	// 大宗交易-(美股|泰股|马股|印尼股|印度股|新加坡股|港股|英股|德股|法股|日本股)
	ShareBlkFloating = NewBigCache()
}

// GetShareUsCache
//
//	@Description: 股票-美股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareUsCache(key string) ([]byte, error) {
	usP, err := ShareUsPriceSetUp.Get(key)
	if err != nil || string(usP) == decimal.Zero.String() || len(utils.StrReplace(string(usP))) == 0 {
		usS, errs := ShareUsCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return usS, nil
	}

	return usP, nil
}
func GetShareUsCacheWs(key string) ([]byte, error) {
	usP, err := ShareUsCache.Get(key)
	if err != nil || string(usP) == decimal.Zero.String() || len(utils.StrReplace(string(usP))) == 0 {
		return []byte{}, err
	}

	return usP, nil
}

// GetShareThaCache
//
//	@Description: 股票-泰股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareThaCache(key string) ([]byte, error) {
	thaP, err := ShareThaPriceSetUp.Get(key)
	if err != nil || string(thaP) == decimal.Zero.String() || len(utils.StrReplace(string(thaP))) == 0 {
		thaS, errs := ShareThaCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return thaS, nil
	}

	return thaP, nil
}
func GetShareThaCacheWs(key string) ([]byte, error) {
	thaP, err := ShareThaCache.Get(key)
	if err != nil || string(thaP) == decimal.Zero.String() || len(utils.StrReplace(string(thaP))) == 0 {
		return []byte{}, err
	}

	return thaP, nil
}

// GetShareIdnCache
//
//	@Description: 股票-印尼股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareIdnCache(key string) ([]byte, error) {
	idnP, err := ShareIdnPriceSetUp.Get(key)
	if err != nil || string(idnP) == decimal.Zero.String() || len(utils.StrReplace(string(idnP))) == 0 {
		idnS, errs := ShareIdnCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return idnS, nil
	}

	return idnP, nil
}
func GetShareIdnCacheWs(key string) ([]byte, error) {
	idnP, err := ShareIdnCache.Get(key)
	if err != nil || string(idnP) == decimal.Zero.String() || len(utils.StrReplace(string(idnP))) == 0 {
		return []byte{}, err
	}

	return idnP, nil
}

// GetShareMysCache
//
//	@Description: 股票-马股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareMysCache(key string) ([]byte, error) {
	mysP, err := ShareMysPriceSetUp.Get(key)
	if err != nil || string(mysP) == decimal.Zero.String() || len(utils.StrReplace(string(mysP))) == 0 {
		mysS, errs := ShareMysCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return mysS, nil
	}

	return mysP, nil
}
func GetShareMysCacheWs(key string) ([]byte, error) {
	mysP, err := ShareMysCache.Get(key)
	if err != nil || string(mysP) == decimal.Zero.String() || len(utils.StrReplace(string(mysP))) == 0 {
		return []byte{}, err
	}

	return mysP, nil
}

// GetShareInrCache
//
//	@Description: 股票-印度股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareInrCache(key string) ([]byte, error) {
	inrP, err := ShareInrPriceSetUp.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		inrS, errs := ShareInrCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return inrS, nil
	}

	return inrP, nil
}
func GetShareInrCacheWs(key string) ([]byte, error) {
	inrP, err := ShareInrCache.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		return []byte{}, err
	}

	return inrP, nil
}

// GetShareSgdCache
//
//	@Description: 股票-新加坡股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareSgdCache(key string) ([]byte, error) {
	inrP, err := ShareSgdPriceSetUp.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		inrS, errs := ShareSgdCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return inrS, nil
	}

	return inrP, nil
}
func GetShareSgdCacheWs(key string) ([]byte, error) {
	inrP, err := ShareSgdCache.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		return []byte{}, err
	}

	return inrP, nil
}

// GetShareHkdCache
//
//	@Description: 股票-港股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareHkdCache(key string) ([]byte, error) {
	inrP, err := ShareHkdPriceSetUp.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		inrS, errs := ShareHkdCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return inrS, nil
	}

	return inrP, nil
}
func GetShareHkdCacheWs(key string) ([]byte, error) {
	inrP, err := ShareHkdCache.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		return []byte{}, err
	}

	return inrP, nil
}

// GetShareGbxCache
//
//	@Description:  股票-英股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareGbxCache(key string) ([]byte, error) {
	inrP, err := ShareGbxPriceSetUp.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		inrS, errs := ShareGbxCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return inrS, nil
	}

	return inrP, nil
}
func GetShareGbxCacheWs(key string) ([]byte, error) {
	inrP, err := ShareGbxCache.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		return []byte{}, err
	}

	return inrP, nil
}

// GetShareEurCache
//
//	@Description:  股票-德股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareEurCache(key string) ([]byte, error) {
	inrP, err := ShareEurPriceSetUp.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		inrS, errs := ShareEurCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return inrS, nil
	}

	return inrP, nil
}
func GetShareEurCacheWs(key string) ([]byte, error) {
	inrP, err := ShareEurCache.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		return []byte{}, err
	}

	return inrP, nil
}

// GetShareFurCache
//
//	@Description:  股票-法股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareFurCache(key string) ([]byte, error) {
	inrP, err := ShareFurPriceSetUp.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		inrS, errs := ShareFurCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return inrS, nil
	}

	return inrP, nil
}
func GetShareFurCacheWs(key string) ([]byte, error) {
	inrP, err := ShareFurCache.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		return []byte{}, err
	}

	return inrP, nil
}

// GetShareBrlCache
//
//	@Description: 股票-巴西股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareBrlCache(key string) ([]byte, error) {
	inrP, err := ShareBrlPriceSetUp.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		inrS, errs := ShareBrlCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return inrS, nil
	}

	return inrP, nil
}
func GetShareBrlCacheWs(key string) ([]byte, error) {
	inrP, err := ShareBrlCache.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		return []byte{}, err
	}

	return inrP, nil
}

// GetShareJpyCache
//
//	@Description:  股票-日股市价(市价|盘前|盘后)
//	@param key
//	@return []byte
//	@return error
func GetShareJpyCache(key string) ([]byte, error) {
	inrP, err := ShareJpyPriceSetUp.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		inrS, errs := ShareJpyCache.Get(key)
		if errs != nil {
			return []byte{}, err
		}
		return inrS, nil
	}

	return inrP, nil
}
func GetShareJpyCacheWs(key string) ([]byte, error) {
	inrP, err := ShareJpyCache.Get(key)
	if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
		return []byte{}, err
	}

	return inrP, nil
}