# kubernetes/deployment.yaml
resources:
  requests:
    memory: "2Gi"    # Was 512Mi
  limits:
    memory: "4Gi"    # Was 1Gi

# utils/memory_profiler.py

def get_memory_stats() -> dict:
    """
    Get process memory stats from /proc/self/status.
    
    Returns:
        - rss: Current Resident Set Size (RAM actually used now)
        - peak: VmHWM - High Water Mark (peak RAM since process start)
    """
    stats = {'rss': 0.0, 'peak': 0.0}
    
    try:
        with open('/proc/self/status', 'r') as f:
            for line in f:
                if line.startswith('VmRSS:'):
                    stats['rss'] = int(line.split()[1]) / 1024.0  # KB to MB
                elif line.startswith('VmHWM:'):
                    stats['peak'] = int(line.split()[1]) / 1024.0
        return stats
    except Exception:
        return stats


class MemoryTracker:
    """Track memory usage at checkpoints."""
    
    def __init__(self):
        self.enabled = False
        self.last_rss = 0.0
        self.initial_peak = 0.0
    
    def enable(self):
        self.enabled = True
        stats = get_memory_stats()
        self.last_rss = stats['rss']
        self.initial_peak = stats['peak']
        print(f"[MEMORY] Tracking enabled. RSS: {stats['rss']:.1f} MB")
    
    def checkpoint(self, phase: str):
        if not self.enabled:
            return
        
        stats = get_memory_stats()
        delta = stats['rss'] - self.last_rss
        peak_increase = stats['peak'] - self.initial_peak
        
        print(f"[MEMORY] {phase}: RSS {stats['rss']:.1f} MB "
              f"({'+' if delta >= 0 else ''}{delta:.1f}) | "
              f"Peak {stats['peak']:.1f} MB (+{peak_increase:.1f} since start)")
        
        self.last_rss = stats['rss']

# Global tracker
memory = MemoryTracker()

# file_processor.py

from utils.memory_profiler import memory

def process_uploaded_file(file_path: str) -> dict:
    """Process an uploaded file and generate a report."""
    
    memory.enable()
    memory.checkpoint("Start")
    
    # Phase 1: Read metadata
    metadata = read_file_metadata(file_path)
    memory.checkpoint("Metadata read")
    
    # Phase 2: Parse content
    content = parse_file_content(file_path)
    memory.checkpoint("Content parsed")
    
    # Phase 3: Analyze data
    analysis = analyze_data(content)
    memory.checkpoint("Analysis complete")
    
    # Phase 4: Generate report
    report = generate_report(analysis)
    memory.checkpoint("Report generated")
    
    return report

# BEFORE: The memory-hungry implementation

def parse_file_content(file_path: str) -> dict:
    """Parse a structured text file into sections."""
    
    # Problem 1: Loads ENTIRE file into memory
    with open(file_path, 'r') as f:
        content = f.read()  # 3GB file = 3GB in RAM!
    
    # Problem 2: Creates copies while processing
    sections = {}
    for section_header in find_section_headers(content):
        section_content = extract_section(content, section_header)
        sections[section_header] = section_content
    
    return sections


def get_last_n_lines(file_path: str, n: int = 1000) -> str:
    """Get the last N lines from a file."""
    
    # Problem: Reads ENTIRE file just to get the tail!
    with open(file_path, 'r') as f:
        all_lines = f.readlines()  # Loads everything into memory
        return ''.join(all_lines[-n:])

# AFTER: Memory-efficient implementation

def find_section_streaming(file_path: str, header_match: str) -> str | None:
    """
    Stream through a file to find a specific section.
    
    Reads line-by-line and stops as soon as the section is found.
    Memory usage: O(1) instead of O(file_size)
    """
    section_pattern = re.compile(r'^#==\[\s*(.+?)\s*\]={5,}#\s*$')
    header_match_lower = header_match.lower()
    
    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
        in_target_section = False
        section_content = []
        
        for line in f:
            match = section_pattern.match(line)
            
            if match:
                # Found a section header
                if in_target_section:
                    # We were in the target section, hit the next one - done!
                    return '\n'.join(section_content).strip()
                
                # Check if this is the section we want
                header = match.group(1)
                if header_match_lower in header.lower():
                    in_target_section = True
                    section_content = []
                    
            elif in_target_section:
                section_content.append(line.rstrip('\n'))
        
        # Handle last section in file
        if in_target_section:
            return '\n'.join(section_content).strip()
    
    return None

# AFTER: Read from end of file, not beginning

def get_last_n_lines(file_path: str, n: int = 1000) -> str:
    """
    Get the last N lines using reverse reading.
    
    For large files, reads from the end in chunks.
    Memory usage: O(n * avg_line_length) instead of O(file_size)
    """
    from collections import deque
    
    file_size = os.path.getsize(file_path)
    
    # Small files: just read normally
    if file_size < 1024 * 1024:  # 1MB
        with open(file_path, 'r') as f:
            all_lines = f.readlines()
            return ''.join(all_lines[-n:])
    
    # Large files: read from end in chunks
    chunk_size = 8192
    result_lines = deque(maxlen=n)
    
    with open(file_path, 'rb') as f:
        f.seek(0, 2)  # Seek to end
        remaining = f.tell()
        buffer = b''
        
        while remaining > 0 and len(result_lines) < n:
            read_size = min(chunk_size, remaining)
            remaining -= read_size
            f.seek(remaining)
            chunk = f.read(read_size)
            buffer = chunk + buffer
            
            # Extract complete lines
            lines = buffer.split(b'\n')
            buffer = lines[0]  # Keep incomplete line
            
            for line in reversed(lines[1:]):
                if len(result_lines) >= n:
                    break
                result_lines.appendleft(line.decode('utf-8', errors='ignore'))
    
    return '\n'.join(result_lines)

# AFTER: Read only what you need

def read_file_with_limit(file_path: str, max_bytes: int = 50 * 1024 * 1024) -> str:
    """
    Read a file with a size limit.
    
    If the file is larger than max_bytes, only reads the first max_bytes
    and appends a truncation notice.
    """
    file_size = os.path.getsize(file_path)
    
    if file_size <= max_bytes:
        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
            return f.read()
    
    # File too large - read only up to limit
    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
        content = f.read(max_bytes)
    
    return content + f"\n\n[TRUNCATED: File is {file_size / 1024 / 1024:.1f} MB]"

# ❌ BAD: Loads entire file
content = open(file_path).read()
result = process(content)

# ✅ GOOD: Process line by line
with open(file_path) as f:
    for line in f:
        process_line(line)

# ❌ BAD: Creates multiple copies
data = get_large_data()
filtered = [x for x in data if x > 0]       # Copy 1
sorted_data = sorted(filtered)               # Copy 2
result = list(map(transform, sorted_data))   # Copy 3

# ✅ GOOD: Use generators
def process_data(data):
    for x in data:
        if x > 0:
            yield transform(x)

result = sorted(process_data(get_large_data()))

# ❌ BAD: Accumulates all results
results = []
for item in large_dataset:
    results.append(process(item))
return results

# ✅ GOOD: Yield results as generator
def process_all(large_dataset):
    for item in large_dataset:
        yield process(item)

# ❌ BAD: Reads 3GB to check first 100 bytes
with open(file_path) as f:
    content = f.read()
    if content.startswith("MAGIC"):
        # ...

# ✅ GOOD: Read only what you need
with open(file_path) as f:
    header = f.read(100)
    if header.startswith("MAGIC"):
        # ...

# memory_tracker.py
"""
Memory tracking utilities for identifying memory spikes.
Works on Linux systems by reading /proc/self/status.
"""

import os
import sys
from datetime import datetime


def _get_memory_stats() -> dict:
    """Get memory stats from /proc/self/status."""
    stats = {'rss': 0.0, 'peak': 0.0, 'virtual': 0.0}
    
    try:
        with open('/proc/self/status', 'r') as f:
            for line in f:
                if line.startswith('VmRSS:'):
                    stats['rss'] = int(line.split()[1]) / 1024.0
                elif line.startswith('VmHWM:'):
                    stats['peak'] = int(line.split()[1]) / 1024.0
                elif line.startswith('VmSize:'):
                    stats['virtual'] = int(line.split()[1]) / 1024.0
    except Exception:
        pass
    
    return stats


class MemoryTracker:
    """
    Track memory usage at checkpoints.
    
    Usage:
        tracker = MemoryTracker()
        tracker.enable()
        
        do_something()
        tracker.checkpoint("After do_something")
        
        do_more()
        tracker.checkpoint("After do_more")
    """
    
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._initialized = False
        return cls._instance
    
    def __init__(self):
        if self._initialized:
            return
        self._initialized = True
        self.enabled = False
        self.last_rss = 0.0
        self.initial_peak = 0.0
    
    def enable(self):
        """Enable memory tracking."""
        self.enabled = True
        stats = _get_memory_stats()
        self.last_rss = stats['rss']
        self.initial_peak = stats['peak']
        self._log(f"Tracking enabled. RSS: {stats['rss']:.1f} MB, "
                  f"Peak: {stats['peak']:.1f} MB")
    
    def disable(self):
        """Disable memory tracking."""
        self.enabled = False
    
    def checkpoint(self, phase: str):
        """Log memory usage at a checkpoint."""
        if not self.enabled:
            return
        
        stats = _get_memory_stats()
        delta = stats['rss'] - self.last_rss
        peak_increase = stats['peak'] - self.initial_peak
        
        msg = (f"{phase}: RSS {stats['rss']:.1f} MB "
               f"({'+' if delta >= 0 else ''}{delta:.1f}) | "
               f"Peak {stats['peak']:.1f} MB")
        
        if peak_increase > 1:
            msg += f" (+{peak_increase:.1f} since start)"
        
        self._log(msg)
        self.last_rss = stats['rss']
    
    def _log(self, message: str):
        """Output a log message."""
        timestamp = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
        print(f"[{timestamp}] [MEMORY] {message}", flush=True)


# Convenience singleton
memory = MemoryTracker()