package casino

import (
	"testing"
)

func TestAddCreditsChecked(t *testing.T) {
	sum, err := AddCredits(5, 7)
	if err != nil || sum != 12 {
		t.Fatalf("AddCredits(5,7) = %d, %v", sum, err)
	}
	if sum, err := AddCredits(MaxCredits, 1); err == nil || sum != MaxCredits {
		t.Fatalf("overflow add: %d, %v", sum, err)
	}
	if _, err := AddCredits(MaxCredits, -1); err == nil {
		t.Fatal("negative add must be rejected")
	}
}

func TestMulPayoutBoundsAndConverts(t *testing.T) {
	payout, err := MulPayout(10, 1.5)
	if err != nil || payout != 15 {
		t.Fatalf("MulPayout(10,1.5) = %d, %v", payout, err)
	}
	// Floor conversion: 10 * 0.333 = 3.33 -> 3.
	if payout, _ := MulPayout(10, 0.333); payout != 3 {
		t.Fatalf("floor conversion: %d", payout)
	}
	if payout, err := MulPayout(MaxCredits, 2); err == nil || payout != MaxCredits {
		t.Fatalf("overflow payout: %d, %v", payout, err)
	}
	if payout, err := MulPayout(MaxCredits, 0.5); err != nil || payout != MaxCredits/2 {
		t.Fatalf("half of max: %d, %v", payout, err)
	}
	for _, bad := range []float64{-1, inf(), nan()} {
		if payout, err := MulPayout(10, bad); err == nil || payout != 0 {
			t.Fatalf("multiplier %v accepted: %d, %v", bad, payout, err)
		}
	}
	if payout, _ := MulPayout(0, 2); payout != 0 {
		t.Fatalf("zero-amount payout = %d", payout)
	}
}

func TestWalletErrorMessages(t *testing.T) {
	if got := walletErrorMessage(ErrInsufficientFunds, "Custom short balance."); got != "Custom short balance." {
		t.Fatalf("insufficient funds rendering: %q", got)
	}
	if got := walletErrorMessage(ErrWalletPersistence); !errContains(got, "persistence failure") || errContains(got, "insufficient") {
		t.Fatalf("persistence rendering must be distinct: %q", got)
	}
	if got := walletErrorMessage(ErrInsufficientFunds); got == "" {
		t.Fatal("default message missing")
	}
}

func inf() float64 {
	max := 1e308
	return max * 10
}
func nan() float64 { return inf() - inf() }

func errContains(value, fragment string) bool {
	return len(value) >= len(fragment) && (value == fragment || len(fragment) == 0 || indexOf(value, fragment) >= 0)
}

func indexOf(haystack, needle string) int {
	for i := 0; i+len(needle) <= len(haystack); i++ {
		if haystack[i:i+len(needle)] == needle {
			return i
		}
	}
	return -1
}