package storage

import (
	"github.com/Fuwn/plutia/internal/types"
	"testing"
	"time"
)

func TestPebbleStoreApplyOperationBatch(t *testing.T) {
	tmp := t.TempDir()
	store, err := OpenPebble(tmp)

	if err != nil {
		t.Fatalf("open pebble: %v", err)
	}

	defer store.Close()

	state := types.StateV1{
		Version:      1,
		DID:          "did:plc:test",
		DIDDocument:  []byte(`{"id":"did:plc:test"}`),
		ChainTipHash: "bafy-state-tip",
		LatestOpSeq:  42,
		UpdatedAt:    time.Now().UTC(),
	}
	ref := &types.BlockRefV1{
		Version: 1,
		BlockID: 9,
		Offset:  123,
		Length:  456,
		OpSeq:   42,
		DID:     "did:plc:test",
		CID:     "bafy-op-cid",
		OpHash:  "bafy-op-hash",
	}

	if err := store.ApplyOperationBatch(state, ref, true); err != nil {
		t.Fatalf("apply operation batch: %v", err)
	}

	gotState, ok, err := store.GetState(state.DID)

	if err != nil || !ok {
		t.Fatalf("get state: ok=%v err=%v", ok, err)
	}

	if gotState.ChainTipHash != state.ChainTipHash || gotState.LatestOpSeq != state.LatestOpSeq {
		t.Fatalf("state mismatch: got tip=%s seq=%d", gotState.ChainTipHash, gotState.LatestOpSeq)
	}

	head, ok, err := store.GetChainHead(state.DID)

	if err != nil || !ok || head != state.LatestOpSeq {
		t.Fatalf("chain head mismatch: head=%d ok=%v err=%v", head, ok, err)
	}

	seqs, err := store.ListDIDSequences(state.DID)

	if err != nil {
		t.Fatalf("list did sequences: %v", err)
	}

	if len(seqs) != 1 || seqs[0] != state.LatestOpSeq {
		t.Fatalf("did sequence mismatch: %v", seqs)
	}

	gotRef, ok, err := store.GetOpSeqRef(state.LatestOpSeq)

	if err != nil || !ok {
		t.Fatalf("get opseq ref: ok=%v err=%v", ok, err)
	}

	if gotRef.BlockID != ref.BlockID || gotRef.CID != ref.CID {
		t.Fatalf("op ref mismatch: got block=%d cid=%s", gotRef.BlockID, gotRef.CID)
	}

	globalSeq, err := store.GetGlobalSeq()

	if err != nil || globalSeq != state.LatestOpSeq {
		t.Fatalf("global seq mismatch: seq=%d err=%v", globalSeq, err)
	}
}