// Just write a comment, and Copilot generates the function
// Function to validate email and return detailed validation result
function validateEmailDetailed(email) {
  const result = {
    isValid: false,
    errors: [],
    suggestions: []
  };
  
  if (!email || typeof email !== "string") {
    result.errors.push("Email is required and must be a string");
    return result;
  }
  
  email = email.trim();
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  
  if (!emailRegex.test(email)) {
    result.errors.push("Invalid email format");
    result.suggestions.push("Example: user@example.com");
    return result;
  }
  
  result.isValid = result.errors.length === 0;
  return result;
}

// Generate comprehensive tests for the above function
describe('validateEmailDetailed', () => {
  test('should return valid result for correct email', () => {
    const result = validateEmailDetailed('test@gmail.com');
    expect(result.isValid).toBe(true);
    expect(result.errors).toHaveLength(0);
  });
  
  test('should return error for empty email', () => {
    const result = validateEmailDetailed('');
    expect(result.isValid).toBe(false);
    expect(result.errors).toContain('Email is required and must be a string');
  });
  
  test('should suggest corrections for typos', () => {
    const result = validateEmailDetailed('test@gmai.com');
    expect(result.suggestions.length).toBeGreaterThan(0);
  });
});

# Original inefficient code
def process_user_data(users):
    result = []
    for user in users:
        for order in get_user_orders(user.id):
            for item in get_order_items(order.id):
                if item.price > 100:
                    result.append({
                        "user": user.name,
                        "order_id": order.id,
                        "item": item.name,
                        "price": item.price
                    })
    return result

# Claude's optimized version
async def process_user_data_optimized(users):
    user_ids = [user.id for user in users]
    orders_by_user = await get_orders_batch(user_ids)
    
    all_order_ids = [order.id for orders in orders_by_user.values() for order in orders]
    items_by_order = await get_order_items_batch(all_order_ids)
    
    result = []
    for user in users:
        user_orders = orders_by_user.get(user.id, [])
        for order in user_orders:
            order_items = items_by_order.get(order.id, [])
            for item in order_items:
                if item.price > 100:
                    result.append({
                        "user": user.name,
                        "order_id": order.id,
                        "item": item.name,
                        "price": item.price
                    })
    return result

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Analyze website performance data
def analyze_website_performance(data_file):
    # Load and clean data
    df = pd.read_csv(data_file)
    df['load_time'] = pd.to_numeric(df['load_time'], errors='coerce')
    df['bounce_rate'] = pd.to_numeric(df['bounce_rate'], errors='coerce')
    
    # Performance insights
    insights = {
        'avg_load_time': df['load_time'].mean(),
        'high_bounce_pages': df[df['bounce_rate'] > 0.7]['page_url'].tolist(),
        'performance_correlation': df['load_time'].corr(df['bounce_rate'])
    }
    
    # Create visualizations
    fig, axes = plt.subplots(2, 2, figsize=(15, 10))
    
    # Load time distribution
    axes[0, 0].hist(df['load_time'], bins=30, alpha=0.7)
    axes[0, 0].set_title('Load Time Distribution')
    axes[0, 0].set_xlabel('Load Time (seconds)')
    
    # Bounce rate vs Load time
    axes[0, 1].scatter(df['load_time'], df['bounce_rate'], alpha=0.6)
    axes[0, 1].set_title('Bounce Rate vs Load Time')
    axes[0, 1].set_xlabel('Load Time (seconds)')
    axes[0, 1].set_ylabel('Bounce Rate')
    
    # Top slow pages
    slow_pages = df.nlargest(10, 'load_time')
    axes[1, 0].barh(range(len(slow_pages)), slow_pages['load_time'])
    axes[1, 0].set_title('Slowest 10 Pages')
    axes[1, 0].set_xlabel('Load Time (seconds)')
    
    # Performance over time
    df['date'] = pd.to_datetime(df['date'])
    daily_perf = df.groupby('date')['load_time'].mean()
    axes[1, 1].plot(daily_perf.index, daily_perf.values)
    axes[1, 1].set_title('Average Load Time Over Time')
    axes[1, 1].set_xlabel('Date')
    axes[1, 1].set_ylabel('Load Time (seconds)')
    
    plt.tight_layout()
    plt.savefig('performance_analysis.png', dpi=300)
    
    return insights

// Before: Tightly coupled React component
interface UserProfileProps {
  userId: string;
}

// Cursor AI suggests: Break into smaller, reusable components
function useUserProfile(userId: string) {
  const [user, setUser] = useState<User | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
  
  useEffect(() => {
    const fetchUser = async () => {
      try {
        setLoading(true);
        const response = await fetch(`/api/users/${userId}`);
        if (!response.ok) throw new Error("Failed to fetch user");
        const userData = await response.json();
        setUser(userData);
      } catch (err) {
        setError(err instanceof Error ? err.message : "Unknown error");
      } finally {
        setLoading(false);
      }
    };
    
    fetchUser();
  }, [userId]);
  
  return { user, loading, error };
}

export const UserProfile = ({ userId }: UserProfileProps) => {
  const { user, loading, error } = useUserProfile(userId);
  
  if (loading) return <LoadingSpinner />;
  if (error) return <ErrorMessage message={error} />;
  if (!user) return <NotFound />;
  
  return (
    <div className="user-profile">
      <UserAvatar user={user} />
      <UserInfo user={user} />
      <UserStats user={user} />
    </div>
  );
};

// Tabnine learns your patterns and suggests complete implementations
class APIService {
  constructor(baseURL, apiKey) {
    this.baseURL = baseURL;
    this.apiKey = apiKey;
    this.headers = {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    };
  }
  
  // Tabnine suggests this entire method based on context
  async makeRequest(endpoint, options = {}) {
    const url = `${this.baseURL}${endpoint}`;
    const config = {
      headers: this.headers,
      ...options
    };
    
    try {
      const response = await fetch(url, config);
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      
      const contentType = response.headers.get('content-type');
      if (contentType && contentType.includes('application/json')) {
        return await response.json();
      }
      
      return await response.text();
    } catch (error) {
      console.error(`API request failed: ${error.message}`);
      throw error;
    }
  }
  
  // Auto-generated CRUD methods
  async get(endpoint) {
    return this.makeRequest(endpoint, { method: 'GET' });
  }
  
  async post(endpoint, data) {
    return this.makeRequest(endpoint, {
      method: 'POST',
      body: JSON.stringify(data)
    });
  }
  
  async put(endpoint, data) {
    return this.makeRequest(endpoint, {
      method: 'PUT',
      body: JSON.stringify(data)
    });
  }
  
  async delete(endpoint) {
    return this.makeRequest(endpoint, { method: 'DELETE' });
  }
}

# AI tools can detect and suggest fixes for common issues

# Detected Issue: Race condition in async code
import asyncio
import aiohttp

# Problematic code
async def fetch_user_data(user_ids):
    results = []
    async with aiohttp.ClientSession() as session:
        for user_id in user_ids:
            async with session.get(f'/api/users/{user_id}') as response:
                data = await response.json()
                results.append(data)
    return results

# AI suggested fix: Use asyncio.gather for concurrent requests
async def fetch_user_data_concurrent(user_ids):
    async with aiohttp.ClientSession() as session:
        tasks = [
            session.get(f'/api/users/{user_id}') 
            for user_id in user_ids
        ]
        responses = await asyncio.gather(*tasks)
        results = [await response.json() for response in responses]
    return results

# AI detected performance issue and suggested caching
from functools import lru_cache
import time

@lru_cache(maxsize=128)
def expensive_computation(n):
    # Simulate expensive operation
    time.sleep(0.1)
    return n ** 2 + n + 1

# AI suggested async version with better cache
import asyncio
from functools import wraps

def async_lru_cache(maxsize=128):
    def decorator(func):
        cache = {}
        
        @wraps(func)
        async def wrapper(*args, **kwargs):
            key = str(args) + str(sorted(kwargs.items()))
            if key in cache:
                return cache[key]
            
            result = await func(*args, **kwargs)
            if len(cache) >= maxsize:
                cache.pop(next(iter(cache)))
            cache[key] = result
            return result
        
        return wrapper
    return decorator

@async_lru_cache(maxsize=128)
async def expensive_async_computation(n):
    await asyncio.sleep(0.1)  # Simulate async operation
    return n ** 2 + n + 1

// AI tools can generate comprehensive tests from function signatures

// Function to test
function processOrder(order, inventory, discounts) {
  if (!order || !order.items) {
    throw new Error("Invalid order");
  }
  
  let total = 0;
  const processedItems = [];
  
  for (const item of order.items) {
    const inventoryItem = inventory.find(inv => inv.id === item.id);
    if (!inventoryItem) {
      throw new Error(`Item ${item.id} not found in inventory`);
    }
    
    if (inventoryItem.quantity < item.quantity) {
      throw new Error(`Insufficient stock for item ${item.id}`);
    }
    
    let itemTotal = inventoryItem.price * item.quantity;
    const discount = discounts.find(d => d.itemId === item.id);
    if (discount) {
      itemTotal *= (1 - discount.percentage / 100);
    }
    
    total += itemTotal;
    processedItems.push({
      ...item,
      price: inventoryItem.price,
      total: itemTotal
    });
  }
  
  return {
    total,
    items: processedItems,
    orderNumber: `ORD-${Date.now()}`
  };
}

// AI-generated comprehensive test suite
describe("processOrder", () => {
  const mockInventory = [
    { id: 1, name: "Widget A", price: 10, quantity: 100 },
    { id: 2, name: "Widget B", price: 20, quantity: 50 }
  ];
  
  const mockDiscounts = [{ itemId: 1, percentage: 10 }];
  
  test("should process valid order with single item", () => {
    const order = { items: [{ id: 1, quantity: 2 }] };
    const result = processOrder(order, mockInventory, mockDiscounts);
    
    expect(result.total).toBe(18); // 10 * 2 * 0.9 (10% discount)
    expect(result.items).toHaveLength(1);
    expect(result.orderNumber).toMatch(/ORD-\d+/);
  });
  
  test("should throw error for missing inventory item", () => {
    const order = { items: [{ id: 999, quantity: 1 }] };
    
    expect(() => processOrder(order, mockInventory, mockDiscounts))
      .toThrow("Item 999 not found in inventory");
  });
});

// Use AI for code review automation
const reviewPrompts = {
  security: "Check this code for security vulnerabilities",
  performance: "Identify performance bottlenecks in this function",
  maintainability: "Suggest improvements for code maintainability",
  testing: "Generate test cases for this function"
};

async function aiCodeReview(codeSnippet, reviewType) {
  const prompt = `${reviewPrompts[reviewType]}: ${codeSnippet}`;
  return await aiService.analyze(prompt);
}

/**
 * AI generates comprehensive documentation automatically
 */
async function authenticateUser(credentials, provider, options = {}) {
  // Validates user credentials against specified provider
  // Supports multiple authentication methods
  // Returns user data with access tokens
  
  const validationResult = await validateCredentials(credentials, provider);
  if (!validationResult.isValid) {
    throw new AuthError("Invalid credentials");
  }
  
  const user = await createUserSession(validationResult.user, options);
  return {
    user,
    accessToken: user.tokens.access,
    refreshToken: user.tokens.refresh
  };
}

# Install GitHub Copilot extension in VS Code
# Enable in your IDE settings
# Start coding and let AI assist you

// Ask AI to help with complex problems
// "How can I optimize this database query?"
// "Generate unit tests for this function"
// "Refactor this code to be more maintainable"