class Configuration:
    def __init__(self, config_dict):
        self.rows = config_dict["rows"]
        self.columns = config_dict["columns"]
        self.inarow = config_dict["inarow"]

class Observation:
    def __init__(self, obs_dict):
        self.board = obs_dict["board"]
        self.mark = obs_dict["mark"]

def my_agent(observation, configuration):
    """
    ConnectX agent using Minimax algorithm with alpha-beta pruning
    Args:
        observation: Current game state
        configuration: Game configuration
    Returns:
        Column number (0-based) where to drop the piece
    """
    import numpy as np
    
    # Constants
    EMPTY = 0
    MAX_DEPTH = 6  # Search depth limit
    INFINITY = float('inf')
    
    def make_board(obs):
        """Convert observation to 2D numpy array"""
        return np.asarray(obs.board).reshape(configuration.rows, configuration.columns)
    
    def get_valid_moves(board):
        """Get list of valid moves (columns that aren't full)"""
        return [col for col in range(configuration.columns) if board[0][col] == EMPTY]
    
    def drop_piece(board, col, piece):
        """Drop piece in specified column and return row position"""
        row = np.where(board[:, col] == EMPTY)[0][-1]
        board[row, col] = piece
        return row
    
    def check_window(window, piece, inarow):
        """
        Score a window of positions
        Higher scores for more pieces in a row and potential winning moves
        Negative scores for opponent's threatening positions
        """
        score = 0
        opp_piece = 1 if piece == 2 else 2
        
        # Winning position
        if np.count_nonzero(window == piece) == inarow:
            score += 100
        # One move away from winning
        elif np.count_nonzero(window == piece) == (inarow - 1) and np.count_nonzero(window == EMPTY) == 1:
            score += 10
        # Two moves away from winning
        elif np.count_nonzero(window == piece) == (inarow - 2) and np.count_nonzero(window == EMPTY) == 2:
            score += 5
        
        # Opponent one move away from winning - defensive move needed
        if np.count_nonzero(window == opp_piece) == (inarow - 1) and np.count_nonzero(window == EMPTY) == 1:
            score -= 80
            
        return score
    
    def score_position(board, piece):
        """
        Score entire board position
        Considers horizontal, vertical, and diagonal possibilities
        Extra weight for center column control
        """
        score = 0
        
        # Horizontal windows
        for row in range(configuration.rows):
            for col in range(configuration.columns - (configuration.inarow - 1)):
                window = board[row, col:col + configuration.inarow]
                score += check_window(window, piece, configuration.inarow)
        
        # Vertical windows
        for row in range(configuration.rows - (configuration.inarow - 1)):
            for col in range(configuration.columns):
                window = board[row:row + configuration.inarow, col]
                score += check_window(window, piece, configuration.inarow)
        
        # Positive diagonal windows
        for row in range(configuration.rows - (configuration.inarow - 1)):
            for col in range(configuration.columns - (configuration.inarow - 1)):
                window = [board[row + i][col + i] for i in range(configuration.inarow)]
                score += check_window(window, piece, configuration.inarow)
        
        # Negative diagonal windows
        for row in range(configuration.inarow - 1, configuration.rows):
            for col in range(configuration.columns - (configuration.inarow - 1)):
                window = [board[row - i][col + i] for i in range(configuration.inarow)]
                score += check_window(window, piece, configuration.inarow)
        
        # Center column control bonus
        center_array = board[:, configuration.columns//2]
        center_count = np.count_nonzero(center_array == piece)
        score += center_count * 6
        
        return score
    
    def is_terminal_node(board):
        """Check if current position is terminal (game over)"""
        # Check horizontal wins
        for row in range(configuration.rows):
            for col in range(configuration.columns - (configuration.inarow - 1)):
                window = list(board[row, col:col + configuration.inarow])
                if window.count(1) == configuration.inarow or window.count(2) == configuration.inarow:
                    return True
        
        # Check vertical wins
        for row in range(configuration.rows - (configuration.inarow - 1)):
            for col in range(configuration.columns):
                window = list(board[row:row + configuration.inarow, col])
                if window.count(1) == configuration.inarow or window.count(2) == configuration.inarow:
                    return True
                
        # Check if board is full
        return len(get_valid_moves(board)) == 0
    
    def minimax(board, depth, alpha, beta, maximizing_player):
        """
        Minimax algorithm with alpha-beta pruning
        Returns best move and its score
        """
        valid_moves = get_valid_moves(board)
        is_terminal = is_terminal_node(board)
        
        # Base cases: max depth reached or terminal position
        if depth == 0 or is_terminal:
            if is_terminal:
                return (None, -INFINITY if maximizing_player else INFINITY)
            else:
                return (None, score_position(board, observation.mark))
        
        if maximizing_player:
            value = -INFINITY
            column = np.random.choice(valid_moves)
            for col in valid_moves:
                board_copy = board.copy()
                drop_piece(board_copy, col, observation.mark)
                new_score = minimax(board_copy, depth-1, alpha, beta, False)[1]
                if new_score > value:
                    value = new_score
                    column = col
                alpha = max(alpha, value)
                if alpha >= beta:
                    break
            return column, value
        
        else:
            value = INFINITY
            column = np.random.choice(valid_moves)
            opponent_piece = 1 if observation.mark == 2 else 2
            for col in valid_moves:
                board_copy = board.copy()
                drop_piece(board_copy, col, opponent_piece)
                new_score = minimax(board_copy, depth-1, alpha, beta, True)[1]
                if new_score < value:
                    value = new_score
                    column = col
                beta = min(beta, value)
                if alpha >= beta:
                    break
            return column, value
    
    # Main game logic
    board = make_board(observation)
    valid_moves = get_valid_moves(board)
    
    # First move: take center column
    if len(np.where(board != 0)[0]) == 0:
        return configuration.columns // 2
    
    # Check for immediate winning moves
    for col in valid_moves:
        board_copy = board.copy()
        drop_piece(board_copy, col, observation.mark)
        if is_terminal_node(board_copy):
            return col
    
    # Use minimax to find best move
    column, minimax_score = minimax(board, MAX_DEPTH, -INFINITY, INFINITY, True)
    return column