#!/bin/bash
#set -x
# Enable error tracing but don't exit on error for the whole script
set -E

# Global variables
LINUX_DIR="$HOME/linux"
TEMP_PATCH=""
PENDING_DIR="$HOME/pending/series"
WORKTREE_DIR="$HOME/git-worktrees"

# Function to create a temporary git worktree
create_git_worktree() {
    local base_branch="$1"
    local branch_name="$2"
    local linux_dir="$3"

    mkdir -p "$WORKTREE_DIR"

    # Generate a unique path with timestamp
    local worktree_path="${WORKTREE_DIR}/${branch_name}-$(date +%s)"

    # If the directory already exists for some reason, remove it
    if [ -d "$worktree_path" ]; then
        rm -rf "$worktree_path"
    fi

    cd "$linux_dir"

    # Verify the base branch exists
    if ! git rev-parse --verify "$base_branch" >/dev/null 2>&1; then
        echo "Error: Branch $base_branch does not exist" >&2
        return 1
    fi

    # Create the worktree
    local worktree_result=$(git worktree add --detach "$worktree_path" "$base_branch" 2>&1)
    if [ $? -ne 0 ]; then
        echo "Error creating worktree: $worktree_result" >&2
        return 1
    fi

    echo "$worktree_path"
}

# Function to remove a git worktree
remove_git_worktree() {
    local worktree_path="$1"
    local linux_dir="$2"

    # Check if the worktree path exists
    if [ ! -d "$worktree_path" ]; then
        return 0
    fi

    cd "$linux_dir"

    # First make sure any ongoing git operations are aborted
    cd "$worktree_path" 2>/dev/null
    if [ $? -eq 0 ]; then
        # If there's a rebase in progress, abort it
        if [ -d ".git/rebase-apply" ]; then
            git rebase --abort >/dev/null 2>&1
        fi

        # If there's an am in progress, abort it
        if [ -d ".git/rebase-apply" ]; then
            git am --abort >/dev/null 2>&1
        fi

        # Reset and clean the worktree
        git reset --hard >/dev/null 2>&1
        git clean -fdx >/dev/null 2>&1

        cd "$linux_dir"
    fi

    # Try to remove the worktree
    if ! git worktree remove --force "$worktree_path" >/dev/null 2>&1; then
        # If git worktree remove fails, try more aggressive cleanup
        echo "Warning: Failed to remove worktree via git, using rm -rf" >&2
        rm -rf "$worktree_path"

        # Prune the worktree list
        git worktree prune >/dev/null 2>&1
    fi
}

# Function to generate unique message ID
generate_message_id() {
    local timestamp=$(date +%Y%m%d%H%M%S)
    local random=$(openssl rand -hex 8)
    echo "<${timestamp}-${random}@stable.kernel.org>"
}

# Function to generate unique response filename
generate_response_filename() {
    local mbox_file="$1"
    local base_dir="$HOME/Mail/stable/respo"
    local subject=$(formail -xSubject: < "$mbox_file" | tr '\n' ' ')
    local sender=$(formail -xFrom: < "$mbox_file" | tr -dc '[:alnum:]@.<> _-')
    local date_str=$(formail -xDate: < "$mbox_file")
    local timestamp=$(date -d "$date_str" +%Y%m%d%H%M%S 2>/dev/null || date +%Y%m%d%H%M%S)
    local message_id=$(formail -xMessage-ID: < "$mbox_file" | tr -dc '[:alnum:]@._-')

    # Clean subject (take first 30 chars, remove special chars)
    local clean_subject=$(echo "$subject" | tr -dc '[:alnum:] ' | tr ' ' '_' | cut -c1-30)

    # Clean sender email (extract just the email part if possible, otherwise use whole string)
    local clean_sender=$(echo "$sender" | grep -o '[^< ]*@[^> ]*' || echo "$sender" | tr -dc '[:alnum:]@._-')

    # Create unique filename
    local filename="${clean_sender}-${timestamp}-${clean_subject}-${message_id}.response"

    echo "${base_dir}/${filename}"
}

check_response_exists() {
    local mbox_file="$1"
    local response_file=$(generate_response_filename "$mbox_file")

    if [ -f "$response_file" ]; then
        echo "Response file already exists: $response_file"
        return 0
    fi
    return 1
}

# Function to decode UTF-8 MIME encoded text using Python
decode_mime_header() {
    local encoded_text="$1"
    [ -z "$encoded_text" ] && return 1
    python3 -c '
import sys
import email.header
import email.quoprimime
import email.base64mime

def decode_header(text):
    # Add a maximum iteration count to prevent infinite loops
    max_iterations = 100
    iteration = 0

    # Handle quoted-printable and base64 encoded UTF-8 headers
    while "=?UTF-8?" in text and iteration < max_iterations:
        iteration += 1
        start = text.find("=?UTF-8?")
        end = text.find("?=", start) + 2
        if end <= 1:  # No closing "?=" found
            break

        encoded_part = text[start:end]
        try:
            # Extract encoding type (B or Q) and encoded text
            parts = encoded_part.split("?")
            if len(parts) != 5:
                # Skip this part and continue with the rest of the text
                text = text[:start] + text[end:]
                continue

            charset, encoding, encoded_text = parts[1:4]
            if encoding.upper() == "B":
                decoded = email.base64mime.decode(encoded_text.encode())
            elif encoding.upper() == "Q":
                decoded = email.quoprimime.header_decode(encoded_text)
            else:
                # Skip unsupported encoding
                text = text[:start] + text[end:]
                continue

            # Replace encoded part with decoded text
            new_text = text[:start] + decoded.decode(charset) + text[end:]

            # Ensure we made progress
            if new_text == text:
                # If no change happened, skip this part to avoid infinite loop
                text = text[:start] + text[end:]
            else:
                text = new_text

        except Exception:
            # If decoding fails, skip this part
            text = text[:start] + text[end:]
            continue

    # If we hit the maximum iterations, fall back to using standard library
    if iteration >= max_iterations:
        try:
            # Try the standard Python email.header module as a fallback
            decoded_parts = email.header.decode_header(text)
            return str(email.header.make_header(decoded_parts))
        except Exception:
            # If even that fails, return as is
            pass

    return text

print(decode_header(sys.argv[1]))
' "$encoded_text" 2>/dev/null || echo "$encoded_text"
}

# Function to normalize author string for comparison
normalize_author() {
    local author="$1"
    local normalized=""

    # First decode any UTF-8 MIME encoding
    normalized=$(decode_mime_header "$author")

    # Remove extra quotes and normalize whitespace
    normalized=$(echo "$normalized" | sed -E '
        # Remove surrounding quotes if they exist
        s/^"([^"]+)"$/\1/
        # Remove extra spaces around < and >
        s/[[:space:]]*<[[:space:]]*/</g
        s/[[:space:]]*>[[:space:]]*/>/g
        # Normalize spaces between parts
        s/[[:space:]]+/ /g
        # Trim leading/trailing whitespace
        s/^[[:space:]]+//
        s/[[:space:]]+$//
    ')

    echo "$normalized"
}

# Function to check if we should ignore this mail based on sender
should_ignore_mail() {
    local mbox_file="$1"
    local from=$(formail -xFrom: < "$mbox_file" | sed -e 's/^[[:space:]]*//g' -e 's/[[:space:]]*$//g')

    if check_response_exists "$MBOX_FILE"; then
        exit 0
    fi

    # List of authors to ignore
    if [[ "$from" =~ ^"Sasha Levin".*$ ]] || \
       [[ "$from" =~ ^"Linux Kernel Distribution System".*$ ]] || \
       [[ "$from" =~ ^"Greg Kroah-Hartman".*$ ]]; then
        return 0
    fi
    return 1
}

# Function to check if mail contains a git patch
is_git_patch() {
    local mbox_file="$1"

    # We need to use formail -c to process the entire email including headers and body
    formail -c < "$mbox_file" | awk '
        BEGIN {
            found=0
            p=0
            in_headers=1
            has_patch_subject=0
            has_diff=0
        }

        # Track when we move from email headers to body
        in_headers && /^$/ { in_headers=0; next }

        # Look for [PATCH] in subject line while in headers
        in_headers && /^Subject:.*\[PATCH/ { has_patch_subject=1; next }

        # Look for patch separator
        !in_headers && /^---$/ { p=NR; next }

        # Look for diff or index after separator
        p && (/^diff --git/ || /^index [0-9a-f]/) { has_diff=1; exit }

        # Exit if we go too far past the separator
        NR > p+20 && p { exit }

        END { exit !(has_patch_subject && has_diff) }
    '
}

# Function to decode UTF-8 email subject
decode_subject() {
    local encoded_subject="$1"
    echo "$encoded_subject" | decode_mime_header
}

# Function to extract series info from subject
extract_series_info() {
    local subject="$1"
    # Pattern to match [PATCH X/N] format
    local part_pattern='\[PATCH.*[[:space:]]([0-9]+)/([0-9]+)\]'

    if [[ $subject =~ $part_pattern ]]; then
        local current="${BASH_REMATCH[1]}"
        local total="${BASH_REMATCH[2]}"
        # Remove leading zeros to avoid octal interpretation
        current=$((10#$current))
        total=$((10#$total))
        echo "$current $total"
        return 0
    fi
    return 1
}

# Function to get message ID from mail
get_message_id() {
    local mbox_file="$1"
    formail -xMessage-ID: < "$mbox_file" | tr -d '[:space:]'
}

# Function to get in-reply-to ID from mail
get_in_reply_to() {
    local mbox_file="$1"
    formail -xIn-Reply-To: < "$mbox_file" | tr -d '[:space:]'
}

# Function to generate series directory name
get_series_dir() {
    local message_id="$1"
    local in_reply_to="$2"

    # Use the first message's ID (either this message if it's first, or the one it replies to)
    local series_id="${in_reply_to:-$message_id}"

    # Create a safe directory name from the message ID
    echo "${series_id}" | sed 's/[<>]//g' | tr -c '[:alnum:]' '_'
}

# Function to generate a more unique patch filename
generate_patch_filename() {
    local base_dir="$1"
    local part="$2"
    local subject="$3"
    local sender="$4"
    local timestamp="$5"
    local message_id="$6"

    # Clean subject to use in filename (take first 30 chars, remove special chars)
    local clean_subject=$(echo "$subject" | tr -dc '[:alnum:] ' | tr ' ' '_' | cut -c1-30)

    # Clean sender email (extract just the email part if possible, otherwise use whole string)
    local clean_sender=$(echo "$sender" | grep -o '[^< ]*@[^> ]*' || echo "$sender" | tr -dc '[:alnum:]@._-')

    # Create unique filename combining all elements
    local clean_message_id=$(echo "$message_id" | tr -dc '[:alnum:]@._-')
    echo "${part}-${clean_sender}-${timestamp}-${clean_subject}-${clean_message_id}.mbox"
}

# Function to strip leading zeros from a number
strip_leading_zeros() {
    local num="$1"
    # Use parameter expansion to remove leading zeros
    # Then use 10#$num to ensure base-10 interpretation
    num="${num##0}"
    # If num is empty, it was zero, so return 0
    if [ -z "$num" ]; then
        echo "0"
    else
        echo "$((10#$num))"  # Force base-10 interpretation
    fi
}

# Function to store patch in series directory
store_patch() {
    local mbox_file="$1"
    local series_dir="$2"
    local part=$(strip_leading_zeros "$3")

    # Extract additional information for filename
    local subject=$(formail -xSubject: < "$mbox_file" | tr '\n' ' ')
    local sender=$(formail -xFrom: < "$mbox_file" | tr -dc '[:alnum:]@.<> _-')
    local date_str=$(formail -xDate: < "$mbox_file")
    local timestamp=$(date -d "$date_str" +%Y%m%d%H%M%S 2>/dev/null || date +%Y%m%d%H%M%S)
    local message_id=$(formail -xMessage-ID: < "$mbox_file")

    # Generate unique filename
    local filename=$(generate_patch_filename "$series_dir" "$part" "$subject" "$sender" "$timestamp" "$message_id")

    mkdir -p "$series_dir"
    cp "$mbox_file" "$series_dir/$filename"

    # Create a symlink with just the part number for backward compatibility
    ln -sf "$filename" "$series_dir/$part.mbox"
}

# Function to check if series is complete
is_series_complete() {
    local series_dir="$1"
    local total_parts="$2"

    for ((i=1; i<=total_parts; i++)); do
        if [ ! -f "$series_dir/$i.mbox" ]; then
            return 1
        fi
    done
    return 0
}

# Function to clean subject for searching
clean_subject() {
    local subject="$1"
    local cleaned_subject

    # Special handling for FAILED patch subjects
    if [[ "$subject" =~ FAILED:.*\"([^\"]+)\".*failed[[:space:]]to[[:space:]]apply ]]; then
        # Extract the actual patch subject from within quotes
        cleaned_subject="${BASH_REMATCH[1]}"
    else
        # Regular subject cleaning
        cleaned_subject=$(echo "$subject" | \
            sed -E 's/\[[^]]*\]//g' | \
            tr '\n' ' ' | \
            tr -s ' ' | \
            sed -E 's/^[[:space:]]+|[[:space:]]+$//g')  # Trim whitespace
    fi

    # Remove leading "Re: " if present
    cleaned_subject=$(echo "$cleaned_subject" | sed -E 's/^Re: *//')

    echo "$cleaned_subject"
}

# Function to find commit by subject in origin/master
find_commit_by_subject() {
    local subject="$1"
    local linux_dir="$2"
    local cleaned_subject

    cd "$linux_dir"
    cleaned_subject=$(clean_subject "$subject")
    cleaned_subject=$(printf '%s' "$cleaned_subject" | sed 's/[[\.*^$/]/\\&/g')

    git log origin/master --format="%H" --grep="^${cleaned_subject}$" -1
}

# Function to apply previous patches in series
apply_series_patches() {
    local series_dir="$1"
    local current_part="$2"
    local worktree_path="$3"

    cd "$worktree_path"

    # Clean up any previous rebase-apply directory that might exist
    if [ -d ".git/rebase-apply" ]; then
        rm -rf ".git/rebase-apply"
    fi

    # Reset to ensure clean state
    git reset --hard >/dev/null 2>&1

    # Apply all patches up to but not including the current one
    for ((i=1; i<current_part; i++)); do
        local patch_file="$series_dir/$i.mbox"
        if [ ! -f "$patch_file" ]; then
            echo "Error: Patch file $i does not exist in series"
            return 1
        fi

        # Try to apply the patch
        local apply_result=$(git am "$patch_file" 2>&1)
        if [ $? -ne 0 ]; then
            echo "Error: Failed to apply patch $i in series"
            echo "Error details: $apply_result"

            # Make sure to clean up
            git am --abort >/dev/null 2>&1
            return 1
        fi
    done

    return 0
}

# Function to extract kernel versions from subject
extract_kernel_versions() {
    local subject="$1"
    local active_versions_file="$HOME/stable-queue/active_kernel_versions"
    local found_versions=()
    local range_start=""
    local range_end=""

    # First check for version ranges (e.g., "5.10-6.1" or "5.10.y-6.1.y" or "v5.10-v6.1" or "v6.1-v5.4")
    if [[ "$subject" =~ (^|[^0-9.])(v)?([0-9]+\.[0-9]+)(\.y)?-(v)?([0-9]+\.[0-9]+)(\.y)?([^0-9.]|$) ]]; then
        local ver1="${BASH_REMATCH[3]}"
        local ver2="${BASH_REMATCH[6]}"

        # Determine which is higher and lower for the range check
        if [ "$(printf "%s\n%s" "$ver1" "$ver2" | sort -V | head -n1)" = "$ver2" ]; then
            range_start="$ver2"
            range_end="$ver1"
        else
            range_start="$ver1"
            range_end="$ver2"
        fi

        # Read all versions and filter those within range
        while IFS= read -r version; do
            # Version is in range if:
            # 1. It's >= range_start (version is not smallest when sorted with range_start)
            # 2. It's <= range_end (version is not largest when sorted with range_end)
            if [ "$(printf "%s\n%s" "$range_start" "$version" | sort -V | head -n1)" = "$range_start" ] && \
               [ "$(printf "%s\n%s" "$version" "$range_end" | sort -V | head -n1)" = "$version" ]; then
                found_versions+=("$version")
            fi
        done < "$active_versions_file"
    fi

    # If no range found, check for individual versions
    if [ ${#found_versions[@]} -eq 0 ]; then
        while IFS= read -r version; do
            # Check for version numbers with optional v prefix and optional .y suffix
            # Use a more strict pattern that requires the exact X.Y or X.Y.y format
            if printf "%s" "$subject" | grep -E -q "(^|[^0-9.])${version}(\.y)?([^0-9.]|$)|(^|[[:space:]]|\[)v${version}(\.y)?([^0-9.]|$)"; then
                found_versions+=("$version")
            fi
        done < "$active_versions_file"
    fi

    if [ ${#found_versions[@]} -gt 0 ]; then
        # Sort versions in ascending order
        result=$(printf "%s\n" "${found_versions[@]}" | sort -V | tr '\n' ' ' | sed 's/ $//')
        echo "$result"
        return 0
    fi

    cat "$active_versions_file"
}

# Function to extract commit SHA1 from email body
extract_commit_sha1() {
    local email_body="$1"
    local sha1=""

    # First pattern: Look for "commit [SHA1] upstream" with case insensitivity
    # Using -i flag makes grep ignore case when matching
    sha1=$(echo "$email_body" | grep -i -E "commit [0-9a-f]{40} upstream" | \
           sed -E 's/.*[Cc][Oo][Mm][Mm][Ii][Tt] ([0-9a-f]{40}) [Uu][Pp][Ss][Tt][Rr][Ee][Aa][Mm].*/\1/')

    if [ -n "$sha1" ]; then
        echo "$sha1"
        return 0
    fi

    # Second pattern: Look for "[ Upstream commit [SHA1] ]" with case insensitivity
    sha1=$(echo "$email_body" | grep -i -E "\[[[:space:]]*upstream[[:space:]]+commit[[:space:]]+[0-9a-f]{40}[[:space:]]*\]" | \
           sed -E 's/.*\[[[:space:]]*[Uu][Pp][Ss][Tt][Rr][Ee][Aa][Mm][[:space:]]+[Cc][Oo][Mm][Mm][Ii][Tt][[:space:]]+([0-9a-f]{40})[[:space:]]*\].*/\1/')

    if [ -n "$sha1" ]; then
        echo "$sha1"
        return 0
    fi

    return 1
}

# Function to extract patch author with normalization
extract_patch_author() {
    local mbox_file="$1"
    local author=$(formail -xFrom: < "$mbox_file")
    normalize_author "$author"
}

# Function to get commit author with normalization
get_commit_author() {
    local linux_dir="$1"
    local sha1="$2"

    cd "$linux_dir"
    local author=$(git log -1 --format="%an <%ae>" "$sha1")
    normalize_author "$author"
}

# Function to compare authors and check if they match
authors_match() {
    local author1="$1"
    local author2="$2"

    # Normalize both authors
    local norm1=$(normalize_author "$author1")
    local norm2=$(normalize_author "$author2")

    # Extract email parts for comparison
    local email1=$(echo "$norm1" | grep -o '<[^>]*>' || echo "")
    local email2=$(echo "$norm2" | grep -o '<[^>]*>' || echo "")

    # If emails match and are non-empty, authors match
    if [ -n "$email1" ] && [ "$email1" = "$email2" ]; then
        return 0
    fi

    # If emails don't match or are empty, compare full normalized strings
    [ "$norm1" = "$norm2" ]
}

# Function to get sorted kernel versions
get_sorted_versions() {
    sort -rV "$HOME/stable-queue/active_kernel_versions"
}

# Function to check if version1 is newer than version2
is_version_newer() {
    local v1="$1"
    local v2="$2"

    if [ "$(echo -e "$v1\n$v2" | sort -V | tail -n1)" = "$v1" ]; then
        return 0
    fi
    return 1
}

# Function to check newer kernels for commit
check_newer_kernels() {
    local sha1="$1"
    local target_versions="$2"
    local linux_dir="$3"
    local -n c_results=$4

    cd "$linux_dir"
    local all_versions=($(get_sorted_versions))
    local target_array=($target_versions)
    local newest_target=${target_array[0]}
    local temp_dir=$(mktemp -d)
    local pids=()
    local checked_versions=()

    # Function to check a single branch and write results to temp file
    check_single_branch() {
        local version="$1"
        local branch="pending-${version}"
        local result_file="$temp_dir/$version"

        # Check if branch exists
        if ! git rev-parse --verify "$branch" >/dev/null 2>&1; then
            echo "$version.y | Branch not found" > "$result_file"
            return
        fi

        # Check if commit is an ancestor using merge-base
        if [ "$(git merge-base "$branch" "$sha1")" = "$sha1" ]; then
            echo "$version.y | Present (exact SHA1)" > "$result_file"
            return
        fi

        # Try to find by subject if SHA1 not found
        local subject
        subject=$(git log -1 --format=%s "$sha1")
        if [ -n "$subject" ]; then
            # Search in the specific branch
            local found_commit
            found_commit=$(git log "$branch" --format=%H --grep="^${subject}$" -1)
            if [ -n "$found_commit" ]; then
                echo "$version.y | Present (different SHA1: ${found_commit:0:12})" > "$result_file"
            else
                echo "$version.y | Not found" > "$result_file"
            fi
        else
            echo "$version.y | Not found" > "$result_file"
        fi
    }

    # Launch parallel processes for each relevant version
    for version in "${all_versions[@]}"; do
        # Only check versions newer than our target using sort -V for proper semantic version comparison
        # If version is newer than newest_target, it will be the second item when sorted
        if [ "$(printf "%s\n%s" "$newest_target" "$version" | sort -V | head -n1)" = "$newest_target" ] && \
           [ "$newest_target" != "$version" ]; then
            check_single_branch "$version" &
            pids+=($!)
            checked_versions+=("$version")
        fi
    done

    # Wait for all processes to complete
    for pid in "${pids[@]}"; do
        wait "$pid"
    done

    # Clear the results array
    c_results=()

    # Collect results in order (from newest to oldest)
    for version in "${checked_versions[@]}"; do
        if [ -f "$temp_dir/$version" ]; then
            c_results+=("$(cat "$temp_dir/$version")")
        fi
    done

    # Clean up
    rm -rf "$temp_dir"
}

# Function to validate commit exists in upstream
validate_commit() {
    local sha1="$1"
    local linux_dir="$2"

    cd "$linux_dir"
    git merge-base --is-ancestor "$sha1" origin/master
}

# Function to compare patch with upstream
compare_with_upstream() {
    local mbox_file="$1"
    local sha1="$2"
    local linux_dir="$3"
    local series_dir="$4"
    local current_part="$5"
    local debug_output=()

    if [[ ! $sha1 =~ ^[0-9a-f]{40}$ ]] || [ "$sha1" = "0000000000000000000000000000000000000000" ]; then
        return 0
    fi

    cd "$linux_dir"

    # Extract subject to determine target kernel versions
    local subject=$(formail -xSubject: < "$mbox_file")
    local kernel_versions=($(extract_kernel_versions "$subject"))

    if [ ${#kernel_versions[@]} -eq 0 ]; then
        debug_output+=("No kernel versions found in subject, cannot compare")
        printf '%s\n' "${debug_output[@]}"
        return 1
    fi

    # Use the newest version for comparison since it's closest to upstream
    local version=${kernel_versions[0]}
    local stable_branch="stable/linux-${version}.y"
    local temp_branch="temp-compare-${version}-$(date +%s)"

    # Create a worktree instead of checking out branches
    local worktree_path=$(create_git_worktree "$stable_branch" "$temp_branch" "$linux_dir")

    if [ -z "$worktree_path" ]; then
        debug_output+=("Failed to create worktree for ${stable_branch}")
        printf '%s\n' "${debug_output[@]}"
        return 1
    fi

    cd "$worktree_path"

    # Clean up any previous rebase-apply directory that might exist
    if [ -d ".git/rebase-apply" ]; then
        rm -rf ".git/rebase-apply"
    fi

    # Reset to ensure clean state
    git reset --hard >/dev/null 2>&1

    # If this is part of a series, apply previous patches first
    if [ -n "$series_dir" ] && [ "$current_part" -gt 1 ]; then
        if ! apply_series_patches "$series_dir" "$current_part" "$worktree_path"; then
            debug_output+=("Failed to apply previous patches in series for comparison only.")
            debug_output+=("This doesn't affect the main patch testing.")
            cd "$linux_dir"
            remove_git_worktree "$worktree_path" "$linux_dir"
            printf '%s\n' "${debug_output[@]}"
            return 1
        fi
    fi

    # Try to apply the patch
    local apply_result=$(git am "$mbox_file" 2>&1)
    if [ $? -eq 0 ]; then
        # Get the SHA1 of our newly applied patch
        local new_sha1=$(git rev-parse HEAD)

        debug_output+=("")

        # Compare the ranges using range-diff
        if ! git range-diff "${sha1}^".."$sha1" "${new_sha1}^".."$new_sha1"; then
            debug_output+=("Failed to generate range-diff, but patch applies cleanly.")
        fi

        # Clean up after range-diff
        cd "$linux_dir"
        remove_git_worktree "$worktree_path" "$linux_dir"
    else
        # Clean up failed git-am
        git am --abort >/dev/null 2>&1
        cd "$linux_dir"
        remove_git_worktree "$worktree_path" "$linux_dir"
        debug_output+=("Note: Couldn't generate comparison with upstream commit.")
        debug_output+=("This is just for the diff comparison and doesn't affect the patch application.")
        debug_output+=("Error: $apply_result")
    fi

    printf '%s\n' "${debug_output[@]}"
}

# Function to test commit on a branch
test_commit_on_branch() {
    local sha1="$1"
    local version="$2"
    local linux_dir="$3"
    local mbox_file="$4"
    local series_dir="$5"
    local current_part="$6"
    local -n results=$7
    local -n errors=$8
    local result=0

    cd "$linux_dir"
    local branch="stable/linux-${version}.y"
    local temp_branch="temp-${version}-${sha1:0:8}"

    # Create a worktree instead of checking out branches
    local worktree_path=$(create_git_worktree "$branch" "$temp_branch" "$linux_dir")

    if [ -z "$worktree_path" ]; then
        results+=("stable/linux-${version}.y | Failed (branch not found) | N/A")
        return 1
    fi

    cd "$worktree_path"

    # Clean up any previous rebase-apply directory that might exist
    if [ -d ".git/rebase-apply" ]; then
        rm -rf ".git/rebase-apply"
    fi

    # Reset to ensure clean state
    git reset --hard >/dev/null 2>&1

    # Apply series patches if needed
    if [ -n "$series_dir" ] && [ "$current_part" -gt 1 ]; then
        if ! apply_series_patches "$series_dir" "$current_part" "$worktree_path"; then
            results+=("stable/linux-${version}.y | Failed (series apply) | N/A")
            cd "$linux_dir"
            remove_git_worktree "$worktree_path" "$linux_dir"
            return 1
        fi
    fi

    # Apply current patch
    local apply_result=$(git am "$mbox_file" 2>&1)
    if [ $? -ne 0 ]; then
        # Extract patch content and try to apply with --reject to get .rej files
        local temp_patch=$(mktemp)
        formail -I "" < "$mbox_file" | sed '1,/^$/d' > "$temp_patch"
        git apply --reject "$temp_patch" >/dev/null 2>&1

        # Find and read any .rej files
        local reject_content=""
        while IFS= read -r -d '' rej_file; do
            reject_content+=$'\n'"$(cat "$rej_file")"
            rm -f "$rej_file"
        done < <(find . -name "*.rej" -print0)
        rm -f "$temp_patch"

        # Clean up
        git checkout -f >/dev/null 2>&1
        git am --abort >/dev/null 2>&1
        results+=("stable/linux-${version}.y | Failed | N/A")
        if [ -n "$reject_content" ]; then
            errors+=("Patch failed to apply on ${branch}. Reject:")
            errors+=("$reject_content")
        else
            errors+=("Patch failed to apply on ${branch}: $apply_result")
        fi
        cd "$linux_dir"
        remove_git_worktree "$worktree_path" "$linux_dir"
        return 1
    fi

    # Run build test
    local build_output
    build_output=$(stable build log 2>&1)
    local build_ret=$?

    if [ $build_ret -ne 0 ]; then
        results+=("stable/linux-${version}.y | Success | Failed")
        if [ -n "$build_output" ]; then
            errors+=("Build error for ${branch}:")
            errors+=("$(echo "$build_output" | sed 's/^/    /')")
            errors+=("")
        else
            errors+=("Build error for ${branch}: (no output captured)")
        fi
        result=1
    else
        results+=("stable/linux-${version}.y | Success | Success")
    fi

    cd "$linux_dir"
    remove_git_worktree "$worktree_path" "$linux_dir"

    return $result
}

# Function to check for fixes referencing a commit
check_fixes_for_commit() {
    local sha1="$1"
    local linux_dir="$2"
    local -n result_array=$3

    cd "$linux_dir"

    # Look for commits with Fixes: tag pointing to our commit
    local fixes_commits=$(git log origin/master --grep="Fixes: ${sha1:0:12}" --format="%H %s")

    if [ -n "$fixes_commits" ]; then
        result_array+=("Found fixes commits:")
        while IFS= read -r line; do
            local fix_sha1="${line%% *}"
            local fix_subject="${line#* }"
            result_array+=("${fix_sha1:0:12} ${fix_subject}")
        done <<< "$fixes_commits"
    fi
}

# Function to check if commit was reverted
check_if_reverted() {
    local sha1="$1"
    local linux_dir="$2"
    local -n result_array=$3

    cd "$linux_dir"

    # Look for revert commits in subject and body
    local revert_commits=$(git log origin/master --grep="This reverts commit ${sha1:0:12}\|^Revert \".*${sha1:0:12}.*\"" --format="%H %s")

    # Also look for Fixes: tags in revert commits
    local fixes_reverts=$(git log origin/master --grep="^Revert.*\|Fixes: ${sha1:0:12}" --format="%H %B" | \
                         awk -v sha="$sha1" '
                         /^[0-9a-f]{40}/ { commit=$1; subject=$0; sub(/^[0-9a-f]{40}[[:space:]]*/, "", subject); }
                         /^Revert/ && /Fixes: '"${sha1:0:12}"'/ { print commit " " subject; }
                         ')

    # Combine both results
    local all_reverts=$(printf "%s\n%s" "$revert_commits" "$fixes_reverts" | sort -u)

    if [ -n "$all_reverts" ]; then
        result_array+=("Found revert commits:")
        while IFS= read -r line; do
            if [ -n "$line" ]; then
                local revert_sha1="${line%% *}"
                local revert_subject="${line#* }"
                result_array+=("${revert_sha1:0:12} ${revert_subject}")
            fi
        done <<< "$all_reverts"
    fi
}

# Function to process single patch or series patch
process_patch() {
    local mbox_file="$1"
    local series_dir="$2"
    local current_part="$3"
    local -n p_results=$4
    local -n p_errors=$5
    local worktree_path="$6"  # Optional worktree path when called from test_series
    local failed=0

    # Extract series info first
    local subject=$(formail -xSubject: < "$mbox_file")
    local series_info=$(extract_series_info "$subject")
    local is_series_part=0
    local total_parts=0

    if [ -n "$series_info" ]; then
        read current_part total_parts <<< "$series_info"
        is_series_part=1
    fi

    # If this is part of a series and not the first patch, verify previous patches can be applied
    # Skip this check if we're called from test_series with a provided worktree
    if [ -n "$series_dir" ] && [ "$current_part" -gt 1 ] && [ -z "$worktree_path" ]; then
        # Try to apply previous patches in a temporary worktree
        cd "$LINUX_DIR"
        local temp_branch="temp-series-check-$(date +%s)"

        # Create a worktree
        worktree_path=$(create_git_worktree "HEAD" "$temp_branch" "$LINUX_DIR")

        if [ -z "$worktree_path" ]; then
            p_results+=("All branches | Failed (could not create worktree) | N/A")
            p_errors+=("Error: Cannot proceed - failed to create worktree")
            return 1
        fi

        if ! apply_series_patches "$series_dir" "$current_part" "$worktree_path"; then
            cd "$LINUX_DIR"
            remove_git_worktree "$worktree_path" "$LINUX_DIR"
            p_results+=("All branches | Failed (previous patches in series failed to apply) | N/A")
            p_errors+=("Error: Cannot proceed - previous patches in series failed to apply")
            p_errors+=("This is part ${current_part}/${total_parts} of a series.")
            p_errors+=("Please ensure all previous patches in the series apply cleanly.")
            return 1
        fi

        cd "$LINUX_DIR"
        remove_git_worktree "$worktree_path" "$LINUX_DIR"
        worktree_path=""  # Reset to empty after cleanup
    fi

    # Extract subject to get kernel versions
    local subject=$(formail -xSubject: < "$mbox_file")
    local kernel_versions=$(extract_kernel_versions "$subject")

    # Extract email body
    local email_body=$(formail -I "" < "$mbox_file")
    local claimed_sha1=$(extract_commit_sha1 "$email_body" || true)
    local found_sha1=""
    local author_mismatch=""
    local diff_output=""

    # Find or validate SHA1
    if [ -z "$claimed_sha1" ]; then
        found_sha1=$(find_commit_by_subject "$subject" "$LINUX_DIR")
    else
        if validate_commit "$claimed_sha1" "$LINUX_DIR"; then
            found_sha1="$claimed_sha1"
        else
            found_sha1=$(find_commit_by_subject "$subject" "$LINUX_DIR")
        fi
    fi

    # Use temporary SHA1 if none found
    if [ -z "$found_sha1" ]; then
        found_sha1="0000000000000000000000000000000000000000"
    fi

    # Compare authors if we found a commit
    if [ -n "$found_sha1" ] && [ "$found_sha1" != "0000000000000000000000000000000000000000" ]; then
        local patch_author=$(extract_patch_author "$mbox_file")
        local commit_author=$(get_commit_author "$LINUX_DIR" "$found_sha1")
        if ! authors_match "$patch_author" "$commit_author"; then
            author_mismatch="Backport author: $patch_author
Commit author: $commit_author"
        fi
    fi

    # Compare with upstream if we have a valid SHA1
    if [[ "$found_sha1" =~ ^[0-9a-f]{40}$ ]] && [ "$found_sha1" != "0000000000000000000000000000000000000000" ]; then
        diff_output=$(compare_with_upstream "$mbox_file" "$found_sha1" "$LINUX_DIR" "$series_dir" "$current_part")
    fi

    # Test on each kernel version
    # Skip individual testing if we're called with a worktree (as part of test_series)
    if [ -z "$worktree_path" ]; then
        for version in $kernel_versions; do
            if ! test_commit_on_branch "$found_sha1" "$version" "$LINUX_DIR" "$mbox_file" \
                                      "$series_dir" "$current_part" p_results p_errors; then
                failed=1
            fi
        done
    else
        # If we have a worktree provided, just test applying the patch to it
        cd "$worktree_path"

        # Get the actual branch name for reporting
        local branch_name=""

        # First try to extract from the worktree path which should have the format temp-series-VERSION-timestamp
        if [[ "$worktree_path" =~ temp-series-([0-9]+\.[0-9]+)- ]]; then
            branch_name="${BASH_REMATCH[1]}"
        # Fallback to checking the git branch
        else
            # Get current git branch
            branch_name=$(git symbolic-ref --short HEAD 2>/dev/null || git rev-parse --short HEAD)
            # Extract version if it's in the branch name
            if [[ "$branch_name" =~ linux-([0-9]+\.[0-9]+)\.y ]]; then
                branch_name="${BASH_REMATCH[1]}"
            fi
        fi

        # Default if we couldn't determine the branch
        local full_branch_name="Current branch"
        if [ -n "$branch_name" ]; then
            full_branch_name="stable/linux-${branch_name}.y"
        fi

        # Clean up any previous rebase-apply directory that might exist
        if [ -d ".git/rebase-apply" ]; then
            rm -rf ".git/rebase-apply"
        fi

        # Reset to ensure clean state
        git reset --hard >/dev/null 2>&1

        # Try to apply the patch
        local apply_result=$(git am "$mbox_file" 2>&1)
        if [ $? -ne 0 ]; then
            p_results+=("$full_branch_name | Failed to apply | N/A")
            p_errors+=("Error applying patch to worktree: $apply_result")
            git am --abort >/dev/null 2>&1
            failed=1
        else
            # Run build test
            local build_output
            build_output=$(stable build log 2>&1)
            local build_ret=$?

            if [ $build_ret -ne 0 ]; then
                p_results+=("$full_branch_name | Success | Failed")
                if [ -n "$build_output" ]; then
                    p_errors+=("Build error:")
                    p_errors+=("$(echo "$build_output" | sed 's/^/    /')")
                    p_errors+=("")
                else
                    p_errors+=("Build error: (no output captured)")
                fi
                failed=1
            else
                p_results+=("$full_branch_name | Success | Success")
            fi
        fi
    fi

    # Check newer kernels if we have a valid SHA1
    local -a newer_kernel_results=()
    if [[ "$found_sha1" =~ ^[0-9a-f]{40}$ ]] && [ "$found_sha1" != "0000000000000000000000000000000000000000" ]; then
        check_newer_kernels "$found_sha1" "$kernel_versions" "$LINUX_DIR" newer_kernel_results
    fi

    # Check for fixes and reverts if we have a valid SHA1
    local -a fixes_results=()
    local -a revert_results=()
    if [[ "$found_sha1" =~ ^[0-9a-f]{40}$ ]] && [ "$found_sha1" != "0000000000000000000000000000000000000000" ]; then
        check_fixes_for_commit "$found_sha1" "$LINUX_DIR" fixes_results
        check_if_reverted "$found_sha1" "$LINUX_DIR" revert_results
    fi

    # Generate response for this patch
    generate_response "$mbox_file" "$claimed_sha1" "$found_sha1" \
                     "$(printf '%s\n' "${p_results[@]}")" "$diff_output" \
                     "$author_mismatch" "$(printf '%s\n' "${p_errors[@]}")" \
                     "$(printf '%s\n' "${newer_kernel_results[@]}")" \
                     "$(printf '%s\n' "${fixes_results[@]}")" \
                     "$(printf '%s\n' "${revert_results[@]}")"

    return $failed
}

# Function to test complete series
test_series() {
    local series_dir="$1"
    local total_parts="$2"
    local linux_dir="$3"
    local failed=0

    # Get the first patch to determine target kernel versions
    local first_patch="$series_dir/1.mbox"
    if [ ! -f "$first_patch" ]; then
        echo "Error: First patch in series not found: $first_patch"
        return 1
    fi

    # Extract subject and kernel versions from first patch
    local subject=$(formail -xSubject: < "$first_patch")
    local kernel_versions=$(extract_kernel_versions "$subject")

    if [ -z "$kernel_versions" ]; then
        echo "Error: Cannot determine target kernel versions from patch subject"
        return 1
    fi

    # Process each kernel version
    for version in $kernel_versions; do
        local stable_branch="stable/linux-${version}.y"
        echo "Testing series on $stable_branch..."

        # Process each patch in the series
        for ((i=1; i<=total_parts; i++)); do
            local mbox_file="$series_dir/$i.mbox"
            declare -a patch_results=()
            declare -a patch_errors=()

            # Create a worktree for this branch
            # Use a naming convention that includes the version for easier extraction later
            local temp_branch="temp-series-${version}-$(date +%s)"
            local worktree_path=$(create_git_worktree "$stable_branch" "$temp_branch" "$linux_dir")

            if [ -z "$worktree_path" ]; then
                echo "Error: Failed to create worktree for branch $stable_branch"
                failed=1
                continue
            fi

            # If not the first patch, apply previous patches
            if [ $i -gt 1 ]; then
                if ! apply_series_patches "$series_dir" "$i" "$worktree_path"; then
                    echo "Error: Failed to apply previous patches in series on $stable_branch"
                    remove_git_worktree "$worktree_path" "$linux_dir"
                    failed=1
                    break
                fi
            fi

            # Now process the current patch
            if ! process_patch "$mbox_file" "$series_dir" "$i" patch_results patch_errors "$worktree_path"; then
                failed=1
                remove_git_worktree "$worktree_path" "$linux_dir"
                break
            fi

            # Clean up worktree after testing each patch
            remove_git_worktree "$worktree_path" "$linux_dir"
        done
    done

    return $failed
}

# Function to generate email response
generate_response() {
    local mbox_file="$1"
    local claimed_sha1="$2"
    local found_sha1="$3"
    local results="$4"
    local diff_output="$5"
    local author_mismatch="$6"
    local build_errors="$7"
    local newer_kernel_results="$8"
    local fixes_results="$9"
    local revert_results="${10}"
    local response_file=$(generate_response_filename "$mbox_file")

    # Check if this is a stable-only commit
    local email_body=$(formail -I "" < "$mbox_file")
    local is_stable_only=0
    if echo "$email_body" | grep -i "stable.only" >/dev/null 2>&1; then
        is_stable_only=1
    fi

    {
        # Get the From, Subject, Message-ID, and Date from original email for threading
        formail -X From: -X Subject: < "$mbox_file"
        echo "Message-ID: $(generate_message_id)"
        echo "Date: $(date -R)"
        echo "In-Reply-To: $(formail -xMessage-ID: < "$mbox_file")"
        echo "From: $(git config user.name) <$(git config user.email)>"

        # Use original subject line directly from the email, just add Re: if needed
        local orig_subject=$(formail -xSubject: < "$mbox_file" | \
            tr '\n' ' ' | \
            tr -s ' ' | \
            sed -e 's/^[[:space:]]*//g' -e 's/[[:space:]]*$//g')

        # Only add "Re: " if it's not already there
        if [[ ! "$orig_subject" =~ ^Re: ]]; then
            echo "Subject: Re: $orig_subject"
        else
            echo "Subject: $orig_subject"
        fi

        # Add summary section to determine if there are issues
        local has_issues=0
        local summary=()
        local is_series_part=0
        local series_info=$(extract_series_info "$orig_subject")

        if [ -n "$series_info" ]; then
            read current_part total_parts <<< "$series_info"
            is_series_part=1
            if [ "$current_part" -gt 1 ]; then
                summary+=("ℹ️ This is part ${current_part}/${total_parts} of a series")
            fi
        fi

        # Check for build failures
        if [[ "$results" == *"| Failed"* ]]; then
            has_issues=1
            summary+=("❌ Build failures detected")
        fi

        # Check for missing or unverified commit (skip for stable-only commits)
        if [ $is_stable_only -eq 0 ]; then
            if [ -z "$found_sha1" ] || [ "$found_sha1" = "0000000000000000000000000000000000000000" ]; then
                has_issues=1
                summary+=("⚠️ Could not find matching upstream commit")
            elif [ -n "$claimed_sha1" ] && [ "$claimed_sha1" != "$found_sha1" ]; then
                has_issues=1
                summary+=("⚠️ Provided upstream commit SHA1 does not match found commit")
            elif [ -z "$claimed_sha1" ] && [ -n "$found_sha1" ]; then
                has_issues=1
                summary+=("⚠️ Found matching upstream commit but patch is missing proper reference to it")
            fi
        fi

        # Check for fixes
        if [ -n "$fixes_results" ]; then
            has_issues=1
            summary+=("⚠️ Found follow-up fixes in mainline")
        fi

        # Check for reverts
        if [ -n "$revert_results" ]; then
            has_issues=1
            summary+=("❌ Commit was reverted in mainline")
        fi

        # Add appropriate email headers based on whether there are issues
        if [ $has_issues -eq 1 ]; then
            # If there are issues, send to author and CC stable
            local author_email=$(formail -xFrom: < "$mbox_file" | sed -e 's/.*<\([^>]*\)>.*/\1/')
            echo "To: $author_email"
            echo "Cc: stable@vger.kernel.org"
        else
            # If no issues, send only to stable
            echo "To: stable@vger.kernel.org"
        fi
        echo

        echo "[ Sasha's backport helper bot ]"
        echo
        echo "Hi,"
        echo

        # Print summary section
        if [ $has_issues -eq 1 ]; then
            echo "Summary of potential issues:"
            printf '%s\n' "${summary[@]}"
            echo
        else
            # Check if patch applies and builds successfully
            if [[ "$results" == *"| Success | Success"* ]]; then
                echo "✅ All tests passed successfully. No issues detected."
                echo "No action required from the submitter."
                echo
            fi
        fi

        # Report on SHA1 verification and commit status
        if [ $is_stable_only -eq 1 ]; then
            echo "Note: This is a stable-only commit."
        elif [ -n "$claimed_sha1" ]; then
            if [ "$claimed_sha1" = "$found_sha1" ]; then
                echo "The upstream commit SHA1 provided is correct: $claimed_sha1"
                if [ -n "$author_mismatch" ]; then
                    echo
                    echo "WARNING: Author mismatch between patch and upstream commit:"
                    echo "$author_mismatch"
                fi
            else
                echo "The claimed upstream commit SHA1 ($claimed_sha1) was not found."
                if [ -n "$found_sha1" ] && [ "$found_sha1" != "0000000000000000000000000000000000000000" ]; then
                    echo "However, I found a matching commit: $found_sha1"
                    if [ -n "$author_mismatch" ]; then
                        echo
                        echo "WARNING: Author mismatch between patch and found commit:"
                        echo "$author_mismatch"
                    fi
                fi
            fi
        elif [ -n "$found_sha1" ] && [ "$found_sha1" != "0000000000000000000000000000000000000000" ]; then
            echo "Found matching upstream commit: $found_sha1"
            if [ -n "$author_mismatch" ]; then
                echo
                echo "WARNING: Author mismatch between patch and found commit:"
                echo "$author_mismatch"
            fi
        else
            echo "No upstream commit was identified. Using temporary commit for testing."
        fi
        echo

        # Add newer kernel check results if available
        if [ -n "$newer_kernel_results" ] && [ "${#newer_kernel_results[@]}" -gt 0 ]; then
            echo "Status in newer kernel trees:"
            printf '%s\n' "${newer_kernel_results[@]}"
            echo
        fi

        # Add fixes and revert information if available
        if [ -n "$fixes_results" ]; then
            echo "$fixes_results"
            echo
        fi

        if [ -n "$revert_results" ]; then
            echo "$revert_results"
            echo
        fi

        # Add diff if there are differences and we have a valid SHA1
        if [ -n "$diff_output" ] && [[ "$found_sha1" =~ ^[0-9a-f]{40}$ ]] && \
           [ "$found_sha1" != "0000000000000000000000000000000000000000" ]; then
            # Check if this is just a failure message rather than actual diff
            if [[ "$diff_output" == *"Couldn't generate comparison"* ]]; then
                echo "Note: Could not generate a diff with upstream commit:"
            else
                echo "Note: The patch differs from the upstream commit:"
            fi
            echo "---"
            echo "$diff_output"
            echo "---"
            echo
        fi

        # Print results table
        if [ $is_series_part -eq 1 ] && [ "$current_part" -gt 1 ] && [ $has_issues -eq 1 ]; then
            echo "NOTE: These results are for this patch alone. Full series testing will be"
            echo "performed when all parts are received."
            echo
        fi
        echo "Results of testing on various branches:"
        echo
        printf "| %-25s | %-11s | %-10s |\n" "Branch" "Patch Apply" "Build Test"
        echo "|---------------------------|-------------|------------|"
        while IFS='|' read -r branch status build; do
            if [ -n "$branch" ]; then
                printf "| %-25s | %-11s | %-10s |\n" "$branch" "$status" "$build"
            fi
        done <<< "$results"

        # Add build errors if any
        if [ -n "$build_errors" ]; then
            echo
            echo "Build Errors:"
            echo "$build_errors"
        fi

    } > "$response_file"

    echo "Response written to $response_file"
}

# Cleanup function to remove any remaining worktrees
cleanup() {
    if [ -d "$LINUX_DIR" ]; then
        cd "$LINUX_DIR"
        # Remove any worktrees we created
        if [ -d "$WORKTREE_DIR" ]; then
            for worktree in "$WORKTREE_DIR"/*; do
                if [ -d "$worktree" ]; then
                    # Try to cleanup any git operations first
                    if [ -d "$worktree/.git" ]; then
                        cd "$worktree" 2>/dev/null
                        if [ $? -eq 0 ]; then
                            # Abort any in-progress git operations
                            git am --abort >/dev/null 2>&1
                            git rebase --abort >/dev/null 2>&1
                            git reset --hard >/dev/null 2>&1
                            cd "$LINUX_DIR"
                        fi
                    fi

                    # Now try to remove via git
                    if ! git worktree remove --force "$worktree" >/dev/null 2>&1; then
                        # If that fails, use rm -rf
                        rm -rf "$worktree"
                    fi
                fi
            done

            # Try to remove the directory
            rm -rf "$WORKTREE_DIR" 2>/dev/null || true

            # Prune any worktree references
            git worktree prune >/dev/null 2>&1
        fi

        # Clean up any temp patch file
        rm -f "$TEMP_PATCH" 2>/dev/null || true
    fi
}

# Main script
main() {
    if [ $# -ne 1 ]; then
        echo "Usage: $0 <mbox_file>"
        exit 1
    fi

    MBOX_FILE="$1"
    local diff_output=""
    local failed=0

    echo "Looking at $MBOX_FILE"

    # Validate inputs
    if [ ! -f "$MBOX_FILE" ]; then
        echo "Error: File '$MBOX_FILE' not found"
        exit 1
    fi

    if [ ! -d "$LINUX_DIR" ]; then
        echo "Error: Linux git tree not found at $LINUX_DIR"
        exit 1
    fi

    if [ ! -f "$HOME/stable-queue/active_kernel_versions" ]; then
        echo "Error: Active kernel versions file not found at ~/stable-queue/active_kernel_versions"
        exit 1
    fi

    # Check if we should ignore this mail
    if should_ignore_mail "$MBOX_FILE"; then
        echo "Skipping mail from ignored author"
        exit 0
    fi

    # Check if mail contains a git patch
    if ! is_git_patch "$MBOX_FILE"; then
        echo "Skipping mail: not a git patch"
        exit 0
    fi

    # Extract subject and series information
    subject=$(formail -xSubject: < "$MBOX_FILE")
    if [ -z "$subject" ]; then
        echo "Error: Could not extract subject from mbox"
        exit 1
    fi

    # Get kernel versions to process
    kernel_versions=$(extract_kernel_versions "$subject")
    local has_specific_versions=0
    if [ "$kernel_versions" != "$(cat $HOME/stable-queue/active_kernel_versions)" ]; then
        has_specific_versions=1
    fi

    # Extract email body
    email_body=$(formail -I "" < "$MBOX_FILE")

    # Try to find SHA1 in the email body
    claimed_sha1=$(extract_commit_sha1 "$email_body" || true)
    found_sha1=""

    # If we didn't find SHA1 in the body, try to find it by subject
    if [ -z "$claimed_sha1" ]; then
        found_sha1=$(find_commit_by_subject "$subject" "$LINUX_DIR")
    else
        if validate_commit "$claimed_sha1" "$LINUX_DIR"; then
            found_sha1="$claimed_sha1"
        else
            found_sha1=$(find_commit_by_subject "$subject" "$LINUX_DIR")
        fi
    fi

    # Skip if we have no SHA1 and no specific kernel versions
    if [ -z "$found_sha1" ] && [ $has_specific_versions -eq 0 ]; then
        echo "No commit SHA1 found and no specific kernel versions in subject. Skipping patch."
        exit 0
    fi

    # Check if this is part of a series
    series_info=$(extract_series_info "$subject")
    if [ -n "$series_info" ]; then
        read current_part total_parts <<< "$series_info"

        # Skip 0/N patches
        if [ "$current_part" -eq 0 ]; then
            echo "Skipping 0/$total_parts patch"
            exit 0
        fi

        # Get message IDs and determine series directory
        message_id=$(get_message_id "$MBOX_FILE")
        in_reply_to=$(get_in_reply_to "$MBOX_FILE")
        series_dir="$PENDING_DIR/$(get_series_dir "$message_id" "$in_reply_to")"

        # Store this patch
        store_patch "$MBOX_FILE" "$series_dir" "$current_part"

        echo "Processing part $current_part of $total_parts"

        # Check if series is now complete
        if is_series_complete "$series_dir" "$total_parts"; then
            echo "Series complete, testing all patches..."
            if ! test_series "$series_dir" "$total_parts" "$LINUX_DIR"; then
                echo "Series testing failed. See logs for details."
                failed=1
            else
                echo "Series testing completed successfully."
            fi
            # Clean up series directory regardless of result
            rm -rf "$series_dir"
            exit $failed
        else
            echo "Series incomplete, waiting for remaining patches..."
            echo "Processed part $current_part of $total_parts"
            exit 0
        fi
    else
        # Single patch processing
        declare -a patch_results=()
        declare -a patch_errors=()
        if ! process_patch "$MBOX_FILE" "" "1" patch_results patch_errors; then
            failed=1
        fi
    fi

    exit $failed
}

# Set up trap for cleanup
trap cleanup EXIT ERR

# Run main script
main "$@"