package shreder

import (
	"context"
	"encoding/hex"
	"os"
	"testing"

	"github.com/gagliardetto/solana-go"
	"github.com/gagliardetto/solana-go/rpc"
	"github.com/near/borsh-go"
)

func TestDecodeAxiomArgs(t *testing.T) {
	tests := []struct {
		name    string
		hexData string
	}{
		{
			name:    "pump amm sell Test 0",
			hexData: "00686f08bb1b0000007eb4ac020000000001020200183c",
		},
		{
			name:    "pump amm buy Test 1",
			hexData: "00c09ee6050000000001c94d882600000000020200323c",
		},
		{
			name:    "pump buy Test 2",
			hexData: "00d8d3bc0000000000bb7c53f009000000000104185a",
		},
		{
			name:    "pump sell Test 3",
			hexData: "009bbf69ec08080000830bc61200000000010103a000",
		},
		{
			name:    "pump swap sell Test 4",
			hexData: "00c98ea7588b0000009adf3b010000000001020200283c",
		},
		{
			name:    "pump swap sell Test 5",
			hexData: "00d3727f9301000000f9a50b0100000000010202001e00",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			data, err := hex.DecodeString(tt.hexData)
			if err != nil {
				t.Fatalf("failed to decode hex string: %v", err)
				return
			}
			var args flasArgs
			if err := borsh.Deserialize(&args, data[1:]); err != nil {
				t.Fatalf("failed to decode Axiom args: %v", err)
				return
			}
			t.Logf("Decoded Axiom Args: %+v", args)
		})
	}
}

func toUpdata(slot uint64, tx *solana.Transaction) *SubscribeUpdateTransaction {
	signatures := make([][]byte, len(tx.Signatures))
	for i, sig := range tx.Signatures {
		signatures[i] = sig[:]
	}

	accountKeys := make([][]byte, len(tx.Message.AccountKeys))
	for i, key := range tx.Message.AccountKeys {
		accountKeys[i] = key[:]
	}

	instructions := make([]*CompiledInstruction, len(tx.Message.Instructions))
	for i, instr := range tx.Message.Instructions {
		accounts := make([]byte, len(instr.Accounts))
		for j, acc := range instr.Accounts {
			accounts[j] = byte(acc)
		}
		instructions[i] = &CompiledInstruction{
			ProgramIdIndex: uint32(instr.ProgramIDIndex),
			Accounts:       accounts,
			Data:           instr.Data[:],
		}
	}

	addressTableLookups := make([]*MessageAddressTableLookup, len(tx.Message.AddressTableLookups))
	for i, lookup := range tx.Message.AddressTableLookups {
		writable := make([]byte, len(lookup.WritableIndexes))
		for j, idx := range lookup.WritableIndexes {
			writable[j] = byte(idx)
		}
		readonly := make([]byte, len(lookup.ReadonlyIndexes))
		for j, idx := range lookup.ReadonlyIndexes {
			readonly[j] = byte(idx)
		}
		addressTableLookups[i] = &MessageAddressTableLookup{
			AccountKey:      lookup.AccountKey[:],
			WritableIndexes: writable,
			ReadonlyIndexes: readonly,
		}
	}

	return &SubscribeUpdateTransaction{
		Transaction: &Transaction{
			Signatures: signatures,
			Message: &Message{
				Header: &MessageHeader{
					NumRequiredSignatures:       uint32(tx.Message.Header.NumRequiredSignatures),
					NumReadonlySignedAccounts:   uint32(tx.Message.Header.NumReadonlySignedAccounts),
					NumReadonlyUnsignedAccounts: uint32(tx.Message.Header.NumReadonlyUnsignedAccounts),
				},
				AccountKeys:         accountKeys,
				RecentBlockhash:     nil, // TODO
				Instructions:        instructions,
				Versioned:           false, // TODO
				AddressTableLookups: addressTableLookups,
			},
		},
		Slot: slot,
	}
}

func TestParseTerm(t *testing.T) {
	rpcUrl := os.Getenv("SOL_RPC_URL")
	if rpcUrl == "" {
		t.Fatalf("SOL_RPC_URL is not set")
	}

	client := rpc.New(rpcUrl)
	version := uint64(0)
	tx, err := client.GetTransaction(
		context.Background(),
		solana.MustSignatureFromBase58("5Gz1fa4Qhb35bkg9QCMXpxCX5uuNr7WcjcmrwajGZA7kXsvNS9pDnYe12ggWeSqf1nwZbVPob6DkX6fcwbE9ofBR"),
		&rpc.GetTransactionOpts{
			Commitment:                     rpc.CommitmentFinalized,
			MaxSupportedTransactionVersion: &version,
		},
	)
	if err != nil {
		t.Fatalf("failed to get transaction: %v", err)
	}

	_tx, err := tx.Transaction.GetTransaction()
	if err != nil {
		t.Fatalf("failed to get transaction: %v", err)
	}

	signals := ParseTransaction(toUpdata(tx.Slot, _tx), nil, false)
	if len(signals) != 1 {
		t.Fatalf("expected 1 signal, got %d", len(signals))
	}

	signal := signals[0]
	if signal.Label != "terminal" {
		t.Fatalf("expected terminal signal, got %s", signal.Label)
	}
	if signal.Event != "buy" {
		t.Fatalf("expected buy event, got %s", signal.Event)
	}
	if signal.Maker != "BaLxyjXzATAnfm7cc5AFhWBpiwnsb71THcnofDLTWAPK" {
		t.Fatalf("expected maker BaLxyjXzATAnfm7cc5AFhWBpiwnsb71THcnofDLTWAPK, got %s", signal.Maker)
	}
	if signal.Token0Address != "5Wgv54peXRKDHYHapAELzgNKEPEh9E5Bf3hUR3sTpump" {
		t.Fatalf("expected token0 address 5Wgv54peXRKDHYHapAELzgNKEPEh9E5Bf3hUR3sTpump, got %s", signal.Token0Address)
	}
}