data.go

package main

import (
	"context"
	"fmt"
	"path/filepath"
	"strings"
	"time"

	"github.com/pkg/errors"
	log "github.com/sirupsen/logrus"

	"github.com/DavidArthurCole/EggLedger/api"
	"github.com/DavidArthurCole/EggLedger/db"
	"github.com/DavidArthurCole/EggLedger/ei"
)

var _dbPath string

func dataInit() {
	_dbPath = filepath.Join(_internalDir, "data.db")
	if err := db.InitDB(_dbPath); err != nil {
		log.Fatal("dataInit() err: ", err)
	}
}

func fetchFirstContactWithContext(ctx context.Context, playerId string) (*ei.EggIncFirstContactResponse, error) {
	action := fmt.Sprintf("fetching backup for player %s", playerId)
	wrap := func(err error) error {
		return errors.Wrap(err, "error "+action)
	}
	payload, err := api.RequestFirstContactRawPayloadWithContext(ctx, playerId)
	if err != nil {
		return nil, wrap(err)
	}
	fc, err := api.DecodeFirstContactPayload(payload)
	if err != nil {
		return nil, wrap(err)
	}
	if err := fc.Validate(); err != nil {
		return nil, errors.Wrap(wrap(err), "please double check your ID")
	}
	_storage.SetLastKnownGoodApiVersion(api.AppVersion)
	timestamp := fc.GetBackup().GetSettings().GetLastBackupTime()
	if timestamp != 0 {
		if err := db.InsertBackup(ctx, playerId, timestamp, payload, 12*time.Hour); err != nil {
			// Treat as non-fatal error for now.
			log.Error(err)
		}
	} else {
		log.Warnf("%s: .backup.settings.last_backup_time is 0", playerId)
	}
	return fc, nil
}

func fetchCompleteMissionWithContext(ctx context.Context, playerId string, missionId string, startTimestamp float64, tracker func(string, string)) (*ei.CompleteMissionResponse, error) {
	action := fmt.Sprintf("fetching mission %s for player %s", missionId, playerId)
	wrap := func(err error) error {
		return errors.Wrap(err, "error "+action)
	}
	track := func(name, status string) {
		if tracker != nil {
			tracker(name, status)
		}
	}
	track("Cache", "active")
	resp, err := db.RetrieveCompleteMission(ctx, playerId, missionId)
	if err != nil {
		track("Cache", "failed")
		return nil, wrap(err)
	}
	if resp != nil {
		track("Cache", "done")
		return resp, nil
	}
	track("Cache", "skipped")
	track("Fetch", "active")
	payload, err := api.RequestCompleteMissionRawPayloadWithContext(ctx, playerId, missionId)
	if err != nil {
		track("Fetch", "failed")
		return nil, wrap(err)
	}
	track("Fetch", "done")
	track("Decode", "active")
	resp, err = api.DecodeCompleteMissionPayload(payload)
	if err != nil {
		track("Decode", "failed")
		return nil, wrap(err)
	}
	if !resp.GetSuccess() {
		track("Decode", "failed")
		return nil, wrap(errors.New("success is false"))
	}
	if len(resp.GetArtifacts()) == 0 {
		track("Decode", "failed")
		return nil, wrap(errors.New("no artifact found in server response"))
	}
	track("Decode", "done")
	track("Store", "active")
	missionType := int32(resp.GetInfo().GetType())
	_nominalShipCapacitiesOnce.Do(initNominalShipCapacities)
	cols, _ := computeMissionFilterCols(startTimestamp, resp)
	err = db.InsertCompleteMission(ctx, playerId, missionId, startTimestamp, payload, missionType, cols)
	if err != nil {
		track("Store", "failed")
		return resp, err
	}
	dropRows := buildArtifactDropRows(resp)
	if insertErr := db.InsertArtifactDrops(ctx, playerId, missionId, dropRows); insertErr != nil {
		log.Errorf("failed to insert artifact drops for mission %s: %v", missionId, insertErr)
	}
	track("Store", "done")
	return resp, nil
}

// buildArtifactDropRows converts artifacts from a CompleteMissionResponse into
// ArtifactDropRow values ready for DB insertion. DropIndex matches the 0-based
// position in the repeated field, aligning with the migration 7 UNIQUE constraint.
func buildArtifactDropRows(resp *ei.CompleteMissionResponse) []db.ArtifactDropRow {
	artifacts := resp.GetArtifacts()
	drops := make([]db.ArtifactDropRow, 0, len(artifacts))
	for i, drop := range artifacts {
		spec := drop.GetSpec()
		name := ei.ArtifactSpec_Name_name[int32(spec.GetName())]
		var specType string
		switch {
		case strings.Contains(name, "_FRAGMENT"):
			specType = "StoneFragment"
		case strings.Contains(name, "_STONE"):
			specType = "Stone"
		case strings.Contains(name, "GOLD_METEORITE"),
			strings.Contains(name, "SOLAR_TITANIUM"),
			strings.Contains(name, "TAU_CETI_GEODE"):
			specType = "Ingredient"
		default:
			specType = "Artifact"
		}
		var quality float64
		for _, art := range _eiAfxConfigArtis {
			if art.GetSpec().GetName() == spec.GetName() &&
				art.GetSpec().GetLevel() == spec.GetLevel() &&
				art.GetSpec().GetRarity() == spec.GetRarity() {
				quality = art.GetBaseQuality()
				break
			}
		}
		drops = append(drops, db.ArtifactDropRow{
			DropIndex:  int32(i),
			ArtifactId: int32(spec.GetName()),
			SpecType:   specType,
			Level:      int32(spec.GetLevel()),
			Rarity:     int32(spec.GetRarity()),
			Quality:    quality,
		})
	}
	return drops
}