Minimax algorithm with weird behaviour when depth is high - c

Question

I am writing a connect 4 ai using minimax and alpha-beta pruning. When I set the depth to something low like 10, it works as expected. When I set it to something higher like 20, the minimax algorithm takes too long time as expected because there is too many nodes to search. But when I set the depth to something high like 40, it finds a move really fast, and the move is often really bad. The number of nodes visited also stays the same with different high depths like 40 and 50. What could be the reason for this? Also, sometimes, the AI plays worse at higher depths than at lower depths. What could be the reason for this? The minimax function takes the depth into account when returning the evaluation, so it should favor the longest path to a loss/bad score and it should take the shortest path to win/good score.
Minimax function:
int c4_minimax(bool is_maximizing, int depth, int alpha, int beta) {
if(c4_check_win(bitboard[(move_count) & 1])) {
if(is_maximizing) {
return MAXIMUM;
}
else {
return MINIMUM;
}
}
else if(c4_is_board_full()) {
return 0;
}
else if(depth == 0) {
return c4_evaluate();
}
bool* valid_moves = c4_get_valid_moves();
if(is_maximizing == true) {
int max_eval = MINIMUM;
for(int i = 0;i < COLS;i++) {
if(valid_moves[explore_order[i]] == true) {
c4_make_move(explore_order[i]);
int eval = c4_minimax(false, depth - 1, alpha, beta);
c4_undo_move();
max_eval = MAX(max_eval, eval);
alpha = MAX(alpha, eval);
if(beta <= alpha) {
break;
}
}
}
return max_eval - depth;
}
else if(is_maximizing == false){
int min_eval = MAXIMUM;
for(int i = 0;i < COLS;i++) {
if(valid_moves[explore_order[i]] == true) {
c4_make_move(explore_order[i]);
int eval = c4_minimax(true, depth - 1, alpha, beta);
c4_undo_move();
min_eval = MIN(min_eval, eval);
beta = MIN(beta, eval);
if(beta <= alpha) {
break;
}
}
}
return min_eval + depth;
}
return 0;
}
//initial call:
c4_minimax(false, initial_depth, MINIMUM, MAXIMUM);