// cache.go
package cache

import (
	"context"
	"encoding/json"
	"log"
	"strconv"
	"time"

	"github.com/redis/go-redis/v9"
)

// reference, do not delete that
/*type CacheServer struct {
	Submits int64 `json:"submits"`
	Blocks  int64 `json:"blocks"`

	Accepts float64 `json:"accepts"`
	Rejects int64   `json:"rejects"`
	Shares  int64   `json:"shares"`

	Rewards float64 `json:"reward"`
	Fees    float64 `json:"fee"`

	RefDiff float64 `json:"refdiff"`

	//LastSubmit int64 `json:"lastsubmit"`
}

type CacheUser struct {
	Submits int64 `json:"submits"`
	Blocks  int64 `json:"blocks"`

	Accepts float64 `json:"accepts"`
	Rejects int64   `json:"rejects"`
	Shares  int64   `json:"shares"`

	Rewards float64 `json:"reward"`
	Fees    float64 `json:"fee"`

	User string `json:"user"`
}

type CacheMhs struct {
	User  string `json:"user"`
	Miner string `json:"miner"`
	Index string `json:"index"`

	Accepts []CacheMhsItem `json:"accepts"`
	Rejects []CacheMhsItem `json:"rejects"`

	StartDayTime string `json:"startday"`
}

type CacheMiner struct {
	Submits int64 `json:"submits"`
	Blocks  int64 `json:"blocks"`

	Accepts float64 `json:"accepts"`
	Rejects int64   `json:"rejects"`
	Shares  int64   `json:"shares"`

	LastDiff float64 `json:"diff"`

	Rewards float64 `json:"reward"`
	Fees    float64 `json:"fee"`

	Retry int `json:"retry"`

	LastSubmit int64 `json:"lastsubmit"`

	User  string `json:"user"`
	Miner string `json:"miner"`
	Index string `json:"index"`

	ErrStaleds    int64 `json:"staleds"`
	ErrLowDiffs   int64 `json:"lowdiffs"`
	ErrDuplicates int64 `json:"duplicates"`
	ErrFormats    int64 `json:"formats"`
	ErrOthers     int64 `json:"others"`
}*/

// need used
type CacheMhsItem struct {
	Tt   string  `json:"Tt"`
	Diff float64 `json:"diff"`
}

/*
type CacheMinerItem struct {
	User  string `json:"user"`
	Miner string `json:"miner"`
	Index string `json:"index"`
}*/

func LoadIntCache(client *redis.Client, key_int string) int64 {
	val, err := client.Get(context.Background(), key_int).Result()
	if err != nil {
		log.Printf("[LoadIntCache]Error retrieving data from Redis: %s, %v\n", key_int, err)
		return 0
	}
	val_int, err := strconv.ParseInt(val, 10, 64)
	if err != nil {
		log.Printf("[LoadIntCache]Error parsing integer from string: %v\n", err)
		return 0
	}
	return val_int
}

func StoreIntCache(client *redis.Client, key string, intNumber int64) bool {
	numberStr := strconv.FormatInt(intNumber, 10)
	expiration := 7 * 24 * time.Hour
	err := client.Set(context.Background(), key, numberStr, expiration).Err()
	if err != nil {
		log.Printf("[StoreIntCache]Error storing data in Redis: %s, %v\n", key, err)
		return false
	}
	return true
}

func LoadFloatCache(client *redis.Client, key_float string) float64 {
	val, err := client.Get(context.Background(), key_float).Result()
	if err != nil {
		log.Printf("[LoadFloatCache]Error retrieving data from Redis: %s, %v\n", key_float, err)
		return 0
	}
	val_f, err := strconv.ParseFloat(val, 64)
	if err != nil {
		log.Printf("[LoadFloatCache]Error parsing float from string: %v\n", err)
		return 0
	}
	return val_f
}

func StoreFloatCache(client *redis.Client, key string, floatNumber float64) bool {
	numberStr := strconv.FormatFloat(floatNumber, 'f', -1, 64)
	expiration := 7 * 24 * time.Hour
	err := client.Set(context.Background(), key, numberStr, expiration).Err()
	if err != nil {
		log.Printf("[StoreFloatCache]Error storing data in Redis: %s, %v\n", key, err)
		return false
	}
	return true
}

func LoadStringCache(client *redis.Client, keyStr string) string {
	val, err := client.Get(context.Background(), keyStr).Result()
	if err != nil {
		log.Printf("[LoadStringCache]Error retrieving data from Redis: %s, %v\n", keyStr, err)
		return ""
	}
	return val
}

func StoreStringCache(client *redis.Client, key string, strValue string) bool {
	expiration := 7 * 24 * time.Hour
	err := client.Set(context.Background(), key, strValue, expiration).Err()
	if err != nil {
		log.Printf("[StoreStringCache]Error storing data in Redis: %s, %v\n", key, err)
		return false
	}
	return true
}

func LoadTimeCache(client *redis.Client, keyTime string) (time.Time, bool) {
	val, err := client.Get(context.Background(), keyTime).Result()
	if err != nil {
		log.Printf("[LoadTimeCache]Error retrieving data from Redis: %s, %v\n", keyTime, err)
		return time.Time{}, false
	}

	t, err := time.Parse(time.RFC3339, val)
	if err != nil {
		log.Printf("[LoadTimeCache]Error parsing time from string: %v\n", err)
		return time.Time{}, false
	}

	return t, true
}

func StoreTimeCache(client *redis.Client, key string, timeValue time.Time) bool {
	numberStr := timeValue.Format(time.RFC3339)
	expiration := 7 * 24 * time.Hour
	err := client.Set(context.Background(), key, numberStr, expiration).Err()
	if err != nil {
		log.Printf("[StoreTimeCache]Error storing data in Redis: %s, %v\n", key, err)
		return false
	}
	return true
}

func LoadPoolCache(client *redis.Client, coin string, pool_key string) interface{} {
	k := "pool_" + coin + "_" + pool_key
	switch pool_key {
	case "submits", "blocks", "rejects":
		return LoadIntCache(client, k)
	case "accepts", "rewards", "fee", "refdiff":
		return LoadFloatCache(client, k)
	default:
		log.Printf("[LoadPoolCache]Unknown pool_key: %s\n", pool_key)
		return nil
	}
}

func StorePoolCache(client *redis.Client, coin string, pool_key string, val interface{}) bool {
	k := "pool_" + coin + "_" + pool_key

	switch pool_key {
	case "submits", "blocks", "rejects":
		if pool_key == "rejects" {
			if intVal, ok := val.(float64); ok {
				return StoreIntCache(client, k, int64(intVal))
			}
		} else {
			if intVal, ok := val.(int64); ok {
				return StoreIntCache(client, k, intVal)
			}
		}
		log.Printf("[StorePoolCache]Invalid type for key %s: expected int64, got %T\n", pool_key, val)
		return false
	case "accepts", "rewards", "fee", "refdiff":
		if floatVal, ok := val.(float64); ok {
			return StoreFloatCache(client, k, floatVal)
		}
		log.Printf("[StorePoolCache]Invalid type for key %s: expected float64, got %T\n", pool_key, val)
		return false
	default:
		log.Printf("[StorePoolCache]Unknown pool_key: %s\n", pool_key)
		return false
	}
}

/*
func LoadUserCache(client *redis.Client, coin string, user string, pool_key string) interface{} {
	k := "pool_" + coin + "_" + user + "_" + pool_key
	switch pool_key {
	case "submits", "blocks", "rejects":
		return LoadIntCache(client, k)
	case "accepts", "rewards", "fee":
		return LoadFloatCache(client, k)
	default:
		log.Printf("Unknown pool_key: %s\n", pool_key)
		return nil
	}
}

func StoreUserCache(client *redis.Client, coin string, user string, pool_key string, val interface{}) bool {
	k := "pool_" + coin + "_" + user + "_" + pool_key

	switch pool_key {
	case "submits", "blocks", "rejects":
		if intVal, ok := val.(int64); ok {
			return StoreIntCache(client, k, intVal)
		}
		log.Printf("Invalid type for key %s: expected int64, got %T\n", pool_key, val)
		return false
	case "accepts", "rewards", "fee":
		if floatVal, ok := val.(float64); ok {
			return StoreFloatCache(client, k, floatVal)
		}
		log.Printf("Invalid type for key %s: expected float64, got %T\n", pool_key, val)
		return false
	default:
		log.Printf("Unknown pool_key: %s\n", pool_key)
		return false
	}
}*/

func LoadMinerCache(client *redis.Client, coin string, user string, miner string, index string, pool_key string) interface{} {
	k := "pool_" + coin + "_" + user + "_" + miner + "_" + index + "_" + pool_key
	switch pool_key {
	case "submits", "blocks", "rejects", "retry", "staleds", "lowdiffs", "duplicates", "formats", "others":
		return LoadIntCache(client, k)
	case "accepts", "rewards", "fee", "diff":
		return LoadFloatCache(client, k)
	case "lastsubmit", "startsubmit":
		tT, ok := LoadTimeCache(client, k)
		if ok {
			return tT
		}
		return nil
	default:
		log.Printf("[LoadMinerCache]Unknown pool_key: %s\n", pool_key)
		return nil
	}
}

func StoreMinerCache(client *redis.Client, coin string, user string, miner string, index string, pool_key string, val interface{}) bool {
	k := "pool_" + coin + "_" + user + "_" + miner + "_" + index + "_" + pool_key

	switch pool_key {
	case "submits", "blocks", "rejects", "retry", "staleds", "lowdiffs", "duplicates", "formats", "others":
		if intVal, ok := val.(int64); ok {
			return StoreIntCache(client, k, intVal)
		}
		log.Printf("[StoreMinerCache]Invalid type for %s: expected int64, got %T\n", pool_key, val)
		return false

	case "accepts", "rewards", "fee", "diff":
		if floatVal, ok := val.(float64); ok {
			return StoreFloatCache(client, k, floatVal)
		}
		log.Printf("[StoreMinerCache]Invalid type for %s: expected float64, got %T\n", pool_key, val)
		return false

	case "lastsubmit", "startsubmit":
		if timeVal, ok := val.(time.Time); ok {
			return StoreTimeCache(client, k, timeVal)
		}
		log.Printf("[StoreMinerCache]Invalid type for %s: expected time.Time, got %T\n", pool_key, val)
		return false

	default:
		log.Printf("[StoreMinerCache]Unknown pool_key: %s\n", pool_key)
		return false
	}
}

func StoreCacheMhsItem(client *redis.Client, key string, item CacheMhsItem) bool {
	data, err := json.Marshal(item)
	if err != nil {
		log.Printf("[StoreCacheMhsItem]Error marshalling CacheMhsItem to JSON: %v\n", err)
		return false
	}

	err = client.RPush(context.Background(), key, data).Err()
	if err != nil {
		log.Printf("[StoreCacheMhsItem]Error pushing data to Redis list: %v\n", err)
		return false
	}

	expiration := 7 * 24 * time.Hour
	err = client.Expire(context.Background(), key, expiration).Err()
	if err != nil {
		log.Printf("[StoreCacheMhsItem] Error setting expiration for Redis key: %v\n", err)
		return false
	}

	return true
}

func PopCacheMhsItem(client *redis.Client, key string) (*CacheMhsItem, bool) {
	data, err := client.LPop(context.Background(), key).Result()
	if err != nil {
		log.Printf("[PopCacheMhsItem]Error retrieving data from Redis list: %v\n", err)
		return nil, false
	}

	var item CacheMhsItem
	if err = json.Unmarshal([]byte(data), &item); err != nil {
		log.Printf("[PopCacheMhsItem]Error unmarshalling JSON to CacheMhsItem: %v\n", err)
		return nil, false
	}

	return &item, true
}

func RemoveMhsCache(client *redis.Client, coin string, user string, miner string, index string, key string) bool {
	k := "mhs_" + coin + "_" + user + "_" + miner + "_" + index + "_" + key
	switch key {
	case "accepts", "rejects":
		PopCacheMhsItem(client, k)
		return true
	}
	return false
}

func LoadMhsCache(client *redis.Client, coin string, user string, miner string, index string, key string) interface{} {
	k := "mhs_" + coin + "_" + user + "_" + miner + "_" + index + "_" + key
	switch key {
	case "starttime":
		tT, ok := LoadTimeCache(client, k)
		if ok {
			return tT
		}
		return nil
	case "accepts", "rejects":
		/*listLength, err := client.LLen(context.Background(), k).Result()
		if err != nil {
			log.Printf("Error getting list length: %v\n", err)
			return nil
		}*/
		values, err := client.LRange(context.Background(), k, 0, -1).Result()
		if err != nil {
			log.Printf("[LoadMhsCache]Error getting list values: %v\n", err)
		}
		var items []CacheMhsItem
		for _, value := range values {
			var item CacheMhsItem
			if err = json.Unmarshal([]byte(value), &item); err != nil {
				continue
			}
			items = append(items, item)
		}
		return &items
	default:
		return nil
	}
}

func StoreMhsCache(client *redis.Client, coin string, user string, miner string, index string, key string, val interface{}) bool {
	k := "mhs_" + coin + "_" + user + "_" + miner + "_" + index + "_" + key
	switch key {
	case "starttime":
		if t, ok := val.(time.Time); ok {
			return StoreTimeCache(client, k, t)
		}
		log.Printf("[StoreMhsCache]Invalid type for starttime: expected time.Time, got %T\n", val)
		return false
	case "accepts", "rejects":
		if item, ok := val.(CacheMhsItem); ok {
			return StoreCacheMhsItem(client, k, item)
		}
		log.Printf("[StoreMhsCache]Invalid type for CacheMhsItem: expected CacheMhsItem, got %T\n", val)
		return false
	default:
		log.Printf("[StoreMhsCache]Unknown key: %s\n", key)
		return false
	}
}

/*
func StoreStringToSet(client *redis.Client, setKey string, value string) bool {
	err := client.SAdd(context.Background(), setKey, value).Err()
	if err != nil {
		log.Printf("Error adding value to Redis set: %v\n", err)
		return false
	}
	return true
}

func LoadStringsFromSet(client *redis.Client, setKey string) ([]string, bool) {
	members, err := client.SMembers(context.Background(), setKey).Result()
	if err != nil {
		log.Printf("Error retrieving data from Redis set: %v\n", err)
		return nil, false
	}
	return members, true
}

func RemoveStringFromSet(client *redis.Client, setKey string, value string) bool {
	err := client.SRem(context.Background(), setKey, value).Err()
	if err != nil {
		log.Printf("Error removing value from Redis set: %v\n", err)
		return false
	}
	return true
}

func LoadUsersCache(client *redis.Client, coin string) []string {
	k := "pool_" + coin + "_users"
	users, ok := LoadStringsFromSet(client, k)
	if !ok {
		log.Printf("Error loading users slice from Redis for coin: %s\n", coin)
		return []string{}
	}
	return users
}

func StoreUsersCache(client *redis.Client, coin string, user string) bool {
	k := "pool_" + coin + "_users"
	ok := StoreStringToSet(client, k, user)
	if !ok {
		log.Printf("Error storing users slice to Redis for coin: %s\n", coin)
		return false
	}
	return true
}
*/
/*
func StoreCacheMinerItem(client *redis.Client, setKey string, item CacheMinerItem) bool {
	data, err := json.Marshal(item)
	if err != nil {
		log.Printf("Error marshalling CacheMinerItem to JSON: %v\n", err)
		return false
	}

	err = client.SAdd(context.Background(), setKey, data).Err()
	if err != nil {
		log.Printf("Error adding data to Redis set: %v\n", err)
		return false
	}

	return true
}

func LoadCacheMinerItems(client *redis.Client, setKey string) ([]CacheMinerItem, bool) {
	data, err := client.SMembers(context.Background(), setKey).Result()
	if err != nil {
		log.Printf("Error retrieving data from Redis set: %v\n", err)
		return nil, false
	}

	var items []CacheMinerItem
	for _, itemData := range data {
		var item CacheMinerItem
		err := json.Unmarshal([]byte(itemData), &item)
		if err != nil {
			log.Printf("Error unmarshalling JSON to CacheMinerItem: %v\n", err)
			return nil, false
		}
		items = append(items, item)
	}

	return items, true
}

func RemoveCacheMinerItem(client *redis.Client, setKey string, item CacheMinerItem) bool {

	data, err := json.Marshal(item)
	if err != nil {
		log.Printf("Error marshalling CacheMinerItem to JSON: %v\n", err)
		return false
	}

	err = client.SRem(context.Background(), setKey, data).Err()
	if err != nil {
		log.Printf("Error removing data from Redis set: %v\n", err)
		return false
	}

	return true
}

func LoadMinersCache(client *redis.Client, coin string) []CacheMinerItem {
	k := "pool_" + coin + "_miners"
	miners, ok := LoadCacheMinerItems(client, k)
	if !ok {
		log.Printf("Error loading miners set from Redis for coin: %s\n", coin)
		return []CacheMinerItem{}
	}
	return miners
}

func StoreMinersCache(client *redis.Client, coin string, miner CacheMinerItem) bool {
	k := "pool_" + coin + "_miners"
	ok := StoreCacheMinerItem(client, k, miner)
	if !ok {
		log.Printf("Error storing miners slice to Redis for coin: %s\n", coin)
		return false
	}
	return true
}
*/
