#!/bin/bash

# Wogi Flow - Export Profile
# Export workflow configuration for team sharing
# v3.0: Enhanced with rules, learnings, skills, templates, and tech stack

set -e

WORKFLOW_DIR=".workflow"
PROFILES_DIR="wogi-profiles"

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
CYAN='\033[0;36m'
DIM='\033[2m'
NC='\033[0m'

show_help() {
    echo "Export Workflow Profile"
    echo ""
    echo "Usage: flow export-profile <profile-name> [options]"
    echo ""
    echo "Categories:"
    echo "  --rules          Include .claude/rules/ (recursive) and decisions.md"
    echo "  --learnings      Include feedback-patterns.md and skill learnings"
    echo "  --templates      Include workflow templates (HBS, story, bug report, etc.)"
    echo "  --skills         Include skill definitions (.claude/skills/*/skill.md)"
    echo "  --full           Include everything (all categories + patterns)"
    echo ""
    echo "Pattern Extraction:"
    echo "  --extract-patterns    Scan codebase and extract patterns"
    echo "  --resolve-conflicts   Interactive conflict resolution (with --extract-patterns)"
    echo "  --analysis-mode MODE  Analysis depth: balanced (default), deep"
    echo "  --include-examples    Include code snippets as examples"
    echo ""
    echo "Legacy options:"
    echo "  --include-decisions    Include decisions.md only"
    echo "  --include-app-map      Include app-map.md (component registry)"
    echo "  --include-api-map      Include api-map.md (API registry + data-fetching hooks)"
    echo ""
    echo "Included with --full:"
    echo "  - CLAUDE.md, agents/, config.json (always)"
    echo "  - .claude/rules/ (recursive: security, code-style, architecture, etc.)"
    echo "  - .workflow/state/decisions.md"
    echo "  - .workflow/agents/ (review checklists)"
    echo "  - .claude/skills/*/skill.md (skill definitions)"
    echo "  - .claude/skills/*/knowledge/ (skill patterns & learnings)"
    echo "  - .claude/docs/stack.md (tech stack)"
    echo "  - .workflow/templates/ (CLAUDE.md HBS templates)"
    echo "  - templates/ (story, bug report, etc.)"
    echo "  - .workflow/state/feedback-patterns.md"
    echo ""
    echo "Excluded (session-specific, never exported):"
    echo "  - request-log.md, progress.md, session-state.json"
    echo "  - ready.json, epics.json, task-queue.json"
    echo "  - prompt-history.json, last-review.json"
    echo "  - app-map.md, function-map.md, api-map.md (project-specific)"
    echo ""
    echo "Examples:"
    echo "  flow export-profile my-team --full"
    echo "  flow export-profile my-team --rules --learnings --skills"
    echo "  flow export-profile my-team --extract-patterns --resolve-conflicts"
}

if [ -z "$1" ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
    show_help
    exit 0
fi

PROFILE_NAME="$1"
shift

# Validate profile name to prevent path traversal
if ! [[ "$PROFILE_NAME" =~ ^[a-zA-Z0-9_-]+$ ]]; then
    echo -e "${RED}Error: Invalid profile name. Use only letters, numbers, underscores, and hyphens.${NC}"
    exit 1
fi

# Safe JSON reading function (prevents code injection by using process.argv)
safe_read_json() {
    local file="$1"
    local query="$2"
    node -e '
        const fs = require("fs");
        const file = process.argv[1];
        const query = process.argv[2];
        try {
            const content = fs.readFileSync(file, "utf-8");
            // Check for prototype pollution attempts
            if (/__proto__|constructor\s*["\x27\x60:\[]|prototype\s*["\x27\x60:\[]|\["__proto__"\]|\["constructor"\]|\["prototype"\]/i.test(content)) {
                console.error("Suspicious content detected");
                process.exit(1);
            }
            let p;
            try { p = JSON.parse(content); } catch(err) { console.error(err.message); process.exit(1); }
            // Safe property access based on query type
            if (query === "conflicts.length") {
                console.log(p.conflicts ? p.conflicts.length : 0);
            } else if (query === "conflicts.json") {
                console.log(JSON.stringify(p.conflicts, null, 2));
            } else if (query === "recommendations.json") {
                console.log(JSON.stringify(p.recommendations, null, 2));
            } else {
                console.error("Unknown query: " + query);
                process.exit(1);
            }
        } catch(err) {
            console.error(err.message);
            process.exit(1);
        }
    ' -- "$file" "$query" 2>/dev/null
}

# Parse options
INCLUDE_DECISIONS=false
INCLUDE_APP_MAP=false
INCLUDE_API_MAP=false
INCLUDE_RULES=false
INCLUDE_LEARNINGS=false
INCLUDE_TEMPLATES=false
INCLUDE_SKILLS=false
EXTRACT_PATTERNS=false
RESOLVE_CONFLICTS=false
ANALYSIS_MODE="balanced"
INCLUDE_EXAMPLES=false

while [ $# -gt 0 ]; do
    case "$1" in
        --include-decisions)
            INCLUDE_DECISIONS=true
            ;;
        --include-app-map)
            INCLUDE_APP_MAP=true
            ;;
        --include-api-map)
            INCLUDE_API_MAP=true
            ;;
        --rules)
            INCLUDE_RULES=true
            INCLUDE_DECISIONS=true  # Rules require decisions
            ;;
        --learnings)
            INCLUDE_LEARNINGS=true
            ;;
        --templates)
            INCLUDE_TEMPLATES=true
            ;;
        --skills)
            INCLUDE_SKILLS=true
            ;;
        --extract-patterns)
            EXTRACT_PATTERNS=true
            ;;
        --resolve-conflicts)
            RESOLVE_CONFLICTS=true
            ;;
        --analysis-mode)
            shift
            if [[ "$1" =~ ^(balanced|deep)$ ]]; then
                ANALYSIS_MODE="$1"
            else
                echo -e "${RED}Error: Invalid analysis mode '$1'. Use 'balanced' or 'deep'${NC}"
                exit 1
            fi
            ;;
        --include-examples)
            INCLUDE_EXAMPLES=true
            ;;
        --full)
            INCLUDE_DECISIONS=true
            INCLUDE_RULES=true
            INCLUDE_LEARNINGS=true
            INCLUDE_TEMPLATES=true
            INCLUDE_SKILLS=true
            EXTRACT_PATTERNS=true
            ;;
        *)
            echo -e "${RED}Unknown option: $1${NC}"
            exit 1
            ;;
    esac
    shift
done

# Determine scripts directory
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Create profiles directory
mkdir -p "$PROFILES_DIR"

# Create temp directory for profile
TEMP_DIR=$(mktemp -d)
trap 'rm -rf "$TEMP_DIR"' EXIT INT TERM
PROFILE_DIR="$TEMP_DIR/$PROFILE_NAME"
mkdir -p "$PROFILE_DIR/agents"
mkdir -p "$PROFILE_DIR/.workflow"

echo -e "${CYAN}╔══════════════════════════════════════════════════════════╗${NC}"
echo -e "${CYAN}║  Exporting Profile: $PROFILE_NAME${NC}"
echo -e "${CYAN}╚══════════════════════════════════════════════════════════╝${NC}"
echo ""

# Track what's included for metadata
CONTENTS=""

# ==========================================
# CORE (always included)
# ==========================================
echo -e "${YELLOW}Core Files:${NC}"

echo -e "  ${GREEN}✓${NC} CLAUDE.md"
cp CLAUDE.md "$PROFILE_DIR/"
CONTENTS="$CONTENTS\n- CLAUDE.md (core workflow instructions)"

echo -e "  ${GREEN}✓${NC} agents/ ($(ls agents/*.md 2>/dev/null | wc -l | tr -d ' ') personas)"
cp agents/*.md "$PROFILE_DIR/agents/" 2>/dev/null || true
CONTENTS="$CONTENTS\n- agents/ (agent personas)"

echo -e "  ${GREEN}✓${NC} config.json"
cp "$WORKFLOW_DIR/config.json" "$PROFILE_DIR/.workflow/"
CONTENTS="$CONTENTS\n- .workflow/config.json (configuration)"

# ==========================================
# RULES & DECISIONS
# ==========================================
if [ "$INCLUDE_DECISIONS" = true ] || [ "$INCLUDE_RULES" = true ]; then
    echo ""
    echo -e "${YELLOW}Rules & Decisions:${NC}"

    # decisions.md
    if [ -f "$WORKFLOW_DIR/state/decisions.md" ]; then
        mkdir -p "$PROFILE_DIR/.workflow/state"
        cp "$WORKFLOW_DIR/state/decisions.md" "$PROFILE_DIR/.workflow/state/"
        echo -e "  ${GREEN}✓${NC} decisions.md"
        CONTENTS="$CONTENTS\n- .workflow/state/decisions.md (project rules)"
    fi

    # .claude/rules/ (recursive — rules live in subdirectories)
    if [ "$INCLUDE_RULES" = true ] && [ -d ".claude/rules" ]; then
        # Copy entire rules tree, excluding README.md (auto-generated)
        find .claude/rules -name "*.md" ! -name "README.md" -type f | while read -r file; do
            rel_dir=$(dirname "$file")
            mkdir -p "$PROFILE_DIR/$rel_dir"
            cp "$file" "$PROFILE_DIR/$file"
        done
        RULE_COUNT=$(find "$PROFILE_DIR/.claude/rules" -name "*.md" -type f 2>/dev/null | wc -l | tr -d ' ')
        if [ "$RULE_COUNT" -gt 0 ]; then
            echo -e "  ${GREEN}✓${NC} .claude/rules/ ($RULE_COUNT rules, recursive)"
            CONTENTS="$CONTENTS\n- .claude/rules/ (coding rules)"
        fi
    fi
fi

# ==========================================
# APP MAP (optional)
# ==========================================
if [ "$INCLUDE_APP_MAP" = true ] && [ -f "$WORKFLOW_DIR/state/app-map.md" ]; then
    echo ""
    echo -e "${YELLOW}Component Registry:${NC}"
    mkdir -p "$PROFILE_DIR/.workflow/state"
    cp "$WORKFLOW_DIR/state/app-map.md" "$PROFILE_DIR/.workflow/state/"
    echo -e "  ${GREEN}✓${NC} app-map.md"
    CONTENTS="$CONTENTS\n- .workflow/state/app-map.md (component registry)"
fi

# ==========================================
# API MAP (optional — includes Client-Side Data Hooks section)
# ==========================================
if [ "$INCLUDE_API_MAP" = true ] && [ -f "$WORKFLOW_DIR/state/api-map.md" ]; then
    echo ""
    echo -e "${YELLOW}API Registry:${NC}"
    mkdir -p "$PROFILE_DIR/.workflow/state"
    cp "$WORKFLOW_DIR/state/api-map.md" "$PROFILE_DIR/.workflow/state/"
    echo -e "  ${GREEN}✓${NC} api-map.md"
    CONTENTS="$CONTENTS\n- .workflow/state/api-map.md (API registry incl. data-fetching hooks)"
fi

# ==========================================
# LEARNINGS
# ==========================================
if [ "$INCLUDE_LEARNINGS" = true ]; then
    echo ""
    echo -e "${YELLOW}Learnings:${NC}"

    # feedback-patterns.md
    if [ -f "$WORKFLOW_DIR/state/feedback-patterns.md" ]; then
        mkdir -p "$PROFILE_DIR/.workflow/state"
        cp "$WORKFLOW_DIR/state/feedback-patterns.md" "$PROFILE_DIR/.workflow/state/"
        echo -e "  ${GREEN}✓${NC} feedback-patterns.md"
        CONTENTS="$CONTENTS\n- .workflow/state/feedback-patterns.md (team learnings)"
    fi

    # Skill learnings (patterns.md and learnings.md from each skill)
    if [ -d ".claude/skills" ]; then
        SKILL_COUNT=0
        for skill_dir in .claude/skills/*/; do
            if [ -d "$skill_dir/knowledge" ]; then
                skill_name=$(basename "$skill_dir")
                mkdir -p "$PROFILE_DIR/.claude/skills/$skill_name/knowledge"

                # Copy patterns.md if exists
                if [ -f "$skill_dir/knowledge/patterns.md" ]; then
                    cp "$skill_dir/knowledge/patterns.md" "$PROFILE_DIR/.claude/skills/$skill_name/knowledge/"
                    SKILL_COUNT=$((SKILL_COUNT + 1))
                fi

                # Copy learnings.md if exists
                if [ -f "$skill_dir/knowledge/learnings.md" ]; then
                    cp "$skill_dir/knowledge/learnings.md" "$PROFILE_DIR/.claude/skills/$skill_name/knowledge/"
                fi
            fi
        done

        if [ "$SKILL_COUNT" -gt 0 ]; then
            echo -e "  ${GREEN}✓${NC} skill learnings ($SKILL_COUNT skills)"
            CONTENTS="$CONTENTS\n- .claude/skills/*/knowledge/ (skill learnings)"
        fi
    fi
fi

# ==========================================
# TEMPLATES (workflow templates for code generation)
# ==========================================
if [ "$INCLUDE_TEMPLATES" = true ]; then
    echo ""
    echo -e "${YELLOW}Templates:${NC}"

    # Workflow HBS templates (used to generate CLAUDE.md)
    if [ -d "$WORKFLOW_DIR/templates" ]; then
        mkdir -p "$PROFILE_DIR/.workflow/templates"
        # Copy all template files (HBS, MD)
        find "$WORKFLOW_DIR/templates" -type f \( -name "*.hbs" -o -name "*.md" \) | while read -r file; do
            rel_path="${file#$WORKFLOW_DIR/templates/}"
            rel_dir=$(dirname "$rel_path")
            mkdir -p "$PROFILE_DIR/.workflow/templates/$rel_dir"
            cp "$file" "$PROFILE_DIR/.workflow/templates/$rel_path"
        done
        WF_TEMPLATE_COUNT=$(find "$PROFILE_DIR/.workflow/templates" -type f 2>/dev/null | wc -l | tr -d ' ')
        if [ "$WF_TEMPLATE_COUNT" -gt 0 ]; then
            echo -e "  ${GREEN}✓${NC} .workflow/templates/ ($WF_TEMPLATE_COUNT files, CLAUDE.md generation)"
            CONTENTS="$CONTENTS\n- .workflow/templates/ (CLAUDE.md HBS templates)"
        fi
    fi

    # Story/bug/correction templates
    if [ -d "templates" ]; then
        mkdir -p "$PROFILE_DIR/templates"
        find templates -type f \( -name "*.md" -o -name "*.json" -o -name "*.tsx" \) | while read -r file; do
            rel_dir=$(dirname "$file")
            mkdir -p "$PROFILE_DIR/$rel_dir"
            cp "$file" "$PROFILE_DIR/$file"
        done
        TMPL_COUNT=$(find "$PROFILE_DIR/templates" -type f 2>/dev/null | wc -l | tr -d ' ')
        if [ "$TMPL_COUNT" -gt 0 ]; then
            echo -e "  ${GREEN}✓${NC} templates/ ($TMPL_COUNT story/bug/task templates)"
            CONTENTS="$CONTENTS\n- templates/ (story, bug report, task templates)"
        fi
    fi

    # State file templates (.template suffix) — used during project init
    TEMPLATE_STATE_COUNT=0
    for tpl in "$WORKFLOW_DIR/state/"*.template; do
        if [ -f "$tpl" ]; then
            mkdir -p "$PROFILE_DIR/.workflow/state"
            cp "$tpl" "$PROFILE_DIR/.workflow/state/"
            TEMPLATE_STATE_COUNT=$((TEMPLATE_STATE_COUNT + 1))
        fi
    done
    if [ "$TEMPLATE_STATE_COUNT" -gt 0 ]; then
        echo -e "  ${GREEN}✓${NC} state templates ($TEMPLATE_STATE_COUNT .template files)"
        CONTENTS="$CONTENTS\n- .workflow/state/*.template (init templates)"
    fi
fi

# ==========================================
# SKILLS (skill definitions and knowledge)
# ==========================================
if [ "$INCLUDE_SKILLS" = true ] && [ -d ".claude/skills" ]; then
    echo ""
    echo -e "${YELLOW}Skills:${NC}"

    SKILL_DEF_COUNT=0
    for skill_dir in .claude/skills/*/; do
        skill_name=$(basename "$skill_dir")
        # Skip template
        if [ "$skill_name" = "_template" ]; then continue; fi

        # Copy skill.md (the skill definition)
        if [ -f "$skill_dir/skill.md" ]; then
            mkdir -p "$PROFILE_DIR/.claude/skills/$skill_name"
            cp "$skill_dir/skill.md" "$PROFILE_DIR/.claude/skills/$skill_name/"
            SKILL_DEF_COUNT=$((SKILL_DEF_COUNT + 1))
        fi
    done

    if [ "$SKILL_DEF_COUNT" -gt 0 ]; then
        echo -e "  ${GREEN}✓${NC} skill definitions ($SKILL_DEF_COUNT skills)"
        CONTENTS="$CONTENTS\n- .claude/skills/*/skill.md (skill definitions)"
    fi
fi

# ==========================================
# REVIEW AGENTS (review checklists)
# ==========================================
if [ "$INCLUDE_RULES" = true ] && [ -d "$WORKFLOW_DIR/agents" ]; then
    echo ""
    echo -e "${YELLOW}Review Agents:${NC}"
    mkdir -p "$PROFILE_DIR/.workflow/agents"
    AGENT_COUNT=0
    for agent_file in "$WORKFLOW_DIR/agents/"*.md; do
        if [ -f "$agent_file" ]; then
            cp "$agent_file" "$PROFILE_DIR/.workflow/agents/"
            AGENT_COUNT=$((AGENT_COUNT + 1))
        fi
    done
    if [ "$AGENT_COUNT" -gt 0 ]; then
        echo -e "  ${GREEN}✓${NC} .workflow/agents/ ($AGENT_COUNT review checklists)"
        CONTENTS="$CONTENTS\n- .workflow/agents/ (review checklists: security, performance)"
    fi
fi

# ==========================================
# TECH STACK (generic project stack definition)
# ==========================================
if [ "$INCLUDE_RULES" = true ] && [ -f ".claude/docs/stack.md" ]; then
    mkdir -p "$PROFILE_DIR/.claude/docs"
    cp ".claude/docs/stack.md" "$PROFILE_DIR/.claude/docs/"
    echo -e "  ${GREEN}✓${NC} .claude/docs/stack.md (tech stack)"
    CONTENTS="$CONTENTS\n- .claude/docs/stack.md (tech stack definition)"
fi

# ==========================================
# PATTERN EXTRACTION (NEW)
# ==========================================
if [ "$EXTRACT_PATTERNS" = true ]; then
    echo ""
    echo -e "${YELLOW}Pattern Extraction:${NC}"

    mkdir -p "$PROFILE_DIR/.workflow/extracted"

    # Build extractor options
    EXTRACTOR_OPTS="--format json --with-conflicts --analysis-mode $ANALYSIS_MODE"

    # Run pattern extraction
    echo -e "  ${DIM}Scanning codebase for patterns...${NC}"
    PATTERNS_OUTPUT="$PROFILE_DIR/.workflow/extracted/patterns.json"

    # shellcheck disable=SC2086 — intentional word splitting for multiple flags
    if node "$SCRIPT_DIR/flow-pattern-extractor.js" $EXTRACTOR_OPTS --output "$PATTERNS_OUTPUT" 2>/dev/null; then
        echo -e "  ${GREEN}✓${NC} patterns.json"
        CONTENTS="$CONTENTS\n- .workflow/extracted/patterns.json (extracted patterns)"

        # Check for conflicts (using safe JSON parsing instead of require())
        CONFLICT_COUNT=$(safe_read_json "$PATTERNS_OUTPUT" "conflicts.length" || echo "0")

        if [ "$CONFLICT_COUNT" -gt 0 ]; then
            echo -e "  ${YELLOW}!${NC} Found $CONFLICT_COUNT conflicts"

            # Run conflict resolution if requested
            if [ "$RESOLVE_CONFLICTS" = true ]; then
                # Extract conflicts to temp file (using safe JSON parsing)
                CONFLICTS_TEMP=$(mktemp)
                safe_read_json "$PATTERNS_OUTPUT" "conflicts.json" > "$CONFLICTS_TEMP"

                echo -e "  ${DIM}Launching conflict resolver...${NC}"

                RESOLVED_OUTPUT="$PROFILE_DIR/.workflow/extracted/conflicts-resolved.json"
                if node "$SCRIPT_DIR/flow-conflict-resolver.js" --input "$CONFLICTS_TEMP" --output "$RESOLVED_OUTPUT"; then
                    echo -e "  ${GREEN}✓${NC} conflicts-resolved.json"
                    CONTENTS="$CONTENTS\n- .workflow/extracted/conflicts-resolved.json (user resolutions)"
                else
                    echo -e "  ${YELLOW}!${NC} Conflict resolution skipped or cancelled"
                fi

                rm -f "$CONFLICTS_TEMP"
            fi
        else
            echo -e "  ${GREEN}✓${NC} No conflicting patterns found"
        fi

        # Extract examples if requested
        if [ "$INCLUDE_EXAMPLES" = true ]; then
            mkdir -p "$PROFILE_DIR/.workflow/extracted/examples"

            # Extract example snippets from patterns (using safe JSON parsing)
            node -e "
                const fs = require('node:fs');
                const path = require('node:path');

                try {
                    const content = fs.readFileSync('$PATTERNS_OUTPUT', 'utf-8');
                    // Check for prototype pollution attempts
                    if (/__proto__|constructor\\s*[\"'\`:]|prototype\\s*[\"'\`:]/i.test(content)) {
                        console.error('Suspicious content detected');
                        process.exit(1);
                    }
                    const p = JSON.parse(content);

                    let count = 0;
                    for (const category in p.patterns) {
                        for (const pattern of p.patterns[category] || []) {
                            if (pattern.examples && pattern.examples.length > 0) {
                                const safeName = require('node:path').basename(
                                    pattern.subcategory.replace(/\\./g, '-')
                                ) + '.txt';
                                const filename = safeName;
                                const fileContent = pattern.name + '\\n' + '='.repeat(40) + '\\n\\n' +
                                    pattern.examples.slice(0, 5).join('\\n');
                                fs.writeFileSync(
                                    path.join('$PROFILE_DIR/.workflow/extracted/examples', filename),
                                    fileContent
                                );
                                count++;
                            }
                        }
                    }
                    console.log(count);
                } catch(err) {
                    console.error(err.message);
                    process.exit(1);
                }
            " 2>/dev/null || true

            EXAMPLE_COUNT=$(ls "$PROFILE_DIR/.workflow/extracted/examples/"*.txt 2>/dev/null | wc -l | tr -d ' ')
            if [ "$EXAMPLE_COUNT" -gt 0 ]; then
                echo -e "  ${GREEN}✓${NC} examples/ ($EXAMPLE_COUNT pattern examples)"
                CONTENTS="$CONTENTS\n- .workflow/extracted/examples/ (code snippets)"
            fi
        fi
    else
        echo -e "  ${RED}✗${NC} Pattern extraction failed (continuing without patterns)"
    fi
fi

# ==========================================
# Create profile info file
# ==========================================
cat > "$PROFILE_DIR/PROFILE.md" << EOF
# Wogi Flow Profile: $PROFILE_NAME

Exported: $(date +%Y-%m-%d\ %H:%M)
Source: $(git remote get-url origin 2>/dev/null | sed 's|.*[:/]\([^/]*/[^/]*\)\.git$|\1|; s|.*[:/]\([^/]*/[^/]*\)$|\1|' || echo "local")
Version: 3.0

## Contents
$(echo -e "$CONTENTS")

## Import Instructions

### New Project (during installation)
\`\`\`bash
./scripts/flow install
# Select option 2: "Import from existing profile"
# Enter path: $PROFILE_NAME.zip
\`\`\`

### Existing Project
\`\`\`bash
./scripts/flow import-profile $PROFILE_NAME.zip
\`\`\`

## Import Options
\`\`\`bash
# Preview what would be imported
./scripts/flow import-profile $PROFILE_NAME.zip --dry-run

# Create backup before importing
./scripts/flow import-profile $PROFILE_NAME.zip --backup

# Skip importing learnings
./scripts/flow import-profile $PROFILE_NAME.zip --skip-learnings
\`\`\`

## Configuration Summary
\`\`\`json
$(node -e '
const fs = require("fs");
try {
  const c = JSON.parse(fs.readFileSync("'$WORKFLOW_DIR'/config.json", "utf-8"));
  const safe = { version: c.version, qualityGates: c.qualityGates, review: c.review };
  console.log(JSON.stringify(safe, null, 2));
} catch(err) { console.log("{}"); }
')
\`\`\`
EOF

# ==========================================
# Create zip
# ==========================================
OUTPUT_FILE="$PROFILES_DIR/$PROFILE_NAME.zip"
(cd "$TEMP_DIR" && zip -r "$PROFILE_NAME.zip" "$PROFILE_NAME" > /dev/null)
mv "$TEMP_DIR/$PROFILE_NAME.zip" "$OUTPUT_FILE"

# Calculate size (TEMP_DIR cleaned up by EXIT trap)
SIZE=$(ls -lh "$OUTPUT_FILE" | awk '{print $5}')

echo ""
echo -e "${GREEN}╔══════════════════════════════════════════════════════════╗${NC}"
echo -e "${GREEN}║  ✓ Profile exported successfully                         ║${NC}"
echo -e "${GREEN}╚══════════════════════════════════════════════════════════╝${NC}"
echo ""
echo -e "  ${CYAN}File:${NC} $OUTPUT_FILE"
echo -e "  ${CYAN}Size:${NC} $SIZE"
echo ""
echo -e "${DIM}Share this file with team members.${NC}"
echo -e "${DIM}Import with: ./scripts/flow import-profile $OUTPUT_FILE${NC}"
