mlblive/main.go

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"os"
	"strconv"
	"time"

	"github.com/evanphx/json-patch/v5"
	"scm.dairydemon.net/filifa/mlblive/internal/statsapi"
)

func writeTest(v any, ts string) {
	b, err := json.Marshal(v)
	if err != nil {
		log.Println(err)
	}

	os.WriteFile("examples/data/data_"+ts+".json", b, 0644)
}

func getGamePk() string {
	teamId := flag.String("t", "", "team to get updates for")
	flag.Parse()
	if *teamId == "" {
		log.Fatal("need team ID")
	}

	id, ok := statsapi.TeamIds[*teamId]
	if !ok {
		log.Fatal("invalid team ID")
	}

	sched, err := statsapi.RequestSchedule("1", strconv.Itoa(id))
	if err != nil {
		log.Fatal(err)
	}

	var s statsapi.Schedule
	err = json.Unmarshal(sched, &s)
	if err != nil {
		log.Fatal(err)
	}

	gamePk := s.Dates[0].Games[0].GamePk.String()
	return gamePk
}

func extractPatches(diffPatch []byte) ([]jsonpatch.Patch, error) {
	var patches []jsonpatch.Patch
	var objs []any
	err := json.Unmarshal(diffPatch, &objs)
	if err != nil {
		return patches, err
	}

	for _, obj := range objs {
		diff := obj.(map[string]any)["Diff"]
		patch, err := json.Marshal(diff)
		if err != nil {
			return patches, err
		}

		p, err := jsonpatch.DecodePatch(patch)
		if err != nil {
			return patches, err
		}
		patches = append(patches, p)
	}

	return patches, nil
}

func updateFeed(feedResp []byte, gamePk string, ts string, updateId string) ([]byte, error) {
	diffPatchResp, err := statsapi.RequestDiffPatch(gamePk, ts, updateId)
	patches, err := extractPatches(diffPatchResp)
	if err != nil {
		feedResp, err = statsapi.RequestFeed(gamePk)
		if err != nil {
			return feedResp, err
		}
	} else {
		for _, patch := range patches {
			feedResp, err = patch.Apply(feedResp)
			if err != nil {
				return feedResp, err
			}
		}
	}

	return feedResp, err
}

func main() {
	gamePk := getGamePk()

	ws, err := statsapi.NewGamedayWebsocket(gamePk)
	if err != nil {
		log.Fatal(err)
	}
	defer ws.Close()

	ch := make(chan error)
	go ws.KeepAlive(10*time.Second, ch)

	feedResp, err := statsapi.RequestFeed(gamePk)
	if err != nil {
		log.Fatal(err)
	}

	var feed statsapi.Feed
	err = json.Unmarshal(feedResp, &feed)
	if err != nil {
		log.Fatal(err)
	}

	var game Game
	game.Update(&feed)

	ts := feed.MetaData.TimeStamp

	for {
		var p statsapi.Push
		err = ws.ReadJSON(&p)
		if err != nil {
			log.Fatal(err)
		}

		feedResp, err = updateFeed(feedResp, gamePk, ts, p.UpdateId)
		if err != nil {
			log.Fatal(err)
		}

		err = json.Unmarshal(feedResp, &feed)
		if err != nil {
			log.Fatal(err)
		}

		ts = feed.MetaData.TimeStamp

		game.Update(&feed)
		fmt.Println(game)
	}
}