Central Hub Component

import SwiftUI
import VirtualStadiumUISDK

struct ContentView: View {
    let userJWT = "<your-jwt-token>"
    let userId = "<your-user-id>"
    
    @State private var showCentralHub = true
    
    var body: some View {
        if showCentralHub {
            CentralHubView(
                userJWT: userJWT,
                userId: userId,
                centralHubSettings: CentralHubSettings(),
                onCopyToBetslip: { betPayload in
                    // Handle copying bet to user's bet slip
                    addBetToSlip(betPayload)
                },
                onBetShareHandler: { completion in
                    // Return user's bet slips for sharing
                    Task {
                        let betSlips = await getUserBetSlips()
                        completion(betSlips)
                    }
                },
                onClose: {
                    // Handle back navigation
                    showCentralHub = false
                }
            )
        }
    }
    
    private func getUserBetSlips() async -> [BetPayload] {
        /**
         * TODO(developer): Implement your bet slip fetching logic
         */
        return []
    }
    
    private func addBetToSlip(_ betPayload: BetPayload) {
        /**
         * TODO(developer): Implement your bet slip logic
         */
        print("Bet copied: \(betPayload.id)")
    }
}

public struct BetPayload {
    let id: String
    let betType: BetType           // Single, Multi, Bet Builder, etc.
    let selections: [Selection]
    let stake: Double
    let totalOdds: Double
    let potentialWin: Double
    // ... additional bet details
}

Central Hub Entry
    ├── Onboarding (first-time users only)
    │
    ├── My Profile Tab
    │   ├── Edit Profile
    │   │   ├── Privacy Settings
    │   │   └── Notification Preferences
    │   ├── View Followers
    │   ├── View Following
    │   └── Notifications
    │       ├── Betslip Notifications
    │       ├── Social Notifications
    │       └── Comment Notifications
    │
    ├── Bets Tab
    │   ├── Bet Details & Comments
    │   ├── React to Bets
    │   ├── Copy Bet
    │   └── Share Bet Flow
    │       ├── Bet Selection
    │       ├── Privacy Options
    │       └── Share Confirmation
    │
    ├── Other User Profile
    │   ├── Follow/Unfollow
    │   ├── View Shared Bets
    │   └── View Followers/Following
    │
    ├── Search
    │   ├── User Search
    │   └── User Profiles
    │
    └── Commenting
        ├── View Comments
        └── Add Comment

public struct CentralHubSettings {
    public var oddsType: OddsType
    public var themeSettings: CentralHubThemeSettings
    public var sportIcons: SportIconSettings
    public var fontSettings: FontSettings
    public var translationSettings: CentralHubTranslationSettings
}

public enum OddsType: String {
    case us = "us"  // American format (+150, -200)
    case uk = "uk"  // Fractional format (3/2, 1/5)
    case eu = "eu"  // Decimal format (2.50, 1.20)
}

import SwiftUI
import VirtualStadiumUISDK

let customSettings = CentralHubSettings(
    // Odds format
    oddsType: .us,  // American odds
    
    // Theme customization
    themeSettings: CentralHubThemeSettings(
        // Core background
        background: Color(red: 0.95, green: 0.95, blue: 0.97),
        
        // Toast colors
        toastColors: ToastColors(
            successColors: SuccessToastColors(
                backgroundColor: .green,
                textColor: .white,
                iconColor: .white,
                closeButtonColor: .white
            ),
            errorColors: ErrorToastColors(
                backgroundColor: .red,
                textColor: .white,
                iconColor: .white,
                closeButtonColor: .white
            )
        ),
        
        // Card colors
        cardColors: CentralHubCardsColors(
            betShare: BetShareCardColors(
                background: .white,
                contentText: .black,
                commentsIconColor: .blue,
                commentsTextColor: .black
            ),
            betSlip: BetSlipTheme(
                betslipBackgroundColor: .white,
                betslipBorderColor: Color.gray.opacity(0.2)
            )
        ),
        
        // Button colors
        buttonColors: CentralHubButtonColors(
            followButtonColors: FollowButtonColors(
                background: Color.blue.opacity(0.15),
                text: .blue
            ),
            shareBetslipButtonColors: ShareBetslipButtonColors(
                backgroundColor: .blue,
                textColor: .white
            )
        ),
        
        // Navigation bar
        navigationBarColors: CentralHubNavigationBarColors(
            background: .white,
            title: .black,
            icons: .black
        ),
        
        // Tab colors
        tabColors: TabColors(
            selectedTextColor: .black,
            unselectedTextColor: .gray,
            backgroundColor: Color.gray.opacity(0.2),
            selectedBackgroundColor: .white,
            tabContainerBackground: .white
        ),
        
        // Onboarding
        onboardingScreenColors: CentralHubOnboardingScreenColors(
            backgroundColor: .white,
            onboardingIcon: .blue,
            welcomeTextColor: .black,
            featureItem: FeatureItemColors(
                featureIcon: .blue,
                titleColor: .black,
                descriptionColor: .gray
            )
        )
    ),
    
    // Font customization
    fontSettings: FontSettings(
        fontRegular: UIFont(name: "CustomFont-Regular", size: 16),
        fontMedium: UIFont(name: "CustomFont-Medium", size: 16),
        fontBold: UIFont(name: "CustomFont-Bold", size: 16)
    ),
    
    // Translation customization
    translationSettings: CentralHubTranslationSettings(
        // Customize all text strings
        general: GeneralTranslations(
            follow: "Follow",
            unfollow: "Unfollow",
            copyBetslip: "COPY BET"
        )
    )
)

// Use in CentralHubView
CentralHubView(
    userJWT: jwt,
    userId: userId,
    centralHubSettings: customSettings,
    onCopyToBetslip: { bet in
        copyBet(bet)
    },
    onBetShareHandler: { completion in
        Task {
            let bets = await getBets()
            completion(bets)
        }
    },
    onClose: {
        // Handle close
    }
)

import SwiftUI
import VirtualStadiumUISDK

// Example: Custom sport icons
let customSportIcons = SportIconSettings { sportId in
    switch sportId {
    case "1":  // Soccer
        return Image("custom_soccer_icon")
    case "2":  // Basketball
        return Image("custom_basketball_icon")
    default:
        return Image("default_sport_icon") // Default fallback
    }
}

// Use in CentralHubSettings
let settings = CentralHubSettings(
    oddsType: .eu,
    themeSettings: CentralHubThemeSettings(),
    sportIcons: customSportIcons,
    fontSettings: FontSettings(),
    translationSettings: CentralHubTranslationSettings()
)

// Apply to CentralHubView
CentralHubView(
    userJWT: jwt,
    userId: userId,
    centralHubSettings: settings,
    onCopyToBetslip: { bet in
        copyBet(bet)
    },
    onBetShareHandler: { completion in
        Task {
            let bets = await getBets()
            completion(bets)
        }
    },
    onClose: {
        // Handle close
    }
)

// Sportradar Sport IDs (examples)
// "1" = Soccer
// "2" = Basketball

let sportIcons = SportIconSettings { sportId in
    switch sportId {
    case "1":
        return Image("soccer_icon")
    case "2":
        return Image("basketball_icon")
    default:
        return Image("generic_sport_icon") // Always provide default
    }
}

public struct FontSettings {
    public let fontUltraLight: UIFont
    public let fontThin: UIFont
    public let fontLight: UIFont
    public let fontRegular: UIFont
    public let fontMedium: UIFont
    public let fontSemibold: UIFont
    public let fontBold: UIFont
    public let fontHeavy: UIFont
    public let fontBlack: UIFont
    public var inputFieldPlaceholderFont: UIFont
}

let customFonts = FontSettings(
    fontRegular: UIFont(name: "YourFont-Regular", size: 16),
    fontMedium: UIFont(name: "YourFont-Medium", size: 16),
    fontBold: UIFont(name: "YourFont-Bold", size: 16),
    inputFieldPlaceholderFont: UIFont(name: "YourFont-Regular", size: 17)
)

let settings = CentralHubSettings(
    fontSettings: customFonts
)

public struct CentralHubTranslationSettings {
    public var navigationTitles: NavigationTitleTranslations
    public var onboarding: OnboardingTranslations
    public var segmentedSectionTabTranslations: SegmentedSectionTranslations
    public var profileHub: ProfileHubTranslations
    public var otherUserProfileHub: OtherUserProfileHubTranslations
    public var betsHub: BetsHubTranslations
    public var sortingSheet: SortingSheetTranslations
    public var editProfile: EditProfileTranslations
    public var followersHub: FollowersHubTranslations
    public var commentingHub: CommentingHubTranslations
    public var shareBetHub: ShareBetHubTranslations
    public var betshareNotificationsHub: BetshareNotificationHubTranslations
    public var socialNotificationsHub: SocialNotificationHubTranslations
    public var userSearch: UserSearchTranslations
    public var userHeaderNotificationDescription: UserHeaderNotificationDescriptionTranslation
    public var betView: BetViewTranslations
    public var general: GeneralTranslations
}

let spanishTranslations = CentralHubTranslationSettings(
    navigationTitles: NavigationTitleTranslations(
        profile: "Perfil",
        bets: "Apuestas",
        search: "Buscar",
        followers: "Seguidores",
        following: "Siguiendo"
    ),
    betsHub: BetsHubTranslations(
        shareBetslipButtonTitle: "Compartir Apuesta",
        createdFilterSectionTitle: "ÚLTIMAS APUESTAS",
        copyCountFilterSectionTitle: "MÁS COPIADAS",
        commentCountFilterSectionTitle: "MÁS COMENTADAS",
        emptyContent: "Sin apuestas compartidas"
    ),
    general: GeneralTranslations(
        follow: "Seguir",
        unfollow: "Dejar de seguir",
        copyBetslip: "COPIAR APUESTA",
        bets: "Apuestas",
        copied: "Copiado"
    )
)

let settings = CentralHubSettings(
    translationSettings: spanishTranslations
)

import SwiftUI
import VirtualStadiumUISDK

struct CentralHubContainer: View {
    let jwt: String
    let userId: String
    
    @State private var showToast = false
    @State private var toastMessage = ""
    
    var body: some View {
        CentralHubView(
            userJWT: jwt,
            userId: userId,
            centralHubSettings: CentralHubSettings(),
            
            // Handle bet copying
            onCopyToBetslip: { copiedBet in
                // Add the copied bet to user's bet slip
                addToBetSlip(copiedBet)
                
                // Show confirmation
                toastMessage = "Bet copied to slip!"
                showToast = true
            },
            
            // Provide user's bet slips for sharing
            onBetShareHandler: { completion in
                Task {
                    /**
                     * TODO(developer): Fetch from your backend
                     */
                    // Fetch user's current bet slips
                    let myBets = await fetchUserBetSlips()
                    
                    // Map to BetPayload format
                    let betPayloads = myBets.map { bet in
                        BetPayload(
                            id: bet.id,
                            betSlipId: bet.slipId,
                            betType: bet.type,
                            currency: bet.currency,
                            combinedOdds: Odds(
                                decimalValue: Float(bet.totalOdds),
                                displayValue: "\(bet.totalOdds)"
                            ),
                            stake: Stake(
                                value: bet.stake,
                                currencyCode: bet.currency
                            ),
                            payout: Payout(
                                value: bet.potentialWin,
                                currencyCode: bet.currency
                            ),
                            cashOut: nil,
                            bets: bet.selections.map { selection in
                                Bet(
                                    id: selection.id,
                                    betType: selection.type,
                                    event: BetEvent(
                                        id: selection.eventId,
                                        name: selection.eventName,
                                        teams: selection.teams
                                    ),
                                    markets: [
                                        BetMarket(
                                            id: selection.marketId,
                                            name: selection.marketName,
                                            outcomes: [
                                                Outcome(
                                                    id: selection.outcomeId,
                                                    name: selection.outcomeName,
                                                    odds: Odds(
                                                        decimalValue: Float(selection.odds),
                                                        displayValue: "\(selection.odds)"
                                                    )
                                                )
                                            ]
                                        )
                                    ],
                                    odds: Odds(
                                        decimalValue: Float(selection.odds),
                                        displayValue: "\(selection.odds)"
                                    )
                                )
                            }
                        )
                    }
                    
                    completion(betPayloads)
                }
            },
            
            onClose: {
                // Handle close
            }
        )
        .toast(isPresented: $showToast, message: toastMessage)
    }
    
    private func fetchUserBetSlips() async -> [MyBet] {
        /**
         * TODO(developer): Implement your bet fetching logic
         */
        // Example: return await apiClient.fetchUserBetSlips()
        return []
    }
    
    private func addToBetSlip(_ bet: BetPayload) {
        /**
         * TODO(developer): Implement bet slip logic
         */
        print("Adding bet to slip: \(bet.id)")
        // Example: betSlipManager.addBet(bet)
    }
}

import SwiftUI
import VirtualStadiumUISDK
import Combine

class CentralHubViewModel: ObservableObject {

    @Published var jwtToken: String
    @Published var userId: String
    @Published var isLoading: Bool = true
    
    init(jwtToken: String, userId: String) {
        self.jwtToken = jwtToken
        self.userId = userId
    }
    
        
    func fetchUserBetSlips() -> [BetPayload] {
        /**
         * TODO(developer): Fetch bets and convert them to BetPayload array. The example here converts a mock bet from JSON to BetPayload
         */
        let jsonString = """
        {
            "id": "sr:bet-share-event:12345678901",
            "betSlipId": "some:123",
            "betType": "single",
            "currency": "€",
            "combinedOdds": {
                "decimalValue": 5.67
            },
            "stake": {
                "value": "25,00"
            },
            "payout": {
                "value": "37.50"
            },
            "bets": [
                {
                    "id": "x",
                    "betType": "single",
                    "event": {
                        "id": "x1",
                        "name": "Manchester United VS Chelsea",
                        "sportId": "1"
                    },
                    "markets": [
                        {
                            "id": "a",
                            "name": "1 x 2",
                            "outcomes": [
                                {
                                    "id": "a1",
                                    "name": "Manchester United"
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    """
        return [try! JSONDecoder().decode(BetPayload.self, from: jsonString.data(using: .utf8)!)]
    }
    
    func addBetToSlip(_ bet: BetPayload) {
        /**
         * TODO(developer): Implement copy bet slip logic
         */
        print("Adding bet: \(bet.id)")
    }
    
    func loadSDK() async {
        Task {
            do {
                try await VirtualStadiumUISDK_STGDEV.Managers.SDK.shared.initialize()
                self.isLoading = false
            } catch {
                print("Error initializing SDK: \(error)")
            }
        }
    }
}

struct CentralHubViewContainer: View {

    @StateObject private var viewModel: CentralHubViewModel
    
    init() {
        _viewModel = StateObject(
            wrappedValue: CentralHubViewModel(
                jwtToken: "Pre generated JWT",
                userId: "userId"
            )
        )
    }
    
    var body: some View {
        VStack {
            switch viewModel.isLoading {
            case false:
                CentralHubView(
                    userJWT: viewModel.jwtToken,
                    userId: viewModel.userId,
                    centralHubSettings: createCustomSettings(),
                    
                    onCopyToBetslip: { bet in
                        viewModel.addBetToSlip(bet)
                    },
                    
                    onBetShareHandler: { completion in
                        let bets = viewModel.fetchUserBetSlips()
                        completion(bets)
                    },
                    
                    onClose: {
                        // Cose central hub
                    }
                )
            case true:
                ProgressView()
            }
        }
        .task {
            await viewModel.loadSDK()
        }
    }
    
    private func createCustomSettings() -> CentralHubSettings {
        // Custom theme
        let customTheme = CentralHubThemeSettings(
            background: Color(red: 0.95, green: 0.95, blue: 0.97),
            
            toastColors: ToastColors(
                successColors: SuccessToastColors(
                    backgroundColor: .green,
                    textColor: .white
                )
            ),
            
            buttonColors: CentralHubButtonColors(
                followButtonColors: FollowButtonColors(
                    background: Color.blue.opacity(0.15),
                    text: .blue
                ),
                shareBetslipButtonColors: ShareBetslipButtonColors(
                    backgroundColor: .blue,
                    textColor: .white
                )
            ),
            
            navigationBarColors: CentralHubNavigationBarColors(
                background: .white,
                title: .black,
                icons: .black
            )
        )
        
        // Custom sport icons
        let customSportIcons = SportIconSettings { sportId in
            switch sportId {
            case "1":  // Soccer
                return Image("custom_soccer_icon")
            case "2":  // Basketball
                return Image("custom_basketball_icon")
            default:
                return Image("generic_sport_icon")
            }
        }
        
        // Custom fonts
        let customFonts = FontSettings(
            fontRegular: UIFont(name: "CustomFont-Regular", size: 16),
            fontMedium: UIFont(name: "CustomFont-Medium", size: 16),
            fontBold: UIFont(name: "CustomFont-Bold", size: 16)
        )
        
        return CentralHubSettings(
            oddsType: .us,
            themeSettings: customTheme,
            sportIcons: customSportIcons,
            fontSettings: customFonts,
            translationSettings: CentralHubTranslationSettings()
        )
    }
}

struct MainAppView: View {
    var body: some View {
        CentralHubViewContainer()
    }
}

// Preview
struct CentralHubScreen_Previews: PreviewProvider {
    static var previews: some View {
        CentralHubViewContainer()
    }
}