#!/bin/bash

local languages=""

# JavaScript/TypeScript detection
if [ -f "package.json" ] || [ -f "tsconfig.json" ]; then
    languages="$languages javascript"
    echo "✓ JavaScript/TypeScript detected"

    # Check for ESLint
    if [ -f ".eslintrc.js" ] || [ -f ".eslintrc.json" ] || grep -q "eslint" package.json 2>/dev/null; then
        echo "  - ESLint configuration found"
    else
        echo "  - No ESLint configuration (will create basic setup)"
    fi
fi

# Python detection
if [ -f "setup.py" ] || [ -f "pyproject.toml" ] || [ -f "requirements.txt" ] || find . -maxdepth 2 -name "*.py" -type f 2>/dev/null | grep -q .; then
    languages="$languages python"
    echo "✓ Python detected"
fi

# Go detection
if [ -f "go.mod" ] || find . -maxdepth 2 -name "*.go" -type f 2>/dev/null | grep -q .; then
    languages="$languages go"
    echo "✓ Go detected"
fi

# Java detection
if [ -f "pom.xml" ] || [ -f "build.gradle" ] || find . -maxdepth 2 -name "*.java" -type f 2>/dev/null | grep -q .; then
    languages="$languages java"
    echo "✓ Java detected"
fi

if [ -z "$languages" ]; then
    echo "❌ No supported languages detected"
    echo ""
    echo "Supported languages:"
    echo "  - JavaScript/TypeScript (package.json)"
    echo "  - Python (.py files)"
    echo "  - Go (.go files)"
    echo "  - Java (.java files)"
    exit 1
fi

echo "$languages"

undefined

echo "=== Installing Complexity Analysis Tools ==="
echo ""

install_tools() {
    for lang in $LANGUAGES; do
        case "$lang" in
            javascript)
                echo "Setting up JavaScript/TypeScript complexity analysis..."

                # Check if ESLint is installed
                if ! command -v eslint >/dev/null 2>&1 && ! npm list eslint >/dev/null 2>&1; then
                    echo "Installing ESLint..."
                    npm install --save-dev eslint
                else
                    echo "✓ ESLint already available"
                fi

                # Create ESLint configuration for complexity
                cat > "$ANALYSIS_DIR/.eslintrc.complexity.json" << 'ESLINTCONFIG'
{
    "env": {
        "es2021": true,
        "node": true
    },
    "parserOptions": {
        "ecmaVersion": "latest",
        "sourceType": "module"
    },
    "rules": {
        "complexity": ["warn", 10],
        "max-depth": ["warn", 4],
        "max-nested-callbacks": ["warn", 3],
        "max-lines-per-function": ["warn", 50],
        "max-statements": ["warn", 15]
    }
}
ESLINTCONFIG

                echo "✓ ESLint complexity configuration created"
                echo ""
                ;;

            python)
                echo "Setting up Python complexity analysis..."

                # Check for radon
                if ! command -v radon >/dev/null 2>&1; then
                    echo "Installing radon (complexity analysis tool)..."
                    pip install radon 2>/dev/null || pip3 install radon

                    if [ $? -eq 0 ]; then
                        echo "✓ radon installed"
                    else
                        echo "⚠️  Failed to install radon - using basic analysis"
                    fi
                else
                    echo "✓ radon already installed"
                fi
                echo ""
                ;;

            go)
                echo "Setting up Go complexity analysis..."

                # Check for gocyclo
                if ! command -v gocyclo >/dev/null 2>&1; then
                    echo "Installing gocyclo..."
                    go install github.com/fzipp/gocyclo/cmd/gocyclo@latest

                    if [ $? -eq 0 ]; then
                        echo "✓ gocyclo installed"
                    else
                        echo "⚠️  Failed to install gocyclo"
                    fi
                else
                    echo "✓ gocyclo already installed"
                fi
                echo ""
                ;;

            java)
                echo "Setting up Java complexity analysis..."
                echo "ℹ️  Java analysis requires Checkstyle"
                echo "   Install: https://checkstyle.sourceforge.io/"
                echo ""
                ;;
        esac
    done
}

install_tools

echo "=== Analyzing Cyclomatic Complexity ==="
echo ""

analyze_javascript_complexity() {
    echo "JavaScript/TypeScript complexity analysis..."
    echo ""

    # Find source files
    SOURCE_DIRS="src lib app pages components"
    SOURCE_FILES=""

    for dir in $SOURCE_DIRS; do
        if [ -d "$dir" ]; then
            SOURCE_FILES="$SOURCE_FILES $dir"
        fi
    done

    # Fallback to current directory if no standard dirs found
    if [ -z "$SOURCE_FILES" ]; then
        SOURCE_FILES="."
    fi

    # Run ESLint with complexity rules
    echo "Running ESLint complexity analysis..."
    npx eslint $SOURCE_FILES \
        --ext .js,.jsx,.ts,.tsx \
        --config "$ANALYSIS_DIR/.eslintrc.complexity.json" \
        --format json \
        > "$ANALYSIS_DIR/js-complexity.json" 2>/dev/null

    # Parse results
    if [ -f "$ANALYSIS_DIR/js-complexity.json" ]; then
        # Extract high complexity functions
        node -e "
            const fs = require('fs');
            const results = JSON.parse(fs.readFileSync('$ANALYSIS_DIR/js-complexity.json', 'utf8'));

            console.log('High Complexity Functions:');
            console.log('');

            let totalIssues = 0;
            results.forEach(file => {
                const complexityIssues = file.messages.filter(m =>
                    m.ruleId === 'complexity' ||
                    m.ruleId === 'max-depth' ||
                    m.ruleId === 'max-nested-callbacks' ||
                    m.ruleId === 'max-statements'
                );

                if (complexityIssues.length > 0) {
                    console.log(\`\${file.filePath}:\`);
                    complexityIssues.forEach(issue => {
                        console.log(\`  Line \${issue.line}: \${issue.message}\`);
                        totalIssues++;
                    });
                    console.log('');
                }
            });

            console.log(\`Total complexity issues: \${totalIssues}\`);
        " 2>/dev/null || echo "  (Run 'npm install' if ESLint fails)"
    fi

    echo ""
}

analyze_python_complexity() {
    echo "Python complexity analysis..."
    echo ""

    if command -v radon >/dev/null 2>&1; then
        # Run radon cyclomatic complexity
        echo "Running radon complexity analysis (threshold: $THRESHOLD)..."
        radon cc . -s -a --min=$THRESHOLD --exclude="venv/*,env/*,node_modules/*,.venv/*" \
            > "$ANALYSIS_DIR/python-complexity.txt" 2>/dev/null

        if [ -s "$ANALYSIS_DIR/python-complexity.txt" ]; then
            echo "High complexity functions found:"
            echo ""
            cat "$ANALYSIS_DIR/python-complexity.txt"
        else
            echo "✓ No functions exceed complexity threshold of $THRESHOLD"
        fi
    else
        echo "⚠️  radon not available - using basic pattern analysis"

        # Basic complexity estimation
        find . -name "*.py" -type f \
            -not -path "*/venv/*" \
            -not -path "*/env/*" \
            -not -path "*/.venv/*" \
            -exec grep -l "if\|for\|while\|except\|elif" {} \; \
            | head -10 | while read file; do
                decision_points=$(grep -c "if\|for\|while\|except\|elif" "$file")
                if [ "$decision_points" -gt "$THRESHOLD" ]; then
                    echo "  $file: ~$decision_points decision points"
                fi
            done
    fi

    echo ""
}

analyze_go_complexity() {
    echo "Go complexity analysis..."
    echo ""

    if command -v gocyclo >/dev/null 2>&1; then
        echo "Running gocyclo analysis (threshold: $THRESHOLD)..."
        gocyclo -over $THRESHOLD . > "$ANALYSIS_DIR/go-complexity.txt" 2>/dev/null

        if [ -s "$ANALYSIS_DIR/go-complexity.txt" ]; then
            echo "High complexity functions found:"
            echo ""
            cat "$ANALYSIS_DIR/go-complexity.txt"
        else
            echo "✓ No functions exceed complexity threshold of $THRESHOLD"
        fi
    else
        echo "⚠️  gocyclo not available"
    fi

    echo ""
}

undefined

echo "=== Generating Refactoring Strategies ==="
echo ""

cat > "$ANALYSIS_DIR/refactoring-patterns.md" << 'PATTERNS'

function processOrder(order) {
    // Validate order
    if (!order.items || order.items.length === 0) {
        throw new Error('Empty order');
    }
    if (!order.customer || !order.customer.email) {
        throw new Error('Invalid customer');
    }

    // Calculate total
    let total = 0;
    for (const item of order.items) {
        total += item.price * item.quantity;
        if (item.discount) {
            total -= item.price * item.quantity * item.discount;
        }
    }

    // Apply shipping
    if (total < 50) {
        total += 10;
    }

    // Process payment
    // ... 20 more lines
}

function processOrder(order) {
    validateOrder(order);
    const total = calculateTotal(order.items);
    const finalTotal = applyShipping(total);
    return processPayment(order, finalTotal);
}

function validateOrder(order) {
    if (!order.items?.length) throw new Error('Empty order');
    if (!order.customer?.email) throw new Error('Invalid customer');
}

function calculateTotal(items) {
    return items.reduce((sum, item) => {
        const itemTotal = item.price * item.quantity;
        const discount = item.discount ? itemTotal * item.discount : 0;
        return sum + itemTotal - discount;
    }, 0);
}

function applyShipping(total) {
    return total < 50 ? total + 10 : total;
}

def process_user(user):
    if user is not None:
        if user.is_active:
            if user.email_verified:
                if user.has_permission('admin'):
                    # Actual logic here
                    perform_admin_action(user)
                else:
                    raise PermissionError()
            else:
                raise ValidationError('Email not verified')
        else:
            raise ValidationError('User inactive')
    else:
        raise ValueError('User is None')

def process_user(user):
    # Guard clauses - fail fast
    if user is None:
        raise ValueError('User is None')
    if not user.is_active:
        raise ValidationError('User inactive')
    if not user.email_verified:
        raise ValidationError('Email not verified')
    if not user.has_permission('admin'):
        raise PermissionError()

    # Actual logic at base level
    perform_admin_action(user)

function calculateShipping(type: string, weight: number) {
    if (type === 'standard') {
        if (weight < 5) return 5;
        else if (weight < 10) return 8;
        else return 10;
    } else if (type === 'express') {
        if (weight < 5) return 15;
        else if (weight < 10) return 20;
        else return 25;
    } else if (type === 'overnight') {
        if (weight < 5) return 25;
        else if (weight < 10) return 35;
        else return 45;
    }
    throw new Error('Invalid shipping type');
}

const shippingRates = {
    standard: [5, 8, 10],
    express: [15, 20, 25],
    overnight: [25, 35, 45]
};

function calculateShipping(type: string, weight: number): number {
    const rates = shippingRates[type];
    if (!rates) throw new Error('Invalid shipping type');

    if (weight < 5) return rates[0];
    if (weight < 10) return rates[1];
    return rates[2];
}

// Or even better - configuration-driven
const weightBrackets = [
    { max: 5, index: 0 },
    { max: 10, index: 1 },
    { max: Infinity, index: 2 }
];

function calculateShipping(type: string, weight: number): number {
    const rates = shippingRates[type];
    if (!rates) throw new Error('Invalid shipping type');

    const bracket = weightBrackets.find(b => weight < b.max);
    return rates[bracket.index];
}

func shouldProcessOrder(order Order, user User, inventory Inventory) bool {
    return order.Status == "pending" &&
           order.Total > 0 &&
           user.IsActive &&
           user.CreditLimit >= order.Total &&
           inventory.HasStock(order.Items) &&
           !inventory.IsBackordered(order.Items) &&
           (user.IsPremium || order.Total < 1000)
}

func shouldProcessOrder(order Order, user User, inventory Inventory) bool {
    return isValidOrder(order) &&
           isEligibleUser(user, order) &&
           hasAvailableInventory(inventory, order)
}

func isValidOrder(order Order) bool {
    return order.Status == "pending" && order.Total > 0
}

func isEligibleUser(user User, order Order) bool {
    if !user.IsActive {
        return false
    }
    if user.CreditLimit < order.Total {
        return false
    }
    return user.IsPremium || order.Total < 1000
}

func hasAvailableInventory(inventory Inventory, order Order) bool {
    return inventory.HasStock(order.Items) &&
           !inventory.IsBackordered(order.Items)
}

function processItems(items) {
    const results = [];
    for (let i = 0; i < items.length; i++) {
        if (items[i].active && items[i].price > 0) {
            const discounted = items[i].price * 0.9;
            if (discounted >= 10) {
                results.push({
                    id: items[i].id,
                    name: items[i].name,
                    finalPrice: discounted
                });
            }
        }
    }
    return results;
}

function processItems(items) {
    return items
        .filter(item => item.active && item.price > 0)
        .map(item => ({
            ...item,
            finalPrice: item.price * 0.9
        }))
        .filter(item => item.finalPrice >= 10)
        .map(({ id, name, finalPrice }) => ({ id, name, finalPrice }));
}

// Or even more readable
function processItems(items) {
    return items
        .filter(isValidItem)
        .map(applyDiscount)
        .filter(meetsMinimumPrice)
        .map(toResult);
}

const isValidItem = item => item.active && item.price > 0;
const applyDiscount = item => ({ ...item, finalPrice: item.price * 0.9 });
const meetsMinimumPrice = item => item.finalPrice >= 10;
const toResult = ({ id, name, finalPrice }) => ({ id, name, finalPrice });

undefined

echo ""
echo "=== Generating Complexity Report ==="
echo ""

undefined

echo ""
echo "=== ✓ Complexity Analysis Complete ==="
echo ""
echo "📊 Analysis Results:"
echo "  Total issues: $TOTAL_ISSUES"
echo "  Complexity threshold: $THRESHOLD"
echo "  Languages: $LANGUAGES"
echo ""
echo "📁 Generated Files:"
echo "  - Complexity Report: $REPORT"
echo "  - Refactoring Patterns: $ANALYSIS_DIR/refactoring-patterns.md"
[ -f "$ANALYSIS_DIR/js-complexity.json" ] && echo "  - JS Analysis: $ANALYSIS_DIR/js-complexity.json"
[ -f "$ANALYSIS_DIR/python-complexity.txt" ] && echo "  - Python Analysis: $ANALYSIS_DIR/python-complexity.txt"
[ -f "$ANALYSIS_DIR/go-complexity.txt" ] && echo "  - Go Analysis: $ANALYSIS_DIR/go-complexity.txt"
echo ""
echo "🎯 Recommended Actions:"
if [ "$TOTAL_ISSUES" -gt 0 ]; then
    echo "  1. Review high-complexity functions in report"
    echo "  2. Select appropriate refactoring pattern"
    echo "  3. Implement changes incrementally"
    echo "  4. Run tests after each refactoring"
    echo "  5. Re-run /complexity-reduce to verify"
else
    echo "  ✓ No functions exceed complexity threshold"
    echo "  Continue monitoring during code reviews"
fi
echo ""
echo "💡 Common Refactoring Patterns:"
echo "  - Extract Method (split long functions)"
echo "  - Early Returns (reduce nesting)"
echo "  - Strategy Pattern (replace conditionals)"
echo "  - Decompose Conditionals (named functions)"
echo "  - Replace Loops (use pipelines)"
echo ""
echo "🔗 Integration Points:"
echo "  - /refactor - Systematic code restructuring"
echo "  - /make-it-pretty - Improve readability"
echo "  - /test - Add tests before refactoring"
echo "  - /review - Include complexity in reviews"
echo ""
echo "View report: cat $REPORT"
echo "View patterns: cat $ANALYSIS_DIR/refactoring-patterns.md"