git branch --merged | grep -Ev "(^\*|^\+|production|develop|master)" | xargs git branch -d

git checkout -q master && git for-each-ref refs/heads/ "--format=%(refname:short)" | while read branch; do mergeBase=$(git merge-base master $branch) && [[ $(git cherry master $(git commit-tree $(git rev-parse "$branch^{tree}") -p $mergeBase -m _)) == "-"* ]] && git branch -D $branch; done

deleted_on_remote=$(git remote prune $REMOTE_NAME --dry-run 2>&1 | grep '\[would prune\]' | awk '{print $NF}' | sed "s#^$REMOTE_NAME/##")

git switch "$branch"
git merge develop --no-edit --quiet || {
    echo "Merge failed for $branch, skipping deletion."
    continue
}

if ! git diff --quiet develop; then
    echo "Branch $branch has differences with develop, skipping deletion."
    continue
fi

#!/bin/bash

# --- Configuration ---
REMOTE_NAME="origin" # Change if your remote has a different name

# --- Colors ---
RED='\033[0;31m'
YELLOW='\033[1;33m' # For warnings or info
NC='\033[0m' # No Color

# --- Autostash Setup ---
stash_created=false
# Function to pop the stash if it was created by this script
pop_stash() {
  if [ "$stash_created" = true ]; then
    echo "-----------------------------"
    echo -e "${YELLOW}Popping autostash...${NC}"
    git stash pop || echo -e "${RED}Warning: 'git stash pop' failed. You may need to resolve conflicts manually.${NC}"
  fi
}
# Set a trap to ensure pop_stash is called on any script exit (normal, error, or user abort)
trap pop_stash EXIT

# --- Safety Check: Ensure we are in a git repository ---
if ! git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
  echo -e "${RED}Error: Not inside a Git repository.${NC}"
  exit 1
fi

# --- Autostash Execution ---
# Check for uncommitted changes (staged or unstaged)
if ! git diff-index --quiet HEAD --; then
  echo -e "${YELLOW}Uncommitted changes detected. Creating an autostash...${NC}"
  git stash push -m "autostash-by-cleanup-script-$(date +%s)"
  stash_created=true
  echo "-----------------------------"
fi

echo "Checking for local branches whose remote tracking branches on '$REMOTE_NAME' have been deleted..."

# --- Step 1: Get list of remote branches deleted on the specified remote ---
# Use 'git remote prune --dry-run' which is designed for this.
# Output is like: * [would prune] origin/branch-name
# We extract the part after 'origin/'
deleted_on_remote_raw=$(git remote prune $REMOTE_NAME --dry-run 2>&1)
if [[ $? -ne 0 ]]; then
    echo -e "${RED}Error checking remote prune status. Output:${NC}"
    echo "$deleted_on_remote_raw"
    exit 1
fi

deleted_on_remote=$(echo "$deleted_on_remote_raw" | grep '\[would prune\]' | awk '{print $NF}' | sed "s#^$REMOTE_NAME/##")

if [[ -z "$deleted_on_remote" ]]; then
  echo "No remote branches seem to have been deleted on '$REMOTE_NAME' since last fetch/prune."
  # Optional: Still run fetch -p to actually prune remote refs if needed
  # echo "Running 'git fetch -p' to update remote refs..."
  # git fetch -p $REMOTE_NAME
  exit 0
fi

# --- Step 2: Get list of local branches ---
# Use plumbing 'git for-each-ref' for robustness
local_branches=$(git for-each-ref --format='%(refname:short)' refs/heads/)

# --- Step 3: Get the current branch ---
# Use plumbing 'git symbolic-ref'
current_branch=$(git symbolic-ref --short HEAD 2>/dev/null) || current_branch=""

# --- Step 4: Compare and identify local branches to potentially delete ---
declare -a branches_to_delete # Array to hold branches marked for deletion
declare -a branches_to_display # Array to hold display lines

echo "Comparing with local branches:"
echo "-----------------------------"

has_branches_to_delete=false

while IFS= read -r local_branch; do
  # Ignore the current branch - never delete it automatically
  if [[ "$local_branch" == "$current_branch" ]]; then
    branches_to_display+=("* ${local_branch} (current branch)")
    continue
  fi

  # Check if this local branch exists in the list of deleted remote branches
  # Use grep -Fxq for exact, fixed string, quiet match within the list
  if grep -Fxq "$local_branch" <<< "$deleted_on_remote"; then
    # Found a match - mark for deletion
    branches_to_display+=("- ${RED}${local_branch} (remote deleted)${NC}")
    branches_to_delete+=("$local_branch")
    has_branches_to_delete=true
  else
    # No match - just display normally
    branches_to_display+=("  ${local_branch}")
  fi
done <<< "$local_branches"

# --- Step 5: Display the list ---
if [ ${#branches_to_display[@]} -eq 0 ]; then
    echo "No local branches found."
    exit 0
fi

# Print the collected display lines
for line in "${branches_to_display[@]}"; do
  echo -e "$line"
done
echo "-----------------------------"


# --- Step 6: Check if any branches are marked for deletion ---
if ! $has_branches_to_delete; then
  echo "No local branches correspond to deleted remote branches."
  # Optional: Run fetch -p here if you want to ensure pruning happens even if no local match
  # echo "Running 'git fetch -p' to update remote refs..."
  # git fetch -p $REMOTE_NAME
  exit 0
fi

echo # Newline for clarity before prompt

# --- Step 7: Ask for confirmation ---
# Use '-ei "y"' in read for bash >= 4 (default to 'y')
# Fallback for older bash
read -p "$(echo -e Are you sure you want to delete the ${RED}RED${NC} local branches listed above? \(y/N\):) " response
response_lower=$(echo "$response" | tr '[:upper:]' '[:lower:]') # portable lowercase

# --- Step 8: Perform deletion if confirmed ---
if [[ "$response_lower" == "y" ]]; then
  echo "Proceeding with deletion..."
  deleted_count=0
  error_count=0
  # Actually prune the remote tracking refs first
  # echo "Running 'git fetch -p $REMOTE_NAME' to sync remote refs..."
  # git fetch -p $REMOTE_NAME

  echo "Deleting local branches..."
  for branch in "${branches_to_delete[@]}"; do
    echo -n "Deleting local branch '$branch'... "
    # Use 'git branch -d' (porcelain, but standard and safer as it checks for merged status)
    # Use 'git branch -D' for force deletion if desired.

    git switch "$branch"
    git merge develop --no-edit --quiet || {
      echo -e "${RED}Merge failed for $branch, skipping deletion.${NC}"
      git merge --abort
      ((error_count++))
      continue
    }
    # check if we have some difference with develop
    if ! git diff --quiet develop; then
      # assert slate is pristine before --hard reset
      if ! git diff --quiet; then
        echo -e "${RED}Local changes detected in $branch, aborting merge.${NC}"
        continue
      fi
      git reset --hard HEAD~1
      echo -e "${YELLOW}Branch $branch has differences with develop, skipping deletion.${NC}"
      ((error_count++))
      continue
    fi

    git switch develop

    if git branch -D "$branch"; then
      echo -e "${YELLOW}Deleted.${NC}"
      ((deleted_count++))
    else
      echo -e "${RED}Failed for $branch.${NC}"
      ((error_count++))
    fi
  done
  echo "-----------------------------"
  echo "Deletion complete. $deleted_count branches deleted."
  if [[ $error_count -gt 0 ]]; then
      echo -e "${RED}$error_count branches failed to delete (see messages above).${NC}"
      exit 1 # Exit with error status if deletions failed
  fi
else
  echo "Aborted by user. No local branches were deleted."
  echo "You might still want to run 'git fetch -p $REMOTE_NAME' to prune remote-tracking references."
fi

exit 0