// BoringGame核心合约
#[starknet::contract]
mod BoringGameCore {
    use starknet::ContractAddress;
    
    #[storage]
    struct Storage {
        players: LegacyMap::<ContractAddress, Player>,
        game_state: GameState,
        token_rewards: LegacyMap::<ContractAddress, u256>,
        leaderboard: LegacyMap::<u32, ContractAddress>,
    }
    
    #[derive(Drop, Serde, starknet::Store)]
    struct Player {
        score: u256,
        games_played: u32,
        total_rewards: u256,
        last_game_time: u64,
    }
    
    #[external(v0)]
    fn play_game(ref self: ContractState, moves: Array<u32>) -> u256 {
        let caller = starknet::get_caller_address();
        let score = self._calculate_score(moves);
        let reward = self._calculate_reward(score);
        
        // 更新玩家数据
        let mut player = self.players.read(caller);
        player.score += score;
        player.games_played += 1;
        player.total_rewards += reward;
        player.last_game_time = starknet::get_block_timestamp();
        
        self.players.write(caller, player);
        self.token_rewards.write(caller, reward);
        
        reward
    }
    
    #[external(v0)]
    fn claim_rewards(ref self: ContractState) {
        let caller = starknet::get_caller_address();
        let reward = self.token_rewards.read(caller);
        
        assert(reward > 0, 'No rewards to claim');
        
        // 发送BORING代币奖励
        self._transfer_tokens(caller, reward);
        self.token_rewards.write(caller, 0);
    }
}

// React游戏组件
interface GameProps {
    wallet: WalletConnection;
    contract: BoringGameContract;
}
 
const BoringGameInterface: React.FC<GameProps> = ({ wallet, contract }) => {
    const [gameState, setGameState] = useState<GameState>();
    const [playerScore, setPlayerScore] = useState<number>(0);
    const [isPlaying, setIsPlaying] = useState<boolean>(false);
    
    const playGame = async (moves: number[]) => {
        setIsPlaying(true);
        
        try {
            // 调用智能合约
            const result = await contract.play_game(moves);
            
            // 更新游戏状态
            setPlayerScore(result.score);
            setGameState(result.gameState);
            
            // 显示奖励
            showReward(result.reward);
            
        } catch (error) {
            console.error('Game error:', error);
        } finally {
            setIsPlaying(false);
        }
    };
    
    return (
        <div className="boring-game-container">
            <GameBoard 
                onMove={playGame}
                disabled={isPlaying}
                score={playerScore}
            />
            <RewardPanel 
                wallet={wallet}
                contract={contract}
            />
            <Leaderboard 
                contract={contract}
            />
        </div>
    );
};