package result

// import (
// 	"fmt"
// 	"testing"
// 	"time"

// 	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
// 	"github.com/stretchr/testify/assert"
// )

// // TestNFLMarkets covers all American Football (NFL) market types defined in the domain.
// // For each market (Money Line, Spread, Total Points), it tests home/away win, draw, void, and invalid input scenarios.
// func TestNFLMarkets(t *testing.T) {
// 	t.Log("Testing NFL (American Football) Markets")
// 	markets := []struct {
// 		marketID int64
// 		name     string
// 	}{
// 		{int64(domain.AMERICAN_FOOTBALL_MONEY_LINE), "MONEY_LINE"},
// 		{int64(domain.AMERICAN_FOOTBALL_SPREAD), "SPREAD"},
// 		{int64(domain.AMERICAN_FOOTBALL_TOTAL_POINTS), "TOTAL_POINTS"},
// 	}

// 	for _, m := range markets {
// 		t.Run(m.name, func(t *testing.T) {
// 			// Each subtest below covers a key scenario for the given NFL market.
// 			switch m.marketID {
// 			case int64(domain.AMERICAN_FOOTBALL_MONEY_LINE):
// 				// Home win, away win, draw, and invalid OddHeader for Money Line
// 				t.Run("Home Win", func(t *testing.T) {
// 					status, err := EvaluateNFLMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 21, Away: 14})
// 					t.Logf("Market: %s, Scenario: Home Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Away Win", func(t *testing.T) {
// 					status, err := EvaluateNFLMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2"}, struct{ Home, Away int }{Home: 14, Away: 21})
// 					t.Logf("Market: %s, Scenario: Away Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Draw", func(t *testing.T) {
// 					status, err := EvaluateNFLMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 17, Away: 17})
// 					t.Logf("Market: %s, Scenario: Draw", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_LOSS, status)
// 				})
// 				t.Run("Invalid OddHeader", func(t *testing.T) {
// 					status, err := EvaluateNFLMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "X"}, struct{ Home, Away int }{Home: 10, Away: 7})
// 					t.Logf("Market: %s, Scenario: Invalid OddHeader", m.name)
// 					assert.Error(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// 				})
// 			case int64(domain.AMERICAN_FOOTBALL_SPREAD):
// 				t.Run("Home Win with Handicap", func(t *testing.T) {
// 					status, err := EvaluateNFLSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "-3.5"}, struct{ Home, Away int }{Home: 24, Away: 20})
// 					t.Logf("Market: %s, Scenario: Home Win with Handicap", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Away Win with Handicap", func(t *testing.T) {
// 					status, err := EvaluateNFLSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2", OddHandicap: "+3.5"}, struct{ Home, Away int }{Home: 20, Away: 24})
// 					t.Logf("Market: %s, Scenario: Away Win with Handicap", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Push (Void)", func(t *testing.T) {
// 					status, err := EvaluateNFLSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "0"}, struct{ Home, Away int }{Home: 21, Away: 21})
// 					t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// 				})
// 				t.Run("Non-numeric Handicap", func(t *testing.T) {
// 					status, err := EvaluateNFLSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "notanumber"}, struct{ Home, Away int }{Home: 21, Away: 14})
// 					t.Logf("Market: %s, Scenario: Non-numeric Handicap", m.name)
// 					assert.Error(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// 				})
// 			case int64(domain.AMERICAN_FOOTBALL_TOTAL_POINTS):
// 				t.Run("Over Win", func(t *testing.T) {
// 					status, err := EvaluateNFLTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "44.5"}, struct{ Home, Away int }{Home: 30, Away: 20})
// 					t.Logf("Market: %s, Scenario: Over Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Under Win", func(t *testing.T) {
// 					status, err := EvaluateNFLTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Under", OddName: "44.5"}, struct{ Home, Away int }{Home: 20, Away: 17})
// 					t.Logf("Market: %s, Scenario: Under Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Push (Void)", func(t *testing.T) {
// 					status, err := EvaluateNFLTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "37"}, struct{ Home, Away int }{Home: 20, Away: 17})
// 					t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// 				})
// 				t.Run("Non-numeric OddName", func(t *testing.T) {
// 					status, err := EvaluateNFLTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "notanumber"}, struct{ Home, Away int }{Home: 20, Away: 17})
// 					t.Logf("Market: %s, Scenario: Non-numeric OddName", m.name)
// 					assert.Error(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// 				})
// 			}
// 		})
// 	}
// }

// // TestRugbyMarkets covers all Rugby (Union & League) market types defined in the domain.
// // For each market (Money Line, Spread, Handicap, Total Points), it tests home/away win, draw, void, and invalid input scenarios.
// func TestRugbyMarkets(t *testing.T) {
// 	t.Log("Testing Rugby Markets (Union & League)")
// 	markets := []struct {
// 		marketID int64
// 		name     string
// 	}{
// 		{int64(domain.RUGBY_MONEY_LINE), "MONEY_LINE"},
// 		{int64(domain.RUGBY_SPREAD), "SPREAD"},
// 		{int64(domain.RUGBY_TOTAL_POINTS), "TOTAL_POINTS"},
// 		{int64(domain.RUGBY_HANDICAP), "HANDICAP"},
// 	}

// 	for _, m := range markets {
// 		t.Run(m.name, func(t *testing.T) {
// 			// Each subtest below covers a key scenario for the given Rugby market.
// 			switch m.marketID {
// 			case int64(domain.RUGBY_MONEY_LINE):
// 				// Home win, away win, draw, and invalid OddHeader for Money Line
// 				t.Run("Home Win", func(t *testing.T) {
// 					status, err := EvaluateRugbyMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 30, Away: 20})
// 					t.Logf("Market: %s, Scenario: Home Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Away Win", func(t *testing.T) {
// 					status, err := EvaluateRugbyMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2"}, struct{ Home, Away int }{Home: 20, Away: 30})
// 					t.Logf("Market: %s, Scenario: Away Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Draw", func(t *testing.T) {
// 					status, err := EvaluateRugbyMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 25, Away: 25})
// 					t.Logf("Market: %s, Scenario: Draw", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_LOSS, status)
// 				})
// 				t.Run("Invalid OddHeader", func(t *testing.T) {
// 					status, err := EvaluateRugbyMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "X"}, struct{ Home, Away int }{Home: 10, Away: 7})
// 					t.Logf("Market: %s, Scenario: Invalid OddHeader", m.name)
// 					assert.Error(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// 				})
// 			case int64(domain.RUGBY_SPREAD), int64(domain.RUGBY_HANDICAP):
// 				t.Run("Home Win with Handicap", func(t *testing.T) {
// 					status, err := EvaluateRugbySpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "-6.5"}, struct{ Home, Away int }{Home: 28, Away: 20})
// 					t.Logf("Market: %s, Scenario: Home Win with Handicap", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Away Win with Handicap", func(t *testing.T) {
// 					status, err := EvaluateRugbySpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2", OddHandicap: "+6.5"}, struct{ Home, Away int }{Home: 20, Away: 28})
// 					t.Logf("Market: %s, Scenario: Away Win with Handicap", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Push (Void)", func(t *testing.T) {
// 					status, err := EvaluateRugbySpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "0"}, struct{ Home, Away int }{Home: 21, Away: 21})
// 					t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// 				})
// 				t.Run("Non-numeric Handicap", func(t *testing.T) {
// 					status, err := EvaluateRugbySpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "notanumber"}, struct{ Home, Away int }{Home: 21, Away: 14})
// 					t.Logf("Market: %s, Scenario: Non-numeric Handicap", m.name)
// 					assert.Error(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// 				})
// 			case int64(domain.RUGBY_TOTAL_POINTS):
// 				t.Run("Over Win", func(t *testing.T) {
// 					status, err := EvaluateRugbyTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "40.5"}, struct{ Home, Away int }{Home: 25, Away: 20})
// 					t.Logf("Market: %s, Scenario: Over Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Under Win", func(t *testing.T) {
// 					status, err := EvaluateRugbyTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Under", OddName: "40.5"}, struct{ Home, Away int }{Home: 15, Away: 20})
// 					t.Logf("Market: %s, Scenario: Under Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Push (Void)", func(t *testing.T) {
// 					status, err := EvaluateRugbyTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "35"}, struct{ Home, Away int }{Home: 20, Away: 15})
// 					t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// 				})
// 				t.Run("Non-numeric OddName", func(t *testing.T) {
// 					status, err := EvaluateRugbyTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "notanumber"}, struct{ Home, Away int }{Home: 20, Away: 15})
// 					t.Logf("Market: %s, Scenario: Non-numeric OddName", m.name)
// 					assert.Error(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// 				})
// 			}
// 		})
// 	}
// }

// // TestBaseballMarkets covers all Baseball market types defined in the domain.
// // For each market (Money Line, Spread, Total Runs), it tests home/away win, draw, void, and invalid input scenarios.
// func TestBaseballMarkets(t *testing.T) {
// 	t.Log("Testing Baseball Markets")
// 	markets := []struct {
// 		marketID int64
// 		name     string
// 	}{
// 		{int64(domain.BASEBALL_MONEY_LINE), "MONEY_LINE"},
// 		{int64(domain.BASEBALL_SPREAD), "SPREAD"},
// 		{int64(domain.BASEBALL_TOTAL_RUNS), "TOTAL_RUNS"},
// 	}

// 	for _, m := range markets {
// 		t.Run(m.name, func(t *testing.T) {
// 			// Each subtest below covers a key scenario for the given Baseball market.
// 			switch m.marketID {
// 			case int64(domain.BASEBALL_MONEY_LINE):
// 				// Home win, away win, draw, and invalid OddHeader for Money Line
// 				t.Run("Home Win", func(t *testing.T) {
// 					status, err := EvaluateBaseballMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 6, Away: 3})
// 					t.Logf("Market: %s, Scenario: Home Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Away Win", func(t *testing.T) {
// 					status, err := EvaluateBaseballMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2"}, struct{ Home, Away int }{Home: 2, Away: 5})
// 					t.Logf("Market: %s, Scenario: Away Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Draw", func(t *testing.T) {
// 					status, err := EvaluateBaseballMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 4, Away: 4})
// 					t.Logf("Market: %s, Scenario: Draw", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_LOSS, status)
// 				})
// 				t.Run("Invalid OddHeader", func(t *testing.T) {
// 					status, err := EvaluateBaseballMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "X"}, struct{ Home, Away int }{Home: 10, Away: 7})
// 					t.Logf("Market: %s, Scenario: Invalid OddHeader", m.name)
// 					assert.Error(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// 				})
// 			case int64(domain.BASEBALL_SPREAD):
// 				t.Run("Home Win with Handicap", func(t *testing.T) {
// 					status, err := EvaluateBaseballSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "-1.5"}, struct{ Home, Away int }{Home: 5, Away: 3})
// 					t.Logf("Market: %s, Scenario: Home Win with Handicap", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Away Win with Handicap", func(t *testing.T) {
// 					status, err := EvaluateBaseballSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2", OddHandicap: "+1.5"}, struct{ Home, Away int }{Home: 3, Away: 5})
// 					t.Logf("Market: %s, Scenario: Away Win with Handicap", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Push (Void)", func(t *testing.T) {
// 					status, err := EvaluateBaseballSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "0"}, struct{ Home, Away int }{Home: 4, Away: 4})
// 					t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// 				})
// 				t.Run("Non-numeric Handicap", func(t *testing.T) {
// 					status, err := EvaluateBaseballSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "notanumber"}, struct{ Home, Away int }{Home: 5, Away: 3})
// 					t.Logf("Market: %s, Scenario: Non-numeric Handicap", m.name)
// 					assert.Error(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// 				})
// 			case int64(domain.BASEBALL_TOTAL_RUNS):
// 				t.Run("Over Win", func(t *testing.T) {
// 					status, err := EvaluateBaseballTotalRuns(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "7.5"}, struct{ Home, Away int }{Home: 5, Away: 4})
// 					t.Logf("Market: %s, Scenario: Over Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Under Win", func(t *testing.T) {
// 					status, err := EvaluateBaseballTotalRuns(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Under", OddName: "7.5"}, struct{ Home, Away int }{Home: 2, Away: 3})
// 					t.Logf("Market: %s, Scenario: Under Win", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// 				})
// 				t.Run("Push (Void)", func(t *testing.T) {
// 					status, err := EvaluateBaseballTotalRuns(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "7"}, struct{ Home, Away int }{Home: 4, Away: 3})
// 					t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// 					assert.NoError(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// 				})
// 				t.Run("Non-numeric OddName", func(t *testing.T) {
// 					status, err := EvaluateBaseballTotalRuns(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "notanumber"}, struct{ Home, Away int }{Home: 4, Away: 3})
// 					t.Logf("Market: %s, Scenario: Non-numeric OddName", m.name)
// 					assert.Error(t, err)
// 					assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// 				})
// 			}
// 		})
// 	}
// }

// func TestEvaluateFootballOutcome(t *testing.T) {
// 	service := &Service{} // or your real logger

// 	// Mock outcome
// 	outcome := domain.BetOutcome{
// 		ID:           1,
// 		BetID:        1,
// 		EventID:      1001,
// 		OddID:        2001,
// 		SportID:      1, // Assuming 1 = Football
// 		HomeTeamName: "Manchester",
// 		AwayTeamName: "Liverpool",
// 		MarketID:     int64(domain.FOOTBALL_FULL_TIME_RESULT),
// 		MarketName:   "Full Time Result",
// 		Odd:          1.75,
// 		OddName:      "2", // Home win
// 		OddHeader:    "1",
// 		OddHandicap:  "",
// 		Status:       domain.OUTCOME_STATUS_PENDING, // Initial status
// 		Expires:      time.Now().Add(24 * time.Hour),
// 	}

// 	// Parsed result (simulate Bet365 JSON)
// 	finalScore := struct{ Home, Away int }{Home: 2, Away: 1}
// 	firstHalfScore := struct{ Home, Away int }{Home: 1, Away: 1}
// 	secondHalfScore := struct{ Home, Away int }{Home: 1, Away: 0}
// 	corners := struct{ Home, Away int }{Home: 5, Away: 3}
// 	halfTimeCorners := struct{ Home, Away int }{Home: 2, Away: 2}
// 	events := []map[string]string{
// 		{"type": "goal", "team": "home", "minute": "23"},
// 		{"type": "goal", "team": "away", "minute": "34"},
// 	}

// 	// Act
// 	status, _ := service.EvaluateFootballOutcome(outcome, finalScore, firstHalfScore, secondHalfScore, corners, halfTimeCorners, events)

// 	fmt.Printf("\n\nBet Outcome: %v\n\n", &status)

// }
// func TestEvaluateTotalLegs(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"OverTotalLegs", domain.BetOutcome{OddName: "3", OddHeader: "Over"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_WIN},
// 		{"OverTotalLegs", domain.BetOutcome{OddName: "3", OddHeader: "Under"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_LOSS},
// 		{"UnderTotalLegs", domain.BetOutcome{OddName: "7", OddHeader: "Under"}, struct{ Home, Away int }{2, 3}, domain.OUTCOME_STATUS_WIN},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateTotalLegs(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateGameLines(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"GameLines - Total", domain.BetOutcome{OddName: "Total", OddHandicap: "O 5.5"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_WIN},
// 		{"GameLines - Total", domain.BetOutcome{OddName: "Total", OddHandicap: "O 5.5"}, struct{ Home, Away int }{2, 3}, domain.OUTCOME_STATUS_LOSS},
// 		{"GameLines - Money Line", domain.BetOutcome{OddName: "Money Line", OddHeader: "1"}, struct{ Home, Away int }{2, 3}, domain.OUTCOME_STATUS_LOSS},
// 		{"GameLines - Money Line", domain.BetOutcome{OddName: "Money Line", OddHeader: "1"}, struct{ Home, Away int }{3, 2}, domain.OUTCOME_STATUS_WIN},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateGameLines(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateFirstTeamToScore(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		events   []map[string]string
// 		expected domain.OutcomeStatus
// 	}{
// 		{"HomeScoreFirst", domain.BetOutcome{OddName: "1", HomeTeamName: "Team A", AwayTeamName: "Team B"}, []map[string]string{
// 			{"text": "1st Goal - Team A"},
// 		}, domain.OUTCOME_STATUS_WIN},
// 		{"AwayScoreFirst", domain.BetOutcome{OddName: "2", HomeTeamName: "Team A", AwayTeamName: "Team B"}, []map[string]string{
// 			{"text": "1st Goal - Team A"},
// 		}, domain.OUTCOME_STATUS_LOSS},
// 		{"AwayScoreFirst", domain.BetOutcome{OddName: "2", HomeTeamName: "Team A", AwayTeamName: "Team B"}, []map[string]string{
// 			{"text": "1st Goal - Team B"},
// 		}, domain.OUTCOME_STATUS_WIN},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateFirstTeamToScore(tt.outcome, tt.events)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateGoalsOverUnder(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"LosingGoalsOver", domain.BetOutcome{OddHeader: "Over", OddName: "13"}, struct{ Home, Away int }{7, 5}, domain.OUTCOME_STATUS_LOSS},
// 		{"WinningGoalsOver", domain.BetOutcome{OddHeader: "Over", OddName: "11"}, struct{ Home, Away int }{7, 5}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningGoalsUnder", domain.BetOutcome{OddHeader: "Under", OddName: "12"}, struct{ Home, Away int }{6, 5}, domain.OUTCOME_STATUS_WIN},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateGoalsOverUnder(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateGoalsOddEven(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningOddGoals", domain.BetOutcome{OddName: "Odd"}, struct{ Home, Away int }{7, 4}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingEvenGoals", domain.BetOutcome{OddName: "Even"}, struct{ Home, Away int }{7, 4}, domain.OUTCOME_STATUS_LOSS},
// 		{"WinningEvenGoals", domain.BetOutcome{OddName: "Even"}, struct{ Home, Away int }{6, 6}, domain.OUTCOME_STATUS_WIN},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateGoalsOddEven(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateCorrectScore(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"CorrectScore", domain.BetOutcome{OddName: "7-4"}, struct{ Home, Away int }{7, 4}, domain.OUTCOME_STATUS_WIN},
// 		{"CorrectScore", domain.BetOutcome{OddName: "6-6"}, struct{ Home, Away int }{6, 6}, domain.OUTCOME_STATUS_WIN},
// 		{"IncorrectScore", domain.BetOutcome{OddName: "2-3"}, struct{ Home, Away int }{7, 4}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateCorrectScore(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateHighestScoringHalf(t *testing.T) {
// 	tests := []struct {
// 		name        string
// 		outcome     domain.BetOutcome
// 		firstScore  struct{ Home, Away int }
// 		secondScore struct{ Home, Away int }
// 		expected    domain.OutcomeStatus
// 	}{
// 		{"Winning1stHalf", domain.BetOutcome{OddName: "1st Half"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"Losing1stHalf", domain.BetOutcome{OddName: "1st Half"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_LOSS},
// 		{"Losing2ndHalf", domain.BetOutcome{OddName: "2nd Half"}, struct{ Home, Away int }{0, 0}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_LOSS},
// 		{"Winning2ndHalf", domain.BetOutcome{OddName: "2nd Half"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_WIN},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateHighestScoringHalf(tt.outcome, tt.firstScore, tt.secondScore)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}

// }

// func TestEvaluateHighestScoringQuarter(t *testing.T) {
// 	tests := []struct {
// 		name        string
// 		outcome     domain.BetOutcome
// 		firstScore  struct{ Home, Away int }
// 		secondScore struct{ Home, Away int }
// 		thirdScore  struct{ Home, Away int }
// 		fourthScore struct{ Home, Away int }
// 		expected    domain.OutcomeStatus
// 	}{
// 		{"Winning1stQuarter", domain.BetOutcome{OddName: "1st Quarter"},
// 			struct{ Home, Away int }{1, 1},
// 			struct{ Home, Away int }{0, 0},
// 			struct{ Home, Away int }{1, 0},
// 			struct{ Home, Away int }{0, 0},
// 			domain.OUTCOME_STATUS_WIN},
// 		{"Losing1stQuarter", domain.BetOutcome{OddName: "1st Quarter"},
// 			struct{ Home, Away int }{1, 1},
// 			struct{ Home, Away int }{0, 0},
// 			struct{ Home, Away int }{1, 1},
// 			struct{ Home, Away int }{0, 0},
// 			domain.OUTCOME_STATUS_LOSS},
// 		{"Losing2ndQuarter", domain.BetOutcome{OddName: "2nd Quarter"},
// 			struct{ Home, Away int }{1, 1},
// 			struct{ Home, Away int }{0, 0},
// 			struct{ Home, Away int }{1, 1},
// 			struct{ Home, Away int }{0, 0},
// 			domain.OUTCOME_STATUS_LOSS},
// 		{"Winning3rdQuarter", domain.BetOutcome{OddName: "3rd Quarter"},
// 			struct{ Home, Away int }{1, 0},
// 			struct{ Home, Away int }{0, 0},
// 			struct{ Home, Away int }{1, 1},
// 			struct{ Home, Away int }{0, 0},
// 			domain.OUTCOME_STATUS_WIN},
// 		{"Wining4thQuarter", domain.BetOutcome{OddName: "4th Quarter"},
// 			struct{ Home, Away int }{1, 1},
// 			struct{ Home, Away int }{0, 0},
// 			struct{ Home, Away int }{1, 1},
// 			struct{ Home, Away int }{2, 2},
// 			domain.OUTCOME_STATUS_WIN},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateHighestScoringQuarter(tt.outcome, tt.firstScore, tt.secondScore, tt.thirdScore, tt.fourthScore)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}

// }

// func TestEvaluateWinningMargin(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningMargin", domain.BetOutcome{OddHeader: "1", OddName: "12"}, struct{ Home, Away int }{12, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningMargin", domain.BetOutcome{OddHeader: "2", OddName: "3"}, struct{ Home, Away int }{1, 4}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningMargin", domain.BetOutcome{OddHeader: "1", OddName: "3+"}, struct{ Home, Away int }{4, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningMargin", domain.BetOutcome{OddHeader: "2", OddName: "12+"}, struct{ Home, Away int }{0, 13}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingMargin", domain.BetOutcome{OddHeader: "2", OddName: "3"}, struct{ Home, Away int }{0, 4}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingMargin", domain.BetOutcome{OddHeader: "2", OddName: "3+"}, struct{ Home, Away int }{1, 3}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateWinningMargin(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateDoubleResult(t *testing.T) {
// 	tests := []struct {
// 		name           string
// 		outcome        domain.BetOutcome
// 		firstHalfScore struct{ Home, Away int }
// 		fullTimeScore  struct{ Home, Away int }
// 		expected       domain.OutcomeStatus
// 	}{
// 		{"WinningHomeAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A - Team B"}, struct{ Home, Away int }{1, 0}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningAwayHome", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B - Team A"}, struct{ Home, Away int }{0, 1}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningTie", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Tie - Tie"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningTieAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Tie - Team B"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingHomeAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A - Team B"}, struct{ Home, Away int }{1, 0}, struct{ Home, Away int }{2, 0}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingTie", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Tie - Tie"}, struct{ Home, Away int }{1, 0}, struct{ Home, Away int }{1, 1}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingTieAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Tie - Team A"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
// 		{"BadInput", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A - "}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_PENDING},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateDoubleResult(tt.outcome, tt.firstHalfScore, tt.fullTimeScore)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateHighestScoringPeriod(t *testing.T) {
// 	tests := []struct {
// 		name        string
// 		outcome     domain.BetOutcome
// 		firstScore  struct{ Home, Away int }
// 		secondScore struct{ Home, Away int }
// 		thirdScore  struct{ Home, Away int }
// 		expected    domain.OutcomeStatus
// 	}{
// 		{"Winning1stPeriod", domain.BetOutcome{OddName: "Period 1"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"Winning2ndPeriod", domain.BetOutcome{OddName: "Period 2"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 3}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"Winning3rdPeriod", domain.BetOutcome{OddName: "Period 3"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 3}, struct{ Home, Away int }{3, 3}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningTie", domain.BetOutcome{OddName: "Tie"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"Losing1stPeriod", domain.BetOutcome{OddName: "Period 1"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 3}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_LOSS},
// 		{"Losing3rdPeriod", domain.BetOutcome{OddName: "Period 3"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 3}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateHighestScoringPeriod(tt.outcome, tt.firstScore, tt.secondScore, tt.thirdScore)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvalauteTiedAfterRegulation(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    []struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningTied", domain.BetOutcome{OddName: "Yes"}, []struct{ Home, Away int }{{1, 0}, {0, 1}, {2, 2}}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningTied", domain.BetOutcome{OddName: "Yes"}, []struct{ Home, Away int }{{1, 1}, {0, 1}, {2, 2}, {2, 1}}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningNotTied", domain.BetOutcome{OddName: "No"}, []struct{ Home, Away int }{{0, 0}, {0, 0}, {0, 0}, {1, 0}}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingTied", domain.BetOutcome{OddName: "Yes"}, []struct{ Home, Away int }{{0, 2}, {0, 0}, {0, 0}, {0, 0}}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingNotTied", domain.BetOutcome{OddName: "No"}, []struct{ Home, Away int }{{0, 0}, {0, 0}, {0, 0}, {0, 0}}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateTiedAfterRegulation(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateTeamTotal(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningHomeUnder", domain.BetOutcome{OddHandicap: "Under 3", OddHeader: "1"}, struct{ Home, Away int }{2, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningHomeOver", domain.BetOutcome{OddHandicap: "Over 2", OddHeader: "1"}, struct{ Home, Away int }{3, 1}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningAwayOver", domain.BetOutcome{OddHandicap: "Over 2", OddHeader: "2"}, struct{ Home, Away int }{1, 3}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingHomeOver", domain.BetOutcome{OddHandicap: "Over 2", OddHeader: "1"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingAwayOver", domain.BetOutcome{OddHandicap: "Over 2", OddHeader: "2"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateTeamTotal(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestDrawNoBet(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningHome", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningAway", domain.BetOutcome{OddName: "2"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingHome", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
// 		{"Tie", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 1}, domain.OUTCOME_STATUS_VOID},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateDrawNoBet(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateMoneyLine(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningHome", domain.BetOutcome{OddHeader: "1"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningAway", domain.BetOutcome{OddHeader: "2"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningTie", domain.BetOutcome{OddHeader: "Tie"}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingTie", domain.BetOutcome{OddHeader: "1"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingAway", domain.BetOutcome{OddHeader: "2"}, struct{ Home, Away int }{3, 2}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateMoneyLine(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateDoubleChance(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningHomeOrDraw", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "1 or Draw"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningHomeOrDraw", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A or Draw"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningAwayOrDraw", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Draw or Team B"}, struct{ Home, Away int }{0, 1}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingHomeorAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "1 or 2"}, struct{ Home, Away int }{1, 1}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingAwayOrDraw", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Draw or 2"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateDoubleChance(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateResultAndTotal(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningHomeOver", domain.BetOutcome{OddHeader: "1", OddHandicap: "Over 4"}, struct{ Home, Away int }{3, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningHomeUnder", domain.BetOutcome{OddHeader: "1", OddHandicap: "Under 4"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningAwayUnder", domain.BetOutcome{OddHeader: "2", OddHandicap: "Under 4"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingHomeOver", domain.BetOutcome{OddHeader: "1", OddHandicap: "Under 4"}, struct{ Home, Away int }{3, 2}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingAwayUnder", domain.BetOutcome{OddHeader: "2", OddHandicap: "Under 4"}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateResultAndTotal(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestCheckMultiOutcome(t *testing.T) {
// 	tests := []struct {
// 		name          string
// 		outcome       domain.OutcomeStatus
// 		secondOutcome domain.OutcomeStatus
// 		expected      domain.OutcomeStatus
// 	}{
// 		{"Win-Win", domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_WIN},
// 		{"Win-Void", domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_HALF},
// 		{"Win-Loss", domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_LOSS},
// 		{"Loss-Loss", domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_LOSS},
// 		{"Loss-Void", domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_VOID},
// 		{"Loss-Win", domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_LOSS},
// 		{"Void-Win", domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_VOID},
// 		{"Void-Loss", domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_VOID},
// 		{"Void-Void", domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_VOID},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := checkMultiOutcome(tt.outcome, tt.secondOutcome)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateBTTSX(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningBothScoreX", domain.BetOutcome{OddName: "3", OddHeader: "Yes"}, struct{ Home, Away int }{3, 4}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningBothScoreLess", domain.BetOutcome{OddName: "3", OddHeader: "No"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingBothScoreX", domain.BetOutcome{OddName: "3", OddHeader: "Yes"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingBothScoreLess", domain.BetOutcome{OddName: "3", OddHeader: "No"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateBTTSX(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateResultAndBTTSX(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningHomeAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A and Yes", OddHeader: "3"}, struct{ Home, Away int }{4, 3}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningHomeAndBothScoreLess", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A and No", OddHeader: "3"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningAwayAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B and Yes", OddHeader: "3"}, struct{ Home, Away int }{3, 4}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningAwayAndBothScoreLess", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B and No", OddHeader: "3"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingHomeAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A and Yes", OddHeader: "3"}, struct{ Home, Away int }{3, 4}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingHomeAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B and Yes", OddHeader: "3"}, struct{ Home, Away int }{4, 2}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingAwayAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B and Yes", OddHeader: "3"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateResultAndBTTSX(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateMoneyLine3Way(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"WinningHome", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningAway", domain.BetOutcome{OddName: "2"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"WinningTie", domain.BetOutcome{OddName: "Tie"}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_WIN},
// 		{"LosingTie", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
// 		{"LosingAway", domain.BetOutcome{OddName: "2"}, struct{ Home, Away int }{3, 2}, domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateMoneyLine3Way(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateAsianHandicap(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{
// 			name:     "Home -1 Win",
// 			outcome:  domain.BetOutcome{OddHeader: "1", OddHandicap: "-1"},
// 			score:    struct{ Home, Away int }{Home: 2, Away: 0},
// 			expected: domain.OUTCOME_STATUS_WIN,
// 		},
// 		{
// 			name:     "Home -0.5 Win",
// 			outcome:  domain.BetOutcome{OddHeader: "1", OddHandicap: "-0.5"},
// 			score:    struct{ Home, Away int }{Home: 1, Away: 0},
// 			expected: domain.OUTCOME_STATUS_WIN,
// 		},
// 		{
// 			name:     "Home -1 Void",
// 			outcome:  domain.BetOutcome{OddHeader: "1", OddHandicap: "-1"},
// 			score:    struct{ Home, Away int }{Home: 1, Away: 0},
// 			expected: domain.OUTCOME_STATUS_VOID,
// 		},
// 		{
// 			name:     "Away +3 Win",
// 			outcome:  domain.BetOutcome{OddHeader: "2", OddHandicap: "3"},
// 			score:    struct{ Home, Away int }{Home: 1, Away: 2},
// 			expected: domain.OUTCOME_STATUS_WIN,
// 		},
// 		{
// 			name:     "Split Handicap Home -0.5,-1 Win/Win",
// 			outcome:  domain.BetOutcome{OddHeader: "1", OddHandicap: "-0.5,-1"},
// 			score:    struct{ Home, Away int }{Home: 2, Away: 0},
// 			expected: domain.OUTCOME_STATUS_WIN,
// 		},
// 		{
// 			name:     "Split Handicap Home -0.5,-1 Win/Void",
// 			outcome:  domain.BetOutcome{OddHeader: "1", OddHandicap: "-0.5,-1"},
// 			score:    struct{ Home, Away int }{Home: 1, Away: 0},
// 			expected: domain.OUTCOME_STATUS_WIN,
// 		},
// 		{
// 			name:     "Invalid Handicap",
// 			outcome:  domain.BetOutcome{OddHeader: "1", OddHandicap: "invalid"},
// 			score:    struct{ Home, Away int }{Home: 1, Away: 0},
// 			expected: domain.OUTCOME_STATUS_ERROR,
// 		},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateAsianHandicap(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }

// func TestEvaluateHandicapAndTotal(t *testing.T) {
// 	tests := []struct {
// 		name     string
// 		outcome  domain.BetOutcome
// 		score    struct{ Home, Away int }
// 		expected domain.OutcomeStatus
// 	}{
// 		{"Home +2.5 Over 3", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A +2.5 & Over 3"},
// 			struct{ Home, Away int }{4, 0},
// 			domain.OUTCOME_STATUS_WIN},
// 		{"Away +2.5 Over 4", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B +2.5 & Over 4"},
// 			struct{ Home, Away int }{1, 5},
// 			domain.OUTCOME_STATUS_WIN},
// 		{"Home +2.5 Over 3", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A +2.5 & Over 3"},
// 			struct{ Home, Away int }{2, 0},
// 			domain.OUTCOME_STATUS_LOSS},
// 		{"Home -3.5 Over 3", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A -2.5 & Over 3"},
// 			struct{ Home, Away int }{4, 3},
// 			domain.OUTCOME_STATUS_LOSS},
// 		{"Away -3 Over 4", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B -3 & Over 4"},
// 			struct{ Home, Away int }{3, 5},
// 			domain.OUTCOME_STATUS_LOSS},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			status, _ := EvaluateHandicapAndTotal(tt.outcome, tt.score)
// 			if status != tt.expected {
// 				t.Errorf("expected %d, got %d", tt.expected, status)
// 			}
// 		})
// 	}
// }