package assets

import (
    "context"
    "sync"
    "tr-backend/shared/logger"
    "tr-backend/shared/proto/feed"
    "google.golang.org/grpc"
)

type cache struct {
    assets map[string]*Asset
}

func (c *cache) Get(asset string) *Asset {
    return c.assets[asset]
}

var Cache cache

func fetchAsset(client pbFeed.PairFeedClient, asset string) {
    stream, err := client.GetPairFeed(context.Background(), &pbFeed.Pair{Id: asset})
    if err != nil {
        logger.L.Fatalf("Cant connect stream %+v err: %+v", asset, err)
    }
    logger.L.Debugf("STREAM: %+v", asset)
    go func() {
        for {
            f, err := stream.Recv()
            if err != nil {
                logger.L.Errorf("Stream err: %+v", err)
                return
            }
            logger.L.Debugf("DEBUG: %+v , %+v", f, asset)
        }
    }()
}

func StartCache() {
    Cache = cache{
        assets: map[string]*Asset{},
    }

    var all = []string{
        "DEMO",
        "EURUSD",
        "USDJPY",
        "GBPUSD",
        "AUDUSD",
        "USDCHF",
        "NZDUSD",
        "NZDUSD",
    }
    for _, asset := range all {
        Cache.assets[asset] = &Asset{
            RWMutex:      sync.RWMutex{},
            frames:       map[int]*Frame{},
            currentFrame: []*Value{},
        }
    }

    conn, err := grpc.Dial("app1.tradingrooms.com:8182", grpc.WithInsecure())

    if err != nil {
        logger.L.Fatalf("Cant connect to pair feed: %+v", err)
    }
    client := pbFeed.NewPairFeedClient(conn)

    fetchAsset(client, "DEMO")
}

type Asset struct {
    sync.RWMutex
    currentFrame []*Value
    frames map[int]*Frame
}

func(a *Asset) LastValue() {

}

func(a *Asset) AppendValue() {

}

type Frame struct {
    data []Value
}

type Value struct {
    Timestamp int64
    JSON      []byte
}