# Method 1: Ask user
read -p "Enter target branch (main/develop/staging/etc.): " TARGET_BRANCH

# Method 2: Detect default
if [ -z "$TARGET_BRANCH" ]; then
  TARGET_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@')
fi

# Method 3: Use provided default (e.g., from PLAN.md or previous PRs)
# If branch name contains "feature/*", default to develop or main
# If branch name contains "hotfix/*", default to main
# If branch name contains "release/*", default to main or staging

# Linting check (if enabled)
if [ "$RUN_LINTING" = "true" ]; then
  echo "Running linting..."
  if command -v npm &>/dev/null; then
    npm run lint
  elif command -v poetry &>/dev/null; then
    poetry run ruff check .
  fi
fi

# Build check (if enabled)
if [ "$RUN_BUILD" = "true" ]; then
  echo "Running build..."
  if command -v npm &>/dev/null; then
    npm run build
  fi
fi

#### Virtual Environment Detection for Python

**Purpose**: Ensure Python tests and type checks run in isolated virtual environment to prevent system library pollution

**Detection Patterns** (checked in priority order):
- `.venv` - Poetry default
- `venv` - Python standard
- `myvenv` - Custom
- `env` - Alternative
- `virtualenv` - Legacy

**Shell Detection and Activation**:
```bash
# Function to detect and activate virtual environment
activate_venv() {
  # Check for virtual environments in priority order
  for venv_dir in ".venv" "venv" "myvenv" "env" "virtualenv"; do
    if [ -d "$venv_dir" ]; then
      # Check shell type and activate accordingly
      if [ -n "${ZSH_VERSION:-}" ] || [ -n "${BASH_VERSION:-}" ]; then
        if [ -f "$venv_dir/bin/activate" ]; then
          source "$venv_dir/bin/activate"
          echo "✅ Using virtual environment: $venv_dir"
          return 0
        fi
      elif [ -n "${FISH_VERSION:-}" ]; then
        if [ -f "$venv_dir/bin/activate.fish" ]; then
          source "$venv_dir/bin/activate.fish"
          echo "✅ Using virtual environment: $venv_dir (fish)"
          return 0
        fi
      fi
    fi
  done

  # No virtual environment found
  return 1
}

if (Test-Path ".venv") {
  .\.venv\Scripts\Activate.ps1
  Write-Host "✅ Using virtual environment: .venv"
} elseif (Test-Path "venv") {
  .\venv\Scripts\Activate.ps1
  Write-Host "✅ Using virtual environment: venv"
}

# Before running Python tests or type checks
if command -v poetry &>/dev/null; then
  if ! activate_venv; then
    echo "⚠️  No virtual environment found"
    if [ -f pyproject.toml ]; then
      read -p "Create virtual environment with 'poetry install'? (y/n): " CREATE_VENV
      if [ "$CREATE_VENV" = "y" ]; then
        echo "Creating virtual environment..."
        poetry install
        source .venv/bin/activate
        echo "✅ Created and activated virtual environment"
      else
        echo "⚠️  Warning: Tests may affect system Python libraries"
      fi
    else
      read -p "Create virtual environment with 'python -m venv .venv'? (y/n): " CREATE_VENV
      if [ "$CREATE_VENV" = "y" ]; then
        echo "Creating virtual environment..."
        python -m venv .venv
        source .venv/bin/activate
        echo "✅ Created and activated virtual environment"
      else
        echo "⚠️  Warning: Tests may affect system Python libraries"
      fi
    fi
  fi
fi

if [ "$UNDOC_COUNT" -gt 0 ]; then
  echo "Found $UNDOC_COUNT undocumented items"
fi

**Quality Check Results**:
```bash
# Store results for PR description
LINT_RESULT="✅ Passed" || "❌ Failed"
BUILD_RESULT="✅ Passed" || "❌ Failed"
TEST_RESULT="✅ Passed" || "❌ Failed"
TYPECHECK_RESULT="✅ Passed" || "❌ Failed"
DOCSTRING_RESULT="✅ Passed" || "❌ Failed (industry best practice)"

# Check commits for JIRA ticket
JIRA_TICKET=$(git log --oneline -1 | grep -oE '[A-Z]+-[0-9]+')

# Check commits for git issue reference
GIT_ISSUE=$(git log --oneline -1 | grep -oE '#[0-9]+')

# Check PLAN.md for tracking references
if [ -f "PLAN.md" ]; then
  PLAN_JIRA=$(grep -oE '[A-Z]+-[0-9]+' PLAN.md | head -1)
  PLAN_ISSUE=$(grep -oE '#[0-9]+' PLAN.md | head -1)
fi

# Determine tracking system
if [ -n "$JIRA_TICKET" ]; then
  TRACKING_SYSTEM="jira"
  TRACKING_ID="$JIRA_TICKET"
elif [ -n "$PLAN_JIRA" ]; then
  TRACKING_SYSTEM="jira"
  TRACKING_ID="$PLAN_JIRA"
elif [ -n "$GIT_ISSUE" ]; then
  TRACKING_SYSTEM="git"
  TRACKING_ID="$GIT_ISSUE"
else
  TRACKING_SYSTEM="none"
  TRACKING_ID=""
fi

# Check if working tree is clean
GIT_STATUS=$(git status --porcelain)

if [ -n "$GIT_STATUS" ]; then
  echo "Warning: You have uncommitted changes:"
  echo "$GIT_STATUS"
  read -p "Commit changes before creating PR? (y/n): " COMMIT_CHANGES
  if [ "$COMMIT_CHANGES" = "y" ]; then
    git add .
    git commit -m "Prepare for PR"
  fi
fi

# Check if branch has remote tracking
CURRENT_BRANCH=$(git branch --show-current)
REMOTE_TRACKING=$(git branch --show-current | grep -q "@" && echo "yes" || echo "no")

if [ "$REMOTE_TRACKING" = "no" ]; then
  echo "Branch does not track remote. Pushing..."
  git push -u origin "$CURRENT_BRANCH"
fi

# Search for common image locations
IMAGES=()

# Check diagrams directory
if [ -d "diagrams" ]; then
  IMAGES+=($(find diagrams -type f \( -name "*.png" -o -name "*.svg" -o -name "*.jpg" -o -name "*.jpeg" \)))
fi

# Check tmp directory
IMAGES+=($(find /tmp -type f \( -name "*.png" -o -name "*.svg" \) -mmin -60 2>/dev/null))

# Check for workflow-related files
IMAGES+=($(find . -maxdepth 2 -type f \( -name "*workflow*.png" -o -name "*diagram*.png" \) 2>/dev/null))

# Display found images
if [ ${#IMAGES[@]} -gt 0 ]; then
  echo "Found images:"
  printf '  - %s\n' "${IMAGES[@]}"
  read -p "Include these images in PR? (y/n): " INCLUDE_IMAGES
else
  INCLUDE_IMAGES="n"
fi

gh pr create \
  --base "$TARGET_BRANCH" \
  --title "feat: <summary> [${TRACKING_ID}]" \
  --body "$(cat <<'EOF'
## Summary
<Bullet points describing changes>

## JIRA Reference
- Ticket: ${TRACKING_ID}
- Link: https://<company>.atlassian.net/browse/${TRACKING_ID}

## Changes
- <Key change 1>
- <Key change 2>
- <Key change 3>

## Quality Checks
- Linting: ${LINT_RESULT}
- Build: ${BUILD_RESULT}
- Tests: ${TEST_RESULT}
- Type Check: ${TYPECHECK_RESULT}

## Files Modified
- \`src/path/to/file1.ts\` - Description
- \`src/path/to/file2.tsx\` - Description
- \`README.md\` - Documentation updates

## Checklist
- [ ] Code follows project style guidelines
- [ ] All quality checks passed
- [ ] Documentation updated
- [ ] Self-reviewed
EOF
)"

gh pr create \
  --base "$TARGET_BRANCH" \
  --title "fix: <summary> (#${TRACKING_ID})" \
  --body "$(cat <<'EOF'
## Summary
<Bullet points describing changes>

## Issue Reference
- Resolves #${TRACKING_ID}
- Link: <issue-url>

## Changes
- <Key change 1>
- <Key change 2>

## Quality Checks
- Linting: ${LINT_RESULT}
- Build: ${BUILD_RESULT}
- Tests: ${TEST_RESULT}

## Files Modified
- \`src/path/to/file1.ts\` - Description
- \`src/path/to/file2.tsx\` - Description

## Checklist
- [ ] Code follows project style guidelines
- [ ] All quality checks passed
- [ ] Documentation updated
- [ ] Self-reviewed
EOF
)"

gh pr create \
  --base "$TARGET_BRANCH" \
  --title "feat: <summary>" \
  --body "$(cat <<'EOF'
## Summary
<Bullet points describing changes>

## Changes
- <Key change 1>
- <Key change 2>
- <Key change 3>

## Quality Checks
- Linting: ${LINT_RESULT}
- Build: ${BUILD_RESULT}
- Tests: ${TEST_RESULT}
- Type Check: ${TYPECHECK_RESULT}

## Files Modified
- \`src/path/to/file1.ts\` - Description
- \`src/path/to/file2.tsx\` - Description

## Checklist
- [ ] Code follows project style guidelines
- [ ] All quality checks passed
- [ ] Documentation updated
- [ ] Self-reviewed
EOF
)"

if [ "$INCLUDE_IMAGES" = "y" ] && [ ${#IMAGES[@]} -gt 0 ]; then
  for image in "${IMAGES[@]}"; do
    if [[ "$image" =~ ^https?:// ]]; then
      # It's already a URL - add to PR
      PR_BODY+="
![Diagram]($image)"
    elif [ -f "$image" ]; then
      # Local file - need to upload
      # Option 1: Upload to JIRA if tracking system is JIRA
      # Option 2: Upload to image hosting service
      # Option 3: Commit to repository (for diagrams)
      echo "Local image: $image"
      echo "This should be uploaded or committed to the repository"
    fi
  done
fi

# Get PR number
PR_NUMBER=$(gh pr view --json number --jq '.number')
PR_URL=$(gh pr view --json url --jq '.url')

# Display success message
echo ""
echo "✅ Pull request created successfully!"
echo ""
echo "**PR Details:**"
echo "- Number: #$PR_NUMBER"
echo "- Title: <pr-title>"
echo "- Branch: $CURRENT_BRANCH"
echo "- Target: $TARGET_BRANCH"
echo "- URL: $PR_URL"
echo ""

# Ask for merge confirmation
read -p "Would you like to proceed with merging this PR? If yes, please specify target branch (default: $TARGET_BRANCH): " MERGE_CONFIRMATION

if [ "$MERGE_CONFIRMATION" = "y" ]; then
  read -p "Enter target branch (default: $TARGET_BRANCH): " MERGE_TARGET
  MERGE_TARGET=${MERGE_TARGET:-$TARGET_BRANCH}

  # Merge PR
  gh pr merge "$PR_NUMBER" --base "$MERGE_TARGET"
  echo "✅ PR merged into $MERGE_TARGET"

  # Step 9: Update JIRA Ticket Status (if applicable)
  if [ "$TRACKING_SYSTEM" = "jira" ] && [ -n "$TRACKING_ID" ]; then
    read -p "Update JIRA ticket status to Done? (y/n): " UPDATE_JIRA

    if [ "$UPDATE_JIRA" = "y" ]; then
      echo ""
      echo "Updating JIRA ticket status..."
      echo "=========================================="

      # Use jira-status-updater to transition ticket
      # This skill handles:
      # - Detecting JIRA ticket from PR/commits
      # - Querying available transitions
      # - Finding target status (Done/Closed)
      # - Executing status transition
      # - Adding merge comment with details

      # Integration pattern:
      # 1. Extract commit details
      COMMIT_HASH=$(git rev-parse HEAD)
      COMMIT_AUTHOR=$(git log -1 --pretty=%an)
      COMMIT_DATE=$(git log -1 --date=iso8601 --pretty=%aI)

      # 2. Detect JIRA ticket (already have TRACKING_ID)
      JIRA_TICKET="$TRACKING_ID"

      # 3. Get cloud ID
      CLOUD_ID="${ATLASSIAN_CLOUD_ID:-<your-cloud-id>}"

      # 4. Get available transitions
      TRANSITIONS=$(atlassian_getTransitionsForJiraIssue \
        --cloudId "$CLOUD_ID" \
        --issueIdOrKey "$JIRA_TICKET")

      # 5. Find "Done" or "Closed" transition
      TARGET_TRANSITION_ID=$(echo "$TRANSITIONS" | jq -r '.transitions[] | select(.to.name == "Done" or .to.name == "Closed") | .id' | head -1)
      TARGET_TRANSITION_NAME=$(echo "$TRANSITIONS" | jq -r '.transitions[] | select(.to.name == "Done" or .to.name == "Closed") | .to.name' | head -1)

      # 6. Get current status
      TICKET_DETAILS=$(atlassian_getJiraIssue \
        --cloudId "$CLOUD_ID" \
        --issueIdOrKey "$JIRA_TICKET")
      CURRENT_STATUS=$(echo "$TICKET_DETAILS" | jq -r '.fields.status.name')

      # 7. Check if already in target status
      if [ "$CURRENT_STATUS" = "$TARGET_TRANSITION_NAME" ]; then
        echo "✅ Ticket already in target status: $TARGET_TRANSITION_NAME"
      else
        # 8. Execute transition
        if [ -n "$TARGET_TRANSITION_ID" ]; then
          TRANSITION_RESULT=$(atlassian_transitionJiraIssue \
            --cloudId "$CLOUD_ID" \
            --issueIdOrKey "$JIRA_TICKET" \
            --transition "{\"id\": \"$TARGET_TRANSITION_ID\"}")

          if [ $? -eq 0 ]; then
            echo "✅ Successfully transitioned $JIRA_TICKET from $CURRENT_STATUS to $TARGET_TRANSITION_NAME"
          else
            echo "❌ Failed to transition $JIRA_TICKET"
            echo "   Transition ID: $TARGET_TRANSITION_ID"
            echo "   Please check permissions and available transitions"
          fi
        else
          echo "⚠️  No 'Done' or 'Closed' transition available for $JIRA_TICKET"
          echo "   Available transitions:"
          echo "$TRANSITIONS" | jq -r '.transitions[] | "   - \(.to.name)"'
        fi
      fi

      # 9. Add merge comment
      COMMENT_BODY=$(cat <<EOF
## Pull Request Merged

**PR**: #$PR_NUMBER - <pr-title>
**URL**: $PR_URL
**Branch**: $CURRENT_BRANCH → $MERGE_TARGET

### Status Update
✅ Ticket transitioned from **$CURRENT_STATUS** to **$TARGET_TRANSITION_NAME**

### Merge Details
- **Commit**: \`$COMMIT_HASH\`
- **Author**: $COMMIT_AUTHOR
- **Date**: $COMMIT_DATE

### Files Changed
\`\`\`
$(git diff --stat HEAD~1 HEAD)
\`\`\`
EOF
)

      atlassian_addCommentToJiraIssue \
        --cloudId "$CLOUD_ID" \
        --issueIdOrKey "$JIRA_TICKET" \
        --commentBody "$COMMENT_BODY"

      if [ $? -eq 0 ]; then
        echo "✅ Added merge comment to $JIRA_TICKET"
      else
        echo "⚠️  Failed to add comment to $JIRA_TICKET"
      fi

      echo "=========================================="
      echo ""
      echo "🔗 JIRA Ticket: https://<company>.atlassian.net/browse/$JIRA_TICKET"
    fi
  fi
fi

# Prompt user for target branch
read -p "Enter target branch (main/develop/staging/etc.): " TARGET_BRANCH

# Provide default if available
TARGET_BRANCH=${TARGET_BRANCH:-main}

# Offer to fix automatically
if [ "$RUN_LINTING" = "true" ]; then
  read -p "Linting failed. Run auto-fix? (y/n): " AUTO_FIX
  if [ "$AUTO_FIX" = "y" ]; then
    npm run lint -- --fix
  fi
fi

# Ask if user wants to continue anyway
read -p "Some checks failed. Create PR anyway? (y/n): " CONTINUE_PR
if [ "$CONTINUE_PR" = "n" ]; then
  echo "PR creation cancelled. Please fix issues and retry."
  exit 1
fi

# Create standalone PR without tracking reference
TRACKING_SYSTEM="none"
TRACKING_ID=""

# Or ask user to provide reference
read -p "Enter JIRA ticket or git issue number (leave blank for none): " USER_TRACKING
if [ -n "$USER_TRACKING" ]; then
  # Parse and use provided tracking
fi

# Push branch with upstream tracking
git push -u origin $(git branch --show-current)

# Manually specify virtual environment directory
VENV_DIR=".venv"  # or "venv", "myvenv", etc.

if [ -d "$VENV_DIR" ]; then
  source "$VENV_DIR/bin/activate"
  echo "✅ Manually activated: $VENV_DIR"
else
  echo "❌ Virtual environment not found: $VENV_DIR"
  echo "Available options:"
  ls -la | grep -E 'venv|env' || echo "  No virtual environments found"
fi

# Check virtual environment structure
ls -la .venv/bin/ | grep activate

# Try manual activation
source .venv/bin/activate

# Verify activation
echo $VIRTUAL_ENV  # Should show venv path
which python      # Should show venv python, not system python

# Recreate virtual environment (Poetry)
rm -rf .venv
poetry install

# Recreate virtual environment (pip)
rm -rf .venv
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

# Check Poetry version
poetry --version

# Check pyproject.toml exists
ls -la pyproject.toml

# Try verbose install for debugging
poetry install -vvv

# Common fixes:
# 1. Update Poetry
pip install --upgrade poetry

# 2. Clear Poetry cache
poetry cache clear --all pypi

# 3. Check Python version in pyproject.toml
grep "python" pyproject.toml

# 4. Use explicit Python version
poetry env use $(which python3.11)

# Verify virtual environment is active
echo $VIRTUAL_ENV

# Check which Python is being used
which python
which pytest

# Force virtual environment activation before tests
if [ -z "${VIRTUAL_ENV:-}" ]; then
  echo "⚠️  Warning: No virtual environment active"
  source .venv/bin/activate
  echo "✅ Activated virtual environment: $VIRTUAL_ENV"
fi

# Now run tests
poetry run pytest

# Get current branch
git branch --show-current

# Get default branch
git symbolic-ref refs/remotes/origin/HEAD

# Check git status
git status

# Check for remote tracking
git branch -vv | grep '*'

# Push branch with upstream
git push -u origin <branch-name>

# Create PR
gh pr create --base <target> --title "Title" --body "Description"

# View PR
gh pr view

# List PRs
gh pr list

# Merge PR
gh pr merge <pr-number>

# Close PR (without merge)
gh pr close <pr-number>

# Virtual Environment Commands

# Detect if virtual environment is active
echo $VIRTUAL_ENV

# Check which Python is being used
which python
which pytest

# Activate virtual environment (bash/zsh)
source .venv/bin/activate

# Activate virtual environment (fish)
source .venv/bin/activate.fish

# Activate virtual environment (PowerShell)
.\.venv\Scripts\Activate.ps1

# Create Poetry virtual environment
poetry install

# Create standard virtual environment
python -m venv .venv

# Run tests in virtual environment
poetry run pytest

# Run type checking in virtual environment
poetry run mypy .

# Run linting in virtual environment
poetry run ruff check .

# Deactivate virtual environment
deactivate

# List all virtual environment directories
ls -la | grep -E 'venv|env'

# Check Poetry environment info
poetry env info