solver.py

#!/usr/bin/env python3
import argparse
import csv
import os
import subprocess
import time
import random
import multiprocessing
import signal
import sys

# ============================================================================
# SLOT AND TYPE NORMALIZATION DATA STRUCTURES
# ============================================================================
# All slot and type names are normalized to lowercase canonical forms.
# This centralizes all naming variations in one place for easy maintenance.

# Canonical slot names (the "correct" names we use throughout the code)
CANONICAL_SLOTS = {
    'helm', 'chest', 'shoulders', 'gloves', 'pants', 'boots', 'belt',
    'amulet', 'medal', 'ring 1', 'ring 2'
}

# Slot name aliases: maps alternate names to canonical names
SLOT_ALIASES = {
    'head': 'helm',
    'helmet': 'helm',
    'shoulder': 'shoulders',
    'hands': 'gloves',
    'leg': 'pants',
    'legs': 'pants',
    'foot': 'boots',
    'waist': 'belt',
    'rings': 'ring',  # Plural form used in CSV for components/augments that apply to rings
    'amulets': 'amulet',  # Plural form used in CSV
}

# Special slot handling
# 'ring' (singular) matches both 'ring 1' and 'ring 2' for components/augments
# 'armor' expands to all armor pieces (helm, chest, shoulders, gloves, pants, boots, belt)
MULTI_SLOT_TYPES = {
    'ring': ['ring 1', 'ring 2'],
    'armor': ['helm', 'chest', 'shoulders', 'gloves', 'pants', 'boots', 'belt']
}

# Item type aliases for special types
ITEM_TYPE_ALIASES = {
    'component': 'component',
    'augment': 'augment',
}

# Global flag for interrupt handling
interrupted = False

def signal_handler(signum, frame):
    """Handle Ctrl+C gracefully."""
    global interrupted
    if not interrupted:  # Only print message once
        interrupted = True
        print("\n\nInterrupted by user. Finishing current cycle and showing best results found so far...")

def check_and_convert_ods():
    """Checks if the ODS file is newer than the CSV and converts it if necessary."""
    ods_file = 'grim_items.ods'
    csv_file = 'grim_items.csv'

    if not os.path.exists(csv_file) or os.path.getmtime(ods_file) > os.path.getmtime(csv_file):
        print(f"'{ods_file}' is newer than '{csv_file}' or '{csv_file}' does not exist. Converting...")
        try:
            subprocess.run(
                ['libreoffice', '--headless', '--convert-to', 'csv', ods_file],
                check=True,
                capture_output=True,
                text=True
            )
            print("Conversion successful.")
        except (subprocess.CalledProcessError, FileNotFoundError) as e:
            print(f"Error during conversion: {e}")
            if isinstance(e, FileNotFoundError):
                print("Please ensure 'libreoffice' is installed and in your PATH.")
            else:
                print(f"Stderr: {e.stderr}")
            exit(1)


def parse_row_float(row, header, default_value=0):
    """Helper function to parse a row of floats with error handling."""
    parsed_row = {}
    for i, item in enumerate(row):
        try:
            parsed_row[header[i]] = float(item) if item else default_value
        except ValueError:
            parsed_row[header[i]] = default_value
    return parsed_row

def normalize_slot_name(slot_name):
    """Normalize slot names to canonical form using centralized SLOT_ALIASES.

    Args:
        slot_name: Raw slot/gear type name from CSV

    Returns:
        Normalized slot name in lowercase canonical form

    Examples:
        'Head' -> 'helm'
        'Shoulder' -> 'shoulders'
        'Ring' -> 'ring' (special case, matches 'ring 1' and 'ring 2')
    """
    if not slot_name:
        return ''

    normalized = slot_name.strip().lower()
    return SLOT_ALIASES.get(normalized, normalized)


def normalize_item_type(item_type):
    """Normalize item type names (Component, Augment, etc).

    Args:
        item_type: Raw item type from CSV

    Returns:
        Normalized item type in lowercase
    """
    if not item_type:
        return ''

    normalized = item_type.strip().lower()
    return ITEM_TYPE_ALIASES.get(normalized, normalized)


def expand_applies_to(applies_to_str):
    """Parse and expand applies_to field, handling multi-slot types like 'armor' and 'ring'.

    Args:
        applies_to_str: Comma-separated list of slot names from CSV

    Returns:
        List of normalized slot names with multi-slot types expanded

    Example:
        'armor,amulet' -> ['helm', 'chest', 'shoulders', 'gloves', 'pants', 'boots', 'belt', 'amulet']
    """
    if not applies_to_str:
        return []

    expanded = []
    raw_slots = [s.strip() for s in applies_to_str.split(',') if s.strip()]

    for slot in raw_slots:
        normalized = normalize_slot_name(slot)

        # Check if this is a multi-slot type that needs expansion
        if normalized in MULTI_SLOT_TYPES:
            expanded.extend(MULTI_SLOT_TYPES[normalized])
        else:
            expanded.append(normalized)

    return expanded


def infer_component_augment_slots(items_needing_inference, equipped_base_gear):
    """Infer which slot a component/augment is equipped in based on tf count and applies_to.

    Args:
        items_needing_inference: List of component/augment items with tf > 0 but no equipped_in
        equipped_base_gear: Dict of {slot: base_item} for currently equipped base gear

    Returns:
        Dict of {item_name: slot} for inferred assignments
        List of warning messages for ambiguous cases
    """
    inferred = {}
    warnings = []

    for item in items_needing_inference:
        # Parse applies_to
        applies_to_str = item.get('applies_to', '').strip()
        if not applies_to_str:
            warnings.append(
                f"WARNING: {item['type']} '{item['name']}' has tf={item['tf']} but no applies_to field. "
                f"Cannot infer slot."
            )
            continue

        applies_to_raw = [s.strip() for s in applies_to_str.split(',') if s.strip()]
        valid_slots = [normalize_slot_name(s) for s in applies_to_raw]

        # Filter to only equipped slots
        equipped_valid_slots = [
            slot for slot in valid_slots
            if slot in equipped_base_gear or
               ('ring' in valid_slots and slot in ['ring 1', 'ring 2'] and
                (slot in equipped_base_gear))
        ]

        # Handle 'ring' matching both ring 1 and ring 2
        if 'ring' in valid_slots:
            for ring_slot in ['ring 1', 'ring 2']:
                if ring_slot in equipped_base_gear and ring_slot not in equipped_valid_slots:
                    equipped_valid_slots.append(ring_slot)

        if len(equipped_valid_slots) == 0:
            warnings.append(
                f"WARNING: {item['type']} '{item['name']}' is marked as equipped (tf={item['tf']}) "
                f"but no equipped gear matches applies_to='{applies_to_str}'. "
                f"Please check your tf column or equipped_in column."
            )
        elif len(equipped_valid_slots) == 1:
            # Unambiguous - only one possible slot
            inferred[item['name']] = equipped_valid_slots[0]
        else:
            # Ambiguous - multiple possibilities
            # Strategy: Use first valid slot and warn
            inferred[item['name']] = equipped_valid_slots[0]
            warnings.append(
                f"WARNING: {item['type']} '{item['name']}' could be in {', '.join(equipped_valid_slots)}. "
                f"Using {equipped_valid_slots[0]} as best guess. "
                f"Specify equipped_in column for accuracy."
            )

    return inferred, warnings


def sort_rings_by_benefit(gear_dict, header, points_per_unit, max_points):
    """Sort rings so that highest benefit ring is always in ring 1.

    This ensures consistent display across runs even when GA finds same rings in different order.
    Called only during display phase, has no impact on solver performance.

    Args:
        gear_dict: Dict of {slot: {'base': item, 'component': item, 'augment': item}}
        header: CSV header
        points_per_unit: Benefit points per stat unit
        max_points: Maximum benefit caps per stat

    Returns:
        Modified gear_dict with rings sorted by benefit (in-place modification)
    """
    if 'ring 1' not in gear_dict or 'ring 2' not in gear_dict:
        return gear_dict

    # Calculate benefit for each ring slot (base + component + augment)
    def calculate_slot_benefit(slot_data):
        total_benefit = 0
        for item in [slot_data.get('base'), slot_data.get('component'), slot_data.get('augment')]:
            if not item:
                continue
            for stat, value in item.get('stats', {}).items():
                if stat in points_per_unit:
                    capped_value = min(value, max_points.get(stat, float('inf')))
                    total_benefit += capped_value * points_per_unit[stat]
        return total_benefit

    ring1_benefit = calculate_slot_benefit(gear_dict['ring 1'])
    ring2_benefit = calculate_slot_benefit(gear_dict['ring 2'])

    # If ring 2 has higher benefit, swap them
    if ring2_benefit > ring1_benefit:
        gear_dict['ring 1'], gear_dict['ring 2'] = gear_dict['ring 2'], gear_dict['ring 1']

    return gear_dict


def get_current_gear_with_components_augments(all_items, gear_by_type, components, augments):
    """Reconstruct the player's current full gear setup including components and augments.

    Args:
        all_items: All items from CSV (raw dict format)
        gear_by_type: Dict of {type: [items]} for base gear
        components: List of all component items
        augments: List of all augment items

    Returns:
        Dict of {slot: {'base': item, 'component': item or None, 'augment': item or None}}
    """
    # Find equipped base gear (tf=1)
    equipped_base = {}
    ring1_assigned = False

    for item in all_items:
        item_type_normalized = normalize_item_type(item.get('type', ''))
        if item.get('tf') == '1' and item_type_normalized not in ['component', 'augment']:
            gear_type = item['type']
            if gear_type:
                # Normalize and handle rings
                normalized_type = normalize_slot_name(gear_type)
                if normalized_type == 'ring':
                    if not ring1_assigned:
                        slot = 'ring 1'
                        ring1_assigned = True
                    else:
                        slot = 'ring 2'
                else:
                    slot = normalized_type

                # Check if slot is already occupied
                if slot in equipped_base:
                    print(f"\nERROR: Multiple items selected for the same slot!")
                    print(f"  Slot: {slot}")
                    print(f"  First item: {equipped_base[slot]['name']}")
                    print(f"  Second item: {item['name']}")
                    print(f"\nPlease ensure only ONE item has tf=1 for each gear slot.")
                    print(f"Check your CSV file (grim_items.csv) and set tf=0 for one of the above items.\n")
                    exit(1)

                equipped_base[slot] = item

    # Find equipped components and augments (tf > 0)
    equipped_components = []
    equipped_augments = []

    for item in components:
        tf_val = item.get('tf', '0')
        try:
            if int(tf_val) > 0:
                equipped_components.append(item)
        except (ValueError, TypeError):
            pass

    for item in augments:
        tf_val = item.get('tf', '0')
        try:
            if int(tf_val) > 0:
                equipped_augments.append(item)
        except (ValueError, TypeError):
            pass

    # Infer slots for components/augments
    slot_assignments_comp, warnings_comp = infer_component_augment_slots(
        [c for c in equipped_components if not c.get('equipped_in', '').strip()],
        equipped_base
    )
    slot_assignments_aug, warnings_aug = infer_component_augment_slots(
        [a for a in equipped_augments if not a.get('equipped_in', '').strip()],
        equipped_base
    )

    # Print warnings
    for warning in warnings_comp + warnings_aug:
        print(warning)

    # Build final current gear state
    current_gear = {}
    for slot, base_item in equipped_base.items():
        current_gear[slot] = {
            'base': base_item,
            'component': None,
            'augment': None
        }

    # Assign components to slots
    for comp in equipped_components:
        # Check if equipped_in is explicitly specified
        equipped_in_raw = comp.get('equipped_in', '').strip()
        if equipped_in_raw:
            # Handle comma-separated slots (e.g., "helm,chest")
            slots = [normalize_slot_name(s) for s in equipped_in_raw.split(',') if s.strip()]
        else:
            slot = slot_assignments_comp.get(comp['name'])
            slots = [slot] if slot else []

        for slot in slots:
            if slot and slot in current_gear:
                current_gear[slot]['component'] = comp

    # Assign augments to slots
    for aug in equipped_augments:
        # Check if equipped_in is explicitly specified
        equipped_in_raw = aug.get('equipped_in', '').strip()
        if equipped_in_raw:
            # Handle comma-separated slots (e.g., "helm,chest")
            slots = [normalize_slot_name(s) for s in equipped_in_raw.split(',') if s.strip()]
        else:
            slot = slot_assignments_aug.get(aug['name'])
            slots = [slot] if slot else []

        for slot in slots:
            if slot and slot in current_gear:
                current_gear[slot]['augment'] = aug

    return current_gear

def get_gear_stats(gear_list, header):
    """Calculates the total stats for a list of gear."""
    total_stats = {stat: 0.0 for stat in header}
    for item in gear_list:
        for stat, value in item.get('stats', {}).items():
            total_stats[stat] += value
    return total_stats

def display_stat_comparison(current_gear, recommended_gear, header, points_per_unit, max_points):
    """Displays a detailed comparison of stats and benefit scores."""
    current_stats = get_gear_stats(current_gear, header)
    recommended_stats = get_gear_stats(recommended_gear, header)

    print("\n--- Stat Comparison ---")
    print(f"{'Stat':<15} {'Weight':>8} {'Current':>10} {'New':>10} {'Change':>10} {'New Stats':>12} {'Max':>8}")
    print(f"{'':<15} {'':>8} {'Benefit':>10} {'Benefit':>10} {'':>10} {'(Points)':>12} {'':>8}")
    print("-" * 80)

    total_current_benefit = 0
    total_recommended_benefit = 0

    for stat in header:
        # Skip stats with zero or negative weight (metadata columns like tf, type, name, etc.)
        weight = points_per_unit.get(stat, 0)
        if weight <= 0:
            continue
        current_stat_points = current_stats.get(stat, 0)
        recommended_stat_points = recommended_stats.get(stat, 0)
        max_val = max_points.get(stat, float('inf'))

        # Apply caps when calculating benefits for display
        capped_current = min(current_stat_points, max_val)
        capped_recommended = min(recommended_stat_points, max_val)

        current_benefit = capped_current * weight
        recommended_benefit = capped_recommended * weight
        change = recommended_benefit - current_benefit

        total_current_benefit += current_benefit
        total_recommended_benefit += recommended_benefit

        if current_stat_points != 0 or recommended_stat_points != 0:
            max_display = str(round(max_val)) if max_val != float('inf') else "N/A"
            print(f"{stat:<15} {weight:>8.2f} {round(current_benefit):>10} {round(recommended_benefit):>10} {round(change):>+10} {round(recommended_stat_points):>12} {max_display:>8}")

    print("-" * 80)
    total_change = total_recommended_benefit - total_current_benefit
    print(f"{'Total Benefit':<15} {'':>8} {round(total_current_benefit):>10} {round(total_recommended_benefit):>10} {round(total_change):>+10}")


def display_stat_comparison_new(current_gear_dict, optimal_gear_dict, header, points_per_unit, max_points, baseline, current_benefit, optimal_benefit):
    """Displays compact stat comparison with baseline, cap-integrated display, and total points.

    Args:
        current_gear_dict: Dict of {slot: {'base': item, 'component': item, 'augment': item}}
        optimal_gear_dict: Dict of {slot: {'base': item, 'component': item, 'augment': item}}
        header: CSV header
        points_per_unit: Benefit points per stat unit
        max_points: Maximum benefit caps per stat
        baseline: Baseline stat values from skills/difficulty
        current_benefit: Pre-calculated current benefit score (from calculate_fitness)
        optimal_benefit: Pre-calculated optimal benefit score (from calculate_fitness)
    """
    # Column width constants for consistent formatting
    COL_STAT_WIDTH = 10
    COL_WEIGHT_WIDTH = 4
    COL_CUROPT_WIDTH = 17  # Fits: "9999 → 9999 / 999" (supports up to 3-digit max values)
    COL_POINTS_WIDTH = 3
    COL_SOURCES_WIDTH = 80  # Increased from 77 (gained 3 chars from COL_CUROPT_WIDTH reduction)
    SEP = "  "  # Standard separator between columns

    # Calculate total stats for current and optimal (raw values from gear only, not including baseline)
    def calculate_total_stats(gear_dict):
        total_stats = {stat: 0.0 for stat in header}
        for slot, gear_set in gear_dict.items():
            # Base item
            if gear_set.get('base'):
                for stat, val in gear_set['base'].get('stats', {}).items():
                    total_stats[stat] += val
            # Component
            if gear_set.get('component'):
                for stat, val in gear_set['component'].get('stats', {}).items():
                    total_stats[stat] += val
            # Augment
            if gear_set.get('augment'):
                for stat, val in gear_set['augment'].get('stats', {}).items():
                    total_stats[stat] += val
        return total_stats

    current_stats = calculate_total_stats(current_gear_dict)
    optimal_stats = calculate_total_stats(optimal_gear_dict)

    # Display baseline stats section (only show non-zero values)
    baseline_display = []
    for stat in header:
        # Skip stats with zero or negative weight (metadata columns like tf, type, name, etc.)
        weight = points_per_unit.get(stat, 0)
        if weight <= 0:
            continue
        baseline_val = baseline.get(stat, 0)
        if baseline_val != 0:
            baseline_display.append(f"{stat}: {baseline_val:+.0f}" if baseline_val != int(baseline_val) else f"{stat}: {int(baseline_val):+d}")

    if baseline_display:
        print("=" * 120)
        print("BASELINE STATS (from skills + difficulty)")
        print("=" * 120)
        print(" | ".join(baseline_display))
        print()

    print("=" * 120)
    print("STAT COMPARISON")
    print("=" * 120)
    print(f"{'Stat':<{COL_STAT_WIDTH}}{SEP}{'Wgt':>{COL_WEIGHT_WIDTH}}{SEP}{'Cur → Opt':<{COL_CUROPT_WIDTH}}{SEP}{'Pts':>{COL_POINTS_WIDTH}}{SEP}{'Sources (optimal)'}")
    print("─" * 120)

    # Collect stats with non-zero values
    stats_to_display = []
    for stat in header:
        # Skip stats with zero or negative weight (metadata columns like tf, type, name, etc.)
        weight = points_per_unit.get(stat, 0)
        if weight <= 0:
            continue

        current_val = current_stats.get(stat, 0)
        optimal_val = optimal_stats.get(stat, 0)

        if current_val != 0 or optimal_val != 0:
            stats_to_display.append(stat)

    for stat in stats_to_display:
        weight = points_per_unit.get(stat, 0)
        current_val_gear = current_stats.get(stat, 0)
        optimal_val_gear = optimal_stats.get(stat, 0)
        baseline_val = baseline.get(stat, 0)
        max_val = max_points.get(stat, float('inf'))

        # Add baseline to gear stats to get total values
        current_val = current_val_gear + baseline_val
        optimal_val = optimal_val_gear + baseline_val

        # Apply caps to total values
        capped_optimal_total = min(optimal_val, max_val)
        capped_baseline = min(baseline_val, max_val)

        # Calculate marginal benefit points for optimal (gear contribution only)
        gear_contribution = capped_optimal_total - capped_baseline
        stat_optimal_benefit = gear_contribution * weight

        # Calculate sources
        sources = calculate_sources_for_stat(stat, optimal_gear_dict, header)
        sources_str = format_sources_column(sources, max_width=COL_SOURCES_WIDTH)

        # Format Cur → Opt column with aligned arrow and aligned slash
        # Right-align current value, arrow, then right-align optimal (which aligns the /)
        if max_val != float('inf'):
            opt_str = f"{int(current_val):>4} → {int(optimal_val):>4} / {int(max_val)}"
        else:
            opt_str = f"{int(current_val):>4} → {int(optimal_val):>4}"

        # Format points (total benefit from this stat)
        points_str = f"{int(stat_optimal_benefit)}"

        print(f"{stat:<{COL_STAT_WIDTH}}{SEP}{weight:>{COL_WEIGHT_WIDTH}.2f}{SEP}{opt_str:<{COL_CUROPT_WIDTH}}{SEP}{points_str:>{COL_POINTS_WIDTH}}{SEP}{sources_str}")

    print("─" * 120)
    # Use the pre-calculated benefit totals passed in as parameters
    improvement = optimal_benefit - current_benefit
    improvement_pct = (improvement / current_benefit * 100) if current_benefit > 0 else 0
    print(f"TOTAL:  {int(current_benefit)} → {int(optimal_benefit)} ({improvement:+.0f} points, {improvement_pct:+.1f}%)")
    print("=" * 120)


def display_swap_analysis(currently_equipped, best_combination, points_per_unit, max_points):
    """Displays detailed analysis of each gear swap with stat-by-stat benefit breakdown."""
    current_gear_map = {item['type']: item for item in currently_equipped}
    best_gear_map = {item['type']: item for item in best_combination}

    all_slots = sorted(list(set(current_gear_map.keys()) | set(best_gear_map.keys())))

    # Collect all swaps with their benefit changes
    swaps = []
    for slot in all_slots:
        current_item = current_gear_map.get(slot)
        best_item = best_gear_map.get(slot)

        if current_item and best_item and current_item['name'] != best_item['name']:
            current_benefit = current_item.get('calculated_value', 0)
            best_benefit = best_item.get('calculated_value', 0)
            benefit_change = best_benefit - current_benefit

            swaps.append({
                'slot': slot,
                'current_item': current_item,
                'best_item': best_item,
                'benefit_change': benefit_change
            })

    if not swaps:
        return

    # Sort by benefit change (highest improvement first)
    swaps.sort(key=lambda x: x['benefit_change'], reverse=True)

    print("\n=== DETAILED SWAP ANALYSIS ===")
    print("(Sorted by benefit improvement, highest first)\n")

    for i, swap in enumerate(swaps, 1):
        slot = swap['slot']
        current_item = swap['current_item']
        best_item = swap['best_item']
        benefit_change = swap['benefit_change']

        print(f"{i}. {slot.upper()}: {current_item['name']} -> {best_item['name']}")
        print(f"   Net Change: {benefit_change:+.1f} benefit points")
        print()

        # Calculate stat differences
        current_stats = current_item.get('stats', {})
        best_stats = best_item.get('stats', {})

        # Collect all stats that changed
        all_stats = set(current_stats.keys()) | set(best_stats.keys())
        stat_changes = []

        for stat in all_stats:
            if stat in ['tf', 'type', 'name', 'Total', 'calculated_value', 'stats']:
                continue

            current_val = current_stats.get(stat, 0)
            best_val = best_stats.get(stat, 0)

            if current_val != best_val:
                weight = points_per_unit.get(stat, 0)
                max_val = max_points.get(stat, float('inf'))

                # Calculate capped benefits
                current_capped = min(current_val, max_val)
                best_capped = min(best_val, max_val)

                current_benefit = current_capped * weight
                best_benefit = best_capped * weight
                benefit_diff = best_benefit - current_benefit

                stat_changes.append({
                    'stat': stat,
                    'current_val': current_val,
                    'best_val': best_val,
                    'weight': weight,
                    'benefit_diff': benefit_diff,
                    'is_capped': best_capped < best_val or current_capped < current_val
                })

        # Sort by absolute benefit difference
        stat_changes.sort(key=lambda x: abs(x['benefit_diff']), reverse=True)

        # Display stat changes
        print(f"   {'Stat':<10} {'Old':>8} {'New':>8} {'Change':>8} {'Weight':>8} {'Benefit':>10}")
        print(f"   {'-'*62}")

        for sc in stat_changes:
            stat_display = sc['stat']
            if sc['is_capped']:
                stat_display += "*"  # Mark capped stats with asterisk

            val_change = sc['best_val'] - sc['current_val']
            print(f"   {stat_display:<10} {sc['current_val']:>8.1f} {sc['best_val']:>8.1f} "
                  f"{val_change:>+8.1f} x{sc['weight']:>6.2f} = {sc['benefit_diff']:>+8.1f}")

        print()

    print("* = Stat is at or exceeds cap (benefit calculation uses capped value)")
    print()


def display_gear_comparison(currently_equipped, best_combination):
    """Displays a comparison table of currently equipped vs. recommended gear."""
    print("\n**Currently Equipped Gear vs. Recommended Gear**")
    print("\n| Slot      | Current Gear                                    | CurBen |    | Recommended Gear                                | RecBen |")
    print("| :-------- | :---------------------------------------------- | :----- | :- | :---------------------------------------------- | :----- |")

    current_gear_map = {item['type']: item for item in currently_equipped}
    best_gear_map = {item['type']: item for item in best_combination}

    all_slots = sorted(list(set(current_gear_map.keys()) | set(best_gear_map.keys())))

    total_current_benefit = 0
    total_best_benefit = 0

    for slot in all_slots:
        current_item = current_gear_map.get(slot)
        best_item = best_gear_map.get(slot)

        # Format current item name with component/augment
        if current_item:
            current_name = current_item.get('display_name', current_item['name'])
        else:
            current_name = "None"
        current_benefit = round(current_item.get('calculated_value', 0)) if current_item else 0
        total_current_benefit += current_benefit

        # Format best item name with component/augment
        if best_item:
            best_name = best_item.get('display_name', best_item['name'])
        else:
            best_name = "None"
        best_benefit = round(best_item.get('calculated_value', 0)) if best_item else 0
        total_best_benefit += best_benefit

        change_indicator = "->" if current_name != best_name else ""

        print(f"| {slot.capitalize():<9} | {current_name:<47} | {current_benefit:<6} | {change_indicator:<2} | {best_name:<47} | {best_benefit:<6} |")

    print(f"| Total     | {'':<47} | {total_current_benefit:<6} |    | {'':<47} | {total_best_benefit:<6} |")


def _item_name(item):
    """Helper to safely get item name or None."""
    return item['name'] if item else None


def format_item_stats(item, header, points_per_unit, max_width=80):
    """Format stats for a single item, sorted by benefit points.

    Args:
        item: Item dict with stats
        header: CSV header
        points_per_unit: Benefit points per stat unit
        max_width: Maximum character width for stats display

    Returns:
        String like "rFire(50), hlth(100), +%ts(5)" sorted by benefit value
    """
    if not item:
        return ""

    # Collect all stats with their values and benefit points
    stats_with_benefit = []
    for stat in header:
        if stat in ['tf', 'type', 'name', 'Total', 'calculated_value', 'stats', 'applies_to', 'equipped_in', 'note', 'Misc', 'poten']:
            continue

        try:
            value = float(item.get(stat, 0) or 0)
            if value > 0:
                weight = points_per_unit.get(stat, 0)
                benefit = value * weight
                stats_with_benefit.append((stat, value, benefit))
        except (ValueError, TypeError):
            pass

    # Sort by benefit descending
    stats_with_benefit.sort(key=lambda x: x[2], reverse=True)

    # Format as stat(value)
    formatted = []
    for stat, value, _ in stats_with_benefit:
        if value == int(value):
            formatted.append(f"{stat}({int(value)})")
        else:
            formatted.append(f"{stat}({value:.1f})")

    if not formatted:
        return ""

    result = ", ".join(formatted)

    # If too long, truncate and add "+N"
    if len(result) > max_width:
        truncated = []
        current_length = 0

        for i, item_str in enumerate(formatted):
            remaining_count = len(formatted) - i
            suffix = f", +{remaining_count}" if remaining_count > 0 else ""
            suffix_len = len(suffix)

            # Can we fit this item plus the suffix?
            if current_length == 0:  # First item, no leading ", "
                needed = len(item_str) + suffix_len
            else:
                needed = current_length + 2 + len(item_str) + suffix_len  # +2 for ", "

            if needed <= max_width:
                truncated.append(item_str)
                if current_length == 0:
                    current_length = len(item_str)
                else:
                    current_length += 2 + len(item_str)
            else:
                # Add the suffix and break
                result = ", ".join(truncated) + f", +{len(formatted) - len(truncated)}"
                return result

        result = ", ".join(truncated)

    return result


def _format_item_line(current_item, optimal_item):
    """
    Format a single item line (base/component/augment) with hybrid display logic.

    Returns:
        - "old → new" if changed
        - "name" if unchanged (for verification)
        - "(none) → name" if adding to empty slot
        - None if both empty (don't show line)
    """
    current_name = _item_name(current_item)
    optimal_name = _item_name(optimal_item)

    if current_name == optimal_name:
        # No change - show for verification if equipped
        return optimal_name if optimal_name else None
    elif current_name is None and optimal_name:
        # Adding to empty slot
        return f"(none) → {optimal_name}"
    elif current_name and optimal_name is None:
        # Removing (rare)
        return f"{current_name} → (none)"
    elif current_name and optimal_name:
        # Swapping
        return f"{current_name} → {optimal_name}"
    else:
        return None


def display_gear_swaps_new(current_gear_dict, optimal_gear_dict, header, points_per_unit, swaps_only=False):
    """Displays recommended gear configuration with stats for each item.

    Display rules:
    - Changed items show: old → new  stat(value), stat(value), ... (with arrow)
    - Unchanged items show: name  stat(value), stat(value), ... (for verification, no arrow)
    - Empty slots don't show (no line at all)

    Args:
        current_gear_dict: Dict of {slot: {'base': item, 'component': item, 'augment': item}}
        optimal_gear_dict: Dict of {slot: {'base': item, 'component': item, 'augment': item}}
        header: CSV header
        points_per_unit: Benefit points per stat unit
        swaps_only: If True, only show slots with changes (default: False, show all gear)
    """
    all_slots = sorted(set(list(current_gear_dict.keys()) + list(optimal_gear_dict.keys())))

    # Find slots that have changes
    changing_slots = []
    for slot in all_slots:
        current = current_gear_dict.get(slot, {})
        optimal = optimal_gear_dict.get(slot, {})

        # Check if anything changed in this slot
        base_changed = (current.get('base', {}).get('name') if current.get('base') else None) != \
                       (optimal.get('base', {}).get('name') if optimal.get('base') else None)

        comp_changed = (current.get('component', {}).get('name') if current.get('component') else None) != \
                       (optimal.get('component', {}).get('name') if optimal.get('component') else None)

        aug_changed = (current.get('augment', {}).get('name') if current.get('augment') else None) != \
                      (optimal.get('augment', {}).get('name') if optimal.get('augment') else None)

        if base_changed or comp_changed or aug_changed:
            changing_slots.append(slot)

    # Determine which slots to display
    if swaps_only:
        slots_to_display = changing_slots
        header_text = f"RECOMMENDED CHANGES ({len(changing_slots)} slots)"
    else:
        slots_to_display = all_slots
        header_text = "RECOMMENDED GEAR CONFIGURATION"

    if not changing_slots:
        print("=" * 120)
        print("RECOMMENDED CHANGES")
        print("=" * 120)
        print("\n  No changes needed - your current gear is optimal!\n")
        print("=" * 120)
        return

    # Display header
    print("=" * 120)
    print(header_text)
    print("=" * 120)
    print()

    # Display each slot
    for slot in slots_to_display:
        current = current_gear_dict.get(slot, {})
        optimal = optimal_gear_dict.get(slot, {})

        # Slot name
        print(f"{slot.upper()}")

        # Format each field (base/component/augment) using hybrid display logic
        base_line = _format_item_line(current.get('base'), optimal.get('base'))
        comp_line = _format_item_line(current.get('component'), optimal.get('component'))
        aug_line = _format_item_line(current.get('augment'), optimal.get('augment'))

        # Get stats for optimal items
        base_stats = format_item_stats(optimal.get('base'), header, points_per_unit, max_width=80)
        comp_stats = format_item_stats(optimal.get('component'), header, points_per_unit, max_width=80)
        aug_stats = format_item_stats(optimal.get('augment'), header, points_per_unit, max_width=80)

        # Show lines that have content (None means both empty, don't show)
        if base_line:
            stats_suffix = f"  {base_stats}" if base_stats else ""
            print(f"  Base:       {base_line}{stats_suffix}")
        if comp_line:
            stats_suffix = f"  {comp_stats}" if comp_stats else ""
            print(f"  Component:  {comp_line}{stats_suffix}")
        if aug_line:
            stats_suffix = f"  {aug_stats}" if aug_stats else ""
            print(f"  Augment:    {aug_line}{stats_suffix}")

        print()

    print("=" * 120)


def display_performance_summary(comparisons_evaluated, elapsed_time):
    """Displays a one-liner performance summary."""
    if elapsed_time > 0:
        comparisons_per_sec = comparisons_evaluated / elapsed_time
        print(f"Evaluated {comparisons_evaluated:,} gearsets in {elapsed_time:.2f} seconds ({comparisons_per_sec:,.0f} comparisons/sec)\n")
    else:
        print(f"Evaluated {comparisons_evaluated:,} gearsets in {elapsed_time:.2f} seconds\n")


def display_execution_summary(comparisons_evaluated, elapsed_time, current_benefit, optimal_benefit, num_cores, generation):
    """Displays a 2-line execution summary at the bottom of output.

    This is the most important summary info that stays visible without scrolling.
    """
    # Line 1: Solver performance metrics
    if elapsed_time > 0:
        comparisons_per_sec = comparisons_evaluated / elapsed_time
        # Format large numbers nicely (e.g., 24.7T, 4.94T/s)
        def format_large_number(n):
            if n >= 1e12:
                return f"{n/1e12:.1f}T"
            elif n >= 1e9:
                return f"{n/1e9:.1f}B"
            elif n >= 1e6:
                return f"{n/1e6:.1f}M"
            elif n >= 1e3:
                return f"{n/1e3:.1f}K"
            else:
                return f"{n:.0f}"

        eval_str = format_large_number(comparisons_evaluated)
        rate_str = format_large_number(comparisons_per_sec)

        print(f"Evaluated {eval_str} combinations in {elapsed_time:.1f}s ({rate_str}/s) | {num_cores} cores | Generation {generation}")
    else:
        print(f"Evaluated {comparisons_evaluated:,} combinations in {elapsed_time:.1f}s | {num_cores} cores | Generation {generation}")

    # Line 2: Benefit score comparison
    improvement = optimal_benefit - current_benefit
    if current_benefit > 0:
        improvement_pct = (improvement / current_benefit) * 100
        print(f"Current: {current_benefit:.0f} pts | Optimal: {optimal_benefit:.0f} pts | Improvement: {improvement:+.0f} pts ({improvement_pct:+.1f}%)")
    else:
        print(f"Current: {current_benefit:.0f} pts | Optimal: {optimal_benefit:.0f} pts | Improvement: {improvement:+.0f} pts")


def calculate_sources_for_stat(stat_name, gear_dict, header):
    """Calculate which slots/components/augments contribute to a stat.

    Args:
        stat_name: Name of stat to analyze
        gear_dict: Dict of {slot: {'base': item, 'component': item, 'augment': item}}
        header: CSV header

    Returns:
        List of tuples: [(source_name, value), ...] sorted by value descending
    """
    sources = []
    total_comp_value = 0
    total_aug_value = 0

    for slot, gear_set in gear_dict.items():
        # Base gear contribution
        base_item = gear_set.get('base')
        if base_item and stat_name in header:
            try:
                base_value = float(base_item.get(stat_name, 0) or 0)
                if base_value > 0:
                    sources.append((slot, base_value))
            except (ValueError, TypeError):
                pass

        # Component contribution (aggregate all components)
        component = gear_set.get('component')
        if component and stat_name in header:
            try:
                comp_value = float(component.get(stat_name, 0) or 0)
                if comp_value > 0:
                    total_comp_value += comp_value
            except (ValueError, TypeError):
                pass

        # Augment contribution (aggregate all augments)
        augment = gear_set.get('augment')
        if augment and stat_name in header:
            try:
                aug_value = float(augment.get(stat_name, 0) or 0)
                if aug_value > 0:
                    total_aug_value += aug_value
            except (ValueError, TypeError):
                pass

    # Add aggregated component/augment values
    if total_comp_value > 0:
        sources.append(('comp', total_comp_value))
    if total_aug_value > 0:
        sources.append(('aug', total_aug_value))

    # Sort by value descending
    sources.sort(key=lambda x: x[1], reverse=True)

    return sources


def format_sources_column(sources, max_width=60):
    """Format sources list as a string, fitting within max_width.

    Args:
        sources: List of (source_name, value) tuples
        max_width: Maximum character width

    Returns:
        String like "helm(25), chest(20), boots(15), comp(12), aug(8)"
    """
    if not sources:
        return ""

    formatted = []
    for source_name, value in sources:
        formatted.append(f"{source_name}({int(value)})")

    result = ", ".join(formatted)

    # If too long, truncate and add "+N"
    if len(result) > max_width:
        # Fit as many items as possible, reserving exact space needed for "+N"
        truncated = []
        current_length = 0

        for i, item in enumerate(formatted):
            remaining_count = len(formatted) - i
            suffix = f", +{remaining_count}" if remaining_count > 0 else ""
            suffix_len = len(suffix)

            # Can we fit this item plus the suffix?
            if current_length == 0:  # First item, no leading ", "
                needed = len(item) + suffix_len
            else:
                needed = current_length + 2 + len(item) + suffix_len  # +2 for ", "

            if needed <= max_width:
                truncated.append(item)
                if current_length == 0:
                    current_length = len(item)
                else:
                    current_length += 2 + len(item)
            else:
                # Can't fit this item, add suffix for remaining items
                remaining_count = len(formatted) - len(truncated)
                if remaining_count > 0:
                    result = ", ".join(truncated) + f", +{remaining_count}"
                else:
                    result = ", ".join(truncated)
                break
        else:
            # All items fit
            result = ", ".join(truncated)

    return result


def _combine_items(base_item, component, augment, header, gear_type):
    """Combines base item with component and/or augment, summing their stats.

    Used by genetic algorithm for display purposes only.
    """
    virtual_item = {}

    # Start with base item
    for key in header:
        virtual_item[key] = base_item.get(key, '')

    # Add component stats
    if component:
        for key in header:
            if key in ['tf', 'type', 'name', 'applies_to']:
                continue
            try:
                base_val = float(base_item.get(key, 0) or 0)
                comp_val = float(component.get(key, 0) or 0)
                if base_val != 0 or comp_val != 0:
                    virtual_item[key] = base_val + comp_val
            except (ValueError, TypeError):
                pass

    # Add augment stats
    if augment:
        for key in header:
            if key in ['tf', 'type', 'name', 'applies_to']:
                continue
            try:
                current_val = float(virtual_item.get(key, 0) or 0)
                aug_val = float(augment.get(key, 0) or 0)
                if current_val != 0 or aug_val != 0:
                    virtual_item[key] = current_val + aug_val
            except (ValueError, TypeError):
                pass

    # Set metadata
    virtual_item['type'] = gear_type
    virtual_item['component'] = component['name'] if component else None
    virtual_item['augment'] = augment['name'] if augment else None

    # Create a display name that shows the combination
    parts = [base_item['name']]
    if component:
        parts.append(f"[{component['name']}]")
    if augment:
        parts.append(f"<{augment['name']}>")
    virtual_item['display_name'] = ' '.join(parts)

    return virtual_item


def calculate_and_display_combinations(data, verbose=False):
    """Calculates and displays the number of items and total combinations.

    Returns the total number of combinations.
    """
    header = data[0]
    gear_data = data[4:]

    gear_by_type = {}
    components = []
    augments = []

    try:
        type_idx = header.index('type')
        applies_to_idx = header.index('applies_to') if 'applies_to' in header else -1
    except ValueError as e:
        print(f"Missing required column in CSV: {e}")
        return 0

    for row in gear_data:
        if not any(row):
            continue
        item_type = row[type_idx]
        if not item_type:
            continue
        gear_item = {header[i]: row[i] for i in range(len(row))}
        item_type_normalized = normalize_item_type(item_type)
        if item_type_normalized == 'component':
            components.append(gear_item)
        elif item_type_normalized == 'augment':
            augments.append(gear_item)
        else:
            if item_type not in gear_by_type:
                gear_by_type[item_type] = []
            gear_by_type[item_type].append(gear_item)

    # Pre-normalize and expand applies_to for components and augments (avoid repeated work in loop)
    for comp in components:
        comp['_normalized_applies_to'] = expand_applies_to(comp.get('applies_to', ''))

    for aug in augments:
        aug['_normalized_applies_to'] = expand_applies_to(aug.get('applies_to', ''))

    # Handle rings - split into Ring 1 and Ring 2
    if 'ring' in gear_by_type:
        rings = gear_by_type.pop('ring')
        gear_by_type['Ring 1'] = rings
        gear_by_type['Ring 2'] = rings

    total_combinations = 1
    total_gear_pieces = 0

    gear_slots = sorted(gear_by_type.keys())

    for slot in gear_slots:
        num_gear = len(gear_by_type[slot])
        total_gear_pieces += num_gear
        slot_normalized = normalize_slot_name(slot)

        num_components = 0
        if applies_to_idx != -1:
            for comp in components:
                applies_to_list = comp['_normalized_applies_to']
                # Direct match (multi-slot types like 'armor' and 'ring' already expanded during parsing)
                if slot_normalized in applies_to_list:
                    num_components += 1

        num_augments = 0
        if applies_to_idx != -1:
            for aug in augments:
                applies_to_list = aug['_normalized_applies_to']
                # Direct match (multi-slot types like 'armor' and 'ring' already expanded during parsing)
                if slot_normalized in applies_to_list:
                    num_augments += 1

        calc_num_components = num_components + 1 if num_components > 0 else 1  # +1 for no component
        calc_num_augments = num_augments + 1 if num_augments > 0 else 1  # +1 for no augment
        slot_combinations = num_gear * calc_num_components * calc_num_augments
        total_combinations *= slot_combinations

        if verbose:
            if slot == gear_slots[0]:  # Print header only for the first item
                print("--- Item Counts and Combinations ---")
            print(f"{slot}: {num_gear} gear * {calc_num_components} component options * {calc_num_augments} augment options = {slot_combinations} choices")

    if verbose:
        print(f"\nTotal possible combinations: {total_combinations:,}")
        print("-" * 36 + "\n")
    else:
        print(f"{total_gear_pieces} gear pieces, {len(components)} components, {len(augments)} augments. Total combinations: {total_combinations:,}")

    return total_combinations


def create_random_individual(gear_by_type, components_by_slot, augments_by_slot, gear_slots, locked_items_by_slot=None):
    """Creates a random individual with separate base/component/augment genes.

    Args:
        gear_by_type: Dictionary of gear items by type
        components_by_slot: Dictionary of components by slot
        augments_by_slot: Dictionary of augments by slot
        gear_slots: List of gear slot names
        locked_items_by_slot: Optional dict of {slot: {'base': item, 'component': item, 'augment': item}} for locked items
    """
    individual = {}
    selected_ring_name = None

    for slot in gear_slots:
        # Check if this slot has locked items
        has_locked_base = locked_items_by_slot and locked_items_by_slot.get(slot, {}).get('base') is not None
        has_locked_component = locked_items_by_slot and locked_items_by_slot.get(slot, {}).get('component') is not None
        has_locked_augment = locked_items_by_slot and locked_items_by_slot.get(slot, {}).get('augment') is not None

        # Select base item (locked or random)
        if has_locked_base:
            base_item = locked_items_by_slot[slot]['base']
        else:
            base_candidates = gear_by_type[slot]

            # For ring 2, avoid selecting the same ring as ring 1
            if slot == 'ring 2' and selected_ring_name:
                base_candidates = [item for item in base_candidates if item['name'] != selected_ring_name]

            if base_candidates:
                base_item = random.choice(base_candidates)
            else:
                continue

        # Select component (locked or random)
        if has_locked_component:
            component = locked_items_by_slot[slot]['component']
        else:
            component = None
            if slot in components_by_slot and components_by_slot[slot]:
                # 50% chance to add a component if available
                if random.random() < 0.5:
                    component = random.choice(components_by_slot[slot])

        # Select augment (locked or random)
        if has_locked_augment:
            augment = locked_items_by_slot[slot]['augment']
        else:
            augment = None
            if slot in augments_by_slot and augments_by_slot[slot]:
                # 50% chance to add an augment if available
                if random.random() < 0.5:
                    augment = random.choice(augments_by_slot[slot])

        individual[slot] = {
            'base': base_item,
            'component': component,
            'augment': augment
        }

        if slot == 'ring 1':
            selected_ring_name = base_item['name']

    return individual


def calculate_fitness(individual, gear_slots, header, points_per_unit, max_points, baseline):
    """Calculates the capped benefit score for an individual with multi-gene representation."""
    total_stats = {stat: 0.0 for stat in header}

    # Accumulate stats from all equipped items (base + component + augment)
    for slot in gear_slots:
        if slot in individual:
            slot_data = individual[slot]

            # Add base item stats
            base_item = slot_data['base']
            for stat, value in base_item.get('stats', {}).items():
                total_stats[stat] += value

            # Add component stats if present
            if slot_data['component']:
                for stat, value in slot_data['component'].get('stats', {}).items():
                    total_stats[stat] += value

            # Add augment stats if present
            if slot_data['augment']:
                for stat, value in slot_data['augment'].get('stats', {}).items():
                    total_stats[stat] += value

    # Calculate capped benefit (baseline is added before capping, but only gear contribution is scored)
    total_benefit = 0
    for stat, value in total_stats.items():
        if stat in points_per_unit:
            baseline_val = baseline.get(stat, 0)
            max_val = max_points.get(stat, float('inf'))

            # Calculate capped values
            capped_total = min(value + baseline_val, max_val)
            capped_baseline = min(baseline_val, max_val)

            # Award points only for the marginal contribution from gear
            gear_contribution = capped_total - capped_baseline
            total_benefit += gear_contribution * points_per_unit[stat]

    return total_benefit


def tournament_selection(population, fitnesses, tournament_size=5):
    """Selects an individual using tournament selection."""
    tournament_indices = random.sample(range(len(population)), min(tournament_size, len(population)))
    tournament_fitnesses = [fitnesses[i] for i in tournament_indices]
    winner_idx = tournament_indices[tournament_fitnesses.index(max(tournament_fitnesses))]
    return population[winner_idx]


def crossover(parent1, parent2, gear_slots, crossover_rate=0.7):
    """Performs multi-gene crossover between two parents.

    Can mix base, component, and augment genes independently from different parents.
    """
    if random.random() > crossover_rate:
        # No crossover, return deep copy of parent1
        child = {}
        for slot in gear_slots:
            if slot in parent1:
                child[slot] = {
                    'base': parent1[slot]['base'],
                    'component': parent1[slot]['component'],
                    'augment': parent1[slot]['augment']
                }
        return child

    child = {}
    for slot in gear_slots:
        if slot not in parent1 or slot not in parent2:
            # If slot missing from either parent, copy from parent1
            if slot in parent1:
                child[slot] = {
                    'base': parent1[slot]['base'],
                    'component': parent1[slot]['component'],
                    'augment': parent1[slot]['augment']
                }
            continue

        # For each gene (base, component, augment), randomly pick from parent1 or parent2
        child[slot] = {
            'base': parent1[slot]['base'] if random.random() < 0.5 else parent2[slot]['base'],
            'component': parent1[slot]['component'] if random.random() < 0.5 else parent2[slot]['component'],
            'augment': parent1[slot]['augment'] if random.random() < 0.5 else parent2[slot]['augment']
        }

    # Ensure no duplicate rings
    if 'ring 1' in child and 'ring 2' in child:
        if child['ring 1']['base']['name'] == child['ring 2']['base']['name']:
            # Replace ring 2 base with parent's ring 2 base if different
            if 'ring 2' in parent2 and parent2['ring 2']['base']['name'] != child['ring 1']['base']['name']:
                child['ring 2']['base'] = parent2['ring 2']['base']
            elif 'ring 2' in parent1 and parent1['ring 2']['base']['name'] != child['ring 1']['base']['name']:
                child['ring 2']['base'] = parent1['ring 2']['base']

    return child


def mutate(individual, gear_by_type, components_by_slot, augments_by_slot, gear_slots, mutation_rate=0.15, locked_items_by_slot=None):
    """Mutates individual genes (base, component, or augment) independently.

    Args:
        individual: Individual to mutate
        gear_by_type: Dictionary of gear items by type
        components_by_slot: Dictionary of components by slot
        augments_by_slot: Dictionary of augments by slot
        gear_slots: List of gear slot names
        mutation_rate: Probability of mutation for each gene
        locked_items_by_slot: Optional dict of locked items that should not be mutated
    """
    mutated = {}

    # Deep copy the individual
    for slot in gear_slots:
        if slot in individual:
            mutated[slot] = {
                'base': individual[slot]['base'],
                'component': individual[slot]['component'],
                'augment': individual[slot]['augment']
            }

    for slot in gear_slots:
        if slot not in mutated:
            continue

        # Check if this slot has locked items
        has_locked_base = locked_items_by_slot and locked_items_by_slot.get(slot, {}).get('base') is not None
        has_locked_component = locked_items_by_slot and locked_items_by_slot.get(slot, {}).get('component') is not None
        has_locked_augment = locked_items_by_slot and locked_items_by_slot.get(slot, {}).get('augment') is not None

        # Mutate base item (skip if locked)
        if not has_locked_base and random.random() < mutation_rate:
            candidates = gear_by_type[slot]

            # For ring 2, avoid selecting the same ring as ring 1
            if slot == 'ring 2' and 'ring 1' in mutated:
                ring1_name = mutated['ring 1']['base']['name']
                candidates = [item for item in candidates if item['name'] != ring1_name]

            # For ring 1, avoid selecting the same ring as ring 2
            if slot == 'ring 1' and 'ring 2' in mutated:
                ring2_name = mutated['ring 2']['base']['name']
                candidates = [item for item in candidates if item['name'] != ring2_name]

            if candidates:
                mutated[slot]['base'] = random.choice(candidates)

        # Mutate component (skip if locked)
        if not has_locked_component and random.random() < mutation_rate:
            if slot in components_by_slot and components_by_slot[slot]:
                # 50% chance to have a component, 50% chance to have none
                if random.random() < 0.5:
                    mutated[slot]['component'] = random.choice(components_by_slot[slot])
                else:
                    mutated[slot]['component'] = None
            else:
                mutated[slot]['component'] = None

        # Mutate augment (skip if locked)
        if not has_locked_augment and random.random() < mutation_rate:
            if slot in augments_by_slot and augments_by_slot[slot]:
                # 50% chance to have an augment, 50% chance to have none
                if random.random() < 0.5:
                    mutated[slot]['augment'] = random.choice(augments_by_slot[slot])
                else:
                    mutated[slot]['augment'] = None
            else:
                mutated[slot]['augment'] = None

    return mutated


def evolve_island(island_id, population, gear_by_type, components_by_slot, augments_by_slot,
                  gear_slots, header, points_per_unit, max_points, baseline, time_limit,
                  migration_queue, result_queue, status_queue, verbose, shared_interrupted, locked_items_by_slot=None):
    """Worker function that evolves a single island population.

    Args:
        island_id: Unique identifier for this island
        population: Initial population for this island
        gear_by_type: Dictionary of gear items by type
        components_by_slot: Dictionary of components by slot
        augments_by_slot: Dictionary of augments by slot
        gear_slots: List of gear slot names
        header: CSV header row
        points_per_unit: Benefit points per stat unit
        max_points: Maximum benefit caps per stat
        baseline: Baseline stat values from skills/difficulty
        time_limit: Time limit in seconds
        migration_queue: Queue for receiving migrants from other islands
        result_queue: Queue for sending final results
        status_queue: Queue for sending periodic status updates
        verbose: Whether to print progress
        shared_interrupted: Shared Value for interrupt flag
        locked_items_by_slot: Optional dict of locked items that should not be mutated
    """
    # Child processes should ignore SIGINT - only parent handles it
    signal.signal(signal.SIGINT, signal.SIG_IGN)
    mutation_rate = 0.15
    crossover_rate = 0.7
    population_size = len(population)
    elitism_count = max(1, int(population_size * 0.1))
    tournament_size = 5
    migration_size = max(1, int(population_size * 0.05))  # Migrate top 5%

    start_time = time.time()
    generation = 0
    evaluations = 0
    all_time_best = []

    while time.time() - start_time < time_limit and not shared_interrupted.value:
        generation += 1

        # Evaluate fitness
        fitnesses = []
        for individual in population:
            fitness = calculate_fitness(individual, gear_slots, header, points_per_unit, max_points, baseline)
            fitnesses.append(fitness)
            evaluations += 1

        # Track best individuals
        sorted_indices = sorted(range(len(population)), key=lambda i: fitnesses[i], reverse=True)
        best_fitness = fitnesses[sorted_indices[0]]
        all_time_best.append((best_fitness, population[sorted_indices[0]]))

        # Send status update to coordinator
        status_queue.put(('status', island_id, best_fitness, generation, evaluations))

        if verbose and generation % 20 == 0:
            avg_fitness = sum(fitnesses) / len(fitnesses)
            print(f"Island {island_id} Gen {generation}: Best={best_fitness:.1f}, Avg={avg_fitness:.1f}")

        # Check for migration signal from coordinator (non-blocking)
        try:
            msg = migration_queue.get_nowait()
            if msg == 'MIGRATE':
                # Send best individuals to coordinator
                migrants = [population[sorted_indices[i]] for i in range(migration_size)]
                result_queue.put(('migration', island_id, migrants))
            elif isinstance(msg, list):
                # Received incoming migrants - replace worst individuals
                for i, migrant in enumerate(msg):
                    if i < len(sorted_indices):
                        worst_idx = sorted_indices[-(i+1)]
                        population[worst_idx] = migrant
        except:
            pass  # No migration signal yet

        # Sort population by fitness
        sorted_population = [population[i] for i in sorted_indices]
        sorted_fitnesses = [fitnesses[i] for i in sorted_indices]

        # Create next generation
        next_generation = []

        # Elitism: keep top individuals
        next_generation.extend(sorted_population[:elitism_count])

        # Generate offspring
        while len(next_generation) < population_size:
            parent1 = tournament_selection(population, fitnesses, tournament_size)
            parent2 = tournament_selection(population, fitnesses, tournament_size)

            child = crossover(parent1, parent2, gear_slots, crossover_rate)
            child = mutate(child, gear_by_type, components_by_slot, augments_by_slot, gear_slots, mutation_rate, locked_items_by_slot)

            next_generation.append(child)

        population = next_generation

    # Final evaluation
    final_fitnesses = []
    for individual in population:
        fitness = calculate_fitness(individual, gear_slots, header, points_per_unit, max_points, baseline)
        final_fitnesses.append(fitness)
        evaluations += 1

    # Send final results
    result_queue.put(('final', island_id, population, final_fitnesses, all_time_best, evaluations, generation))


def solve_gear_genetic(data, time_limit=5.0, top_n=5, verbose=False, parallel=False):
    """Solves the gear selection problem using a genetic algorithm with multi-gene representation.

    Args:
        data: CSV data containing gear, stats, and weights
        time_limit: Time limit in seconds
        top_n: Number of top builds to return
        verbose: Print detailed progress
        parallel: Use multi-core island model parallelization
    """
    header = data[0]

    # Find configuration rows by name (not position) - scan first 5 rows after header
    name_col_idx = header.index('name') if 'name' in header else None
    points_per_unit_row = None
    max_points_row = None
    baseline_row = None
    config_row_indices = set()

    if name_col_idx is not None:
        for i in range(1, min(6, len(data))):  # Check rows 1-5
            row_name = data[i][name_col_idx].lower().strip() if name_col_idx < len(data[i]) else ''
            if row_name in ['points per unit', 'weight']:
                points_per_unit_row = data[i]
                config_row_indices.add(i)
            elif row_name == 'max points':
                max_points_row = data[i]
                config_row_indices.add(i)
            elif row_name == 'baseline':
                baseline_row = data[i]
                config_row_indices.add(i)

    # Parse configuration rows (with fallbacks if not found)
    points_per_unit = parse_row_float(points_per_unit_row, header, default_value=0) if points_per_unit_row else {stat: 0 for stat in header}
    max_points = parse_row_float(max_points_row, header, default_value=float('inf')) if max_points_row else {stat: float('inf') for stat in header}
    baseline = parse_row_float(baseline_row, header, default_value=0) if baseline_row else {stat: 0 for stat in header}

    # Filter out metadata columns (those with zero or negative weights in points_per_unit)
    # This excludes columns like 'tf' (weight=-1 for sorting), 'type', 'name', etc. (weight=0)
    # from being treated as stats in benefit calculations
    points_per_unit = {stat: weight for stat, weight in points_per_unit.items() if weight > 0}
    max_points = {stat: max_points[stat] for stat in points_per_unit}
    baseline = {stat: baseline[stat] for stat in points_per_unit}

    # Gear data is everything after row 5, plus any non-config rows in rows 1-5
    gear_data = []
    for i in range(1, len(data)):
        if i < 6:  # Rows 1-5: only include non-config rows
            if i not in config_row_indices:
                gear_data.append(data[i])
        else:  # Row 6+: include everything
            gear_data.append(data[i])

    # Group gear by type, and separate components/augments
    gear_by_type = {}
    components = []
    augments = []
    locked_items = []  # Track locked items for display

    for row in gear_data:
        if not any(row) or not row[1]:
            continue
        gear_item = {header[i]: row[i] for i in range(len(row))}

        # Check for locked gear (items with * prefix in name)
        item_name = gear_item.get('name', '')
        if item_name.startswith('*'):
            gear_item['_locked'] = True
            locked_items.append((item_name, gear_item.get('type', 'unknown')))  # Keep * for display
            # Keep the * in the name for display purposes
        else:
            gear_item['_locked'] = False

        gear_type = gear_item['type']
        gear_type_normalized = normalize_item_type(gear_type)

        if gear_type_normalized == 'component':
            components.append(gear_item)
        elif gear_type_normalized == 'augment':
            augments.append(gear_item)
        else:
            if gear_type not in gear_by_type:
                gear_by_type[gear_type] = []
            gear_by_type[gear_type].append(gear_item)

    # Handle rings
    if 'ring' in gear_by_type:
        rings = gear_by_type.pop('ring')
        gear_by_type['ring 1'] = rings
        gear_by_type['ring 2'] = rings

    # Parse stats for base gear items
    for gear_type, gear_list in gear_by_type.items():
        for gear_item in gear_list:
            stats = {stat: 0.0 for stat in header}
            for stat, value in gear_item.items():
                if stat in points_per_unit and value:
                    try:
                        stat_value = float(value)
                        stats[stat] = stat_value
                    except (ValueError, TypeError):
                        pass
            gear_item['stats'] = stats

    # Parse stats for components and augments, and pre-normalize applies_to field
    for component in components:
        stats = {stat: 0.0 for stat in header}
        for stat, value in component.items():
            if stat in points_per_unit and value:
                try:
                    stat_value = float(value)
                    stats[stat] = stat_value
                except (ValueError, TypeError):
                    pass
        component['stats'] = stats

        # Pre-normalize and expand applies_to field to avoid repeated work later
        component['_normalized_applies_to'] = expand_applies_to(component.get('applies_to', ''))

    for augment in augments:
        stats = {stat: 0.0 for stat in header}
        for stat, value in augment.items():
            if stat in points_per_unit and value:
                try:
                    stat_value = float(value)
                    stats[stat] = stat_value
                except (ValueError, TypeError):
                    pass
        augment['stats'] = stats

        # Pre-normalize and expand applies_to field to avoid repeated work later
        augment['_normalized_applies_to'] = expand_applies_to(augment.get('applies_to', ''))

    # Build components_by_slot and augments_by_slot dictionaries
    components_by_slot = {}
    augments_by_slot = {}

    gear_slots = sorted(gear_by_type.keys())

    for slot in gear_slots:
        slot_normalized = normalize_slot_name(slot)

        components_by_slot[slot] = []
        for comp in components:
            applies_to_list = comp['_normalized_applies_to']
            # Direct match (multi-slot types like 'armor' and 'ring' already expanded during parsing)
            if slot_normalized in applies_to_list:
                components_by_slot[slot].append(comp)

        augments_by_slot[slot] = []
        for aug in augments:
            applies_to_list = aug['_normalized_applies_to']
            # Direct match (multi-slot types like 'armor' and 'ring' already expanded during parsing)
            if slot_normalized in applies_to_list:
                augments_by_slot[slot].append(aug)

    # Build locked_items_by_slot dictionary
    locked_items_by_slot = {}
    for slot in gear_slots:
        locked_items_by_slot[slot] = {
            'base': None,
            'component': None,
            'augment': None
        }

        # Find locked base item for this slot
        for item in gear_by_type[slot]:
            if item.get('_locked', False):
                if locked_items_by_slot[slot]['base'] is not None:
                    print(f"Warning: Multiple locked items found for slot '{slot}'. Only the first one will be used.")
                    print(f"  First: {locked_items_by_slot[slot]['base']['name']}")
                    print(f"  Second: {item['name']}")
                else:
                    locked_items_by_slot[slot]['base'] = item

        # Find locked component for this slot
        if slot in components_by_slot:
            for comp in components_by_slot[slot]:
                if comp.get('_locked', False):
                    if locked_items_by_slot[slot]['component'] is not None:
                        print(f"Warning: Multiple locked components found for slot '{slot}'. Only the first one will be used.")
                    else:
                        locked_items_by_slot[slot]['component'] = comp

        # Find locked augment for this slot
        if slot in augments_by_slot:
            for aug in augments_by_slot[slot]:
                if aug.get('_locked', False):
                    if locked_items_by_slot[slot]['augment'] is not None:
                        print(f"Warning: Multiple locked augments found for slot '{slot}'. Only the first one will be used.")
                    else:
                        locked_items_by_slot[slot]['augment'] = aug

    # Check for components/augments with empty or unknown applies_to types
    known_types = set(normalize_slot_name(slot) for slot in gear_slots) | set(MULTI_SLOT_TYPES.keys())  # Include multi-slot types (ring, armor, etc.)

    for comp in components:
        # Check for empty applies_to field
        if not comp['_normalized_applies_to']:
            print(f"Warning: Component '{comp.get('name', 'unknown')}' has empty or missing applies_to field. This component will not be used in any slot.")
            continue  # Skip checking for unknown types if empty

        # Check for unknown applies_to types
        for normalized in comp['_normalized_applies_to']:
            # Check if this normalized type doesn't match any slot
            if normalized not in known_types:
                print(f"Warning: Component '{comp.get('name', 'unknown')}' has unknown applies_to type (normalized to '{normalized}'). This component may not be used correctly.")

    for aug in augments:
        # Check for empty applies_to field
        if not aug['_normalized_applies_to']:
            print(f"Warning: Augment '{aug.get('name', 'unknown')}' has empty or missing applies_to field. This augment will not be used in any slot.")
            continue  # Skip checking for unknown types if empty

        # Check for unknown applies_to types
        for normalized in aug['_normalized_applies_to']:
            # Check if this normalized type doesn't match any slot
            if normalized not in known_types:
                print(f"Warning: Augment '{aug.get('name', 'unknown')}' has unknown applies_to type (normalized to '{normalized}'). This augment may not be used correctly.")

    # Display locked items message
    if locked_items:
        print(f"\nLocked items detected ({len(locked_items)} items will be forced into all builds):")
        for item_name, item_type in locked_items:
            print(f"  {item_type}: {item_name}")
        print()

    # Genetic algorithm parameters
    num_cores = multiprocessing.cpu_count()
    population_size_per_core = 150
    total_population_size = population_size_per_core * num_cores
    mutation_rate = 0.15
    crossover_rate = 0.7
    elitism_count = max(1, int(total_population_size * 0.1))
    tournament_size = 5

    if parallel:
        # Multi-core island model
        num_islands = num_cores
        island_population_size = population_size_per_core
        progress_check_interval = 2.0  # Check progress every 2 seconds

        if verbose:
            print(f"Island Model Genetic Algorithm Parameters:")
            print(f"  Islands (cores): {num_islands}")
            print(f"  Population per island: {island_population_size}")
            print(f"  Total population: {num_islands * island_population_size}")
            print(f"  Progress check interval: {progress_check_interval}s")
            print(f"  Mutation rate: {mutation_rate}")
            print(f"  Crossover rate: {crossover_rate}")
            time_limit_str = f"{time_limit}s" if time_limit != float('inf') else "unlimited (auto-stop on plateau)"
            print(f"  Time limit: {time_limit_str}")
            print()

        # Create initial populations for each island
        island_populations = []
        for i in range(num_islands):
            island_pop = [create_random_individual(gear_by_type, components_by_slot, augments_by_slot, gear_slots, locked_items_by_slot)
                         for _ in range(island_population_size)]
            island_populations.append(island_pop)

        # Create queues for migration, results, and status
        from multiprocessing import Process, Queue, Value
        migration_queues = [Queue() for _ in range(num_islands)]
        result_queue = Queue()
        status_queue = Queue()
        shared_interrupted = Value('b', False)  # Shared boolean for interrupt flag

        # Start island processes
        processes = []
        start_time = time.time()

        for i in range(num_islands):
            p = Process(target=evolve_island,
                       args=(i, island_populations[i], gear_by_type, components_by_slot,
                            augments_by_slot, gear_slots, header, points_per_unit, max_points, baseline,
                            time_limit, migration_queues[i], result_queue, status_queue, verbose, shared_interrupted, locked_items_by_slot))
            p.start()
            processes.append(p)

        # Coordinate migration between islands (ring topology) and monitor progress
        migration_buffer = {}
        final_results = {}
        evaluations = 0
        last_check_time = start_time
        last_best_score = 0
        island_status = {}  # Track latest status from each island

        while any(p.is_alive() for p in processes):
            current_time = time.time()

            # Process status updates (limit to avoid getting stuck in loop)
            status_updates_processed = 0
            while status_updates_processed < 100:  # Process at most 100 status messages per iteration
                try:
                    msg = status_queue.get_nowait()  # Non-blocking
                    if msg[0] == 'status':
                        island_id, best_fitness, generation, island_evals = msg[1:]
                        island_status[island_id] = {
                            'best_fitness': best_fitness,
                            'generation': generation,
                            'evaluations': island_evals
                        }
                    status_updates_processed += 1
                except:
                    break  # No more status messages available

            # Check for migration or final results
            try:
                msg = result_queue.get(timeout=0.001)  # Shorter timeout

                if msg[0] == 'migration':
                    island_id, migrants = msg[1], msg[2]
                    migration_buffer[island_id] = migrants

                    # If we have migrants from all islands, redistribute in ring pattern
                    if len(migration_buffer) == num_islands:
                        for i in range(num_islands):
                            next_island = (i + 1) % num_islands
                            if i in migration_buffer:
                                migration_queues[next_island].put(migration_buffer[i])
                        migration_buffer.clear()

                elif msg[0] == 'final':
                    island_id, population, fitnesses, all_time_best, island_evals, generations = msg[1:]
                    final_results[island_id] = (population, fitnesses, all_time_best, island_evals, generations)

            except:
                pass  # Timeout, continue waiting

            # Check if it's time for progress update and migration
            if current_time - last_check_time >= progress_check_interval:
                # Get current best score across all islands
                if island_status:
                    current_best = max(status['best_fitness'] for status in island_status.values())
                    total_evals = sum(status['evaluations'] for status in island_status.values())
                    avg_generation = sum(status['generation'] for status in island_status.values()) / len(island_status)

                    # Print progress update
                    elapsed = current_time - start_time
                    evals_per_sec = total_evals / elapsed if elapsed > 0 else 0
                    print(f"[{elapsed:.1f}s] Best: {current_best:.0f} pts | Gen {avg_generation:.0f} | {evals_per_sec/1000:.0f}k evals/s")

                    # Check for improvement or interrupt
                    if current_best <= last_best_score:
                        # No improvement - signal all islands to stop
                        print(f"No improvement after {progress_check_interval:.0f}s plateau. Terminating search.")
                        shared_interrupted.value = True
                        # Don't break yet - wait for final results
                    elif interrupted:
                        # User interrupted - signal all islands to stop gracefully
                        print("Terminating search at end of current cycle...")
                        shared_interrupted.value = True
                        # Don't break yet - wait for final results

                    # Trigger migration across all islands
                    for queue in migration_queues:
                        queue.put('MIGRATE')

                    last_best_score = current_best

                last_check_time = current_time

        # Wait for all processes to finish
        for p in processes:
            p.join()

        elapsed_time = time.time() - start_time

        # Combine results from all islands
        all_populations = []
        all_fitnesses = []
        all_time_best_individuals = []

        for island_id in range(num_islands):
            if island_id in final_results:
                population, fitnesses, all_time_best, island_evals, generations = final_results[island_id]
                all_populations.extend(population)
                all_fitnesses.extend(fitnesses)
                all_time_best_individuals.extend(all_time_best)
                evaluations += island_evals

                if verbose:
                    print(f"Island {island_id} completed {generations} generations with {island_evals:,} evaluations")

        population = all_populations
        final_fitnesses = all_fitnesses
        generation = max((final_results[i][4] for i in range(num_islands) if i in final_results), default=0)

    else:
        # Single-core mode (original algorithm)
        progress_check_interval = 2.0  # Check progress every 2 seconds

        if verbose:
            print(f"Genetic Algorithm Parameters:")
            print(f"  Cores: {num_cores}")
            print(f"  Population size: {total_population_size} ({population_size_per_core} per core)")
            print(f"  Mutation rate: {mutation_rate}")
            print(f"  Crossover rate: {crossover_rate}")
            print(f"  Elitism: {elitism_count} individuals")
            time_limit_str = f"{time_limit}s" if time_limit != float('inf') else "unlimited (auto-stop on plateau)"
            print(f"  Time limit: {time_limit_str}")
            print(f"  Progress check interval: {progress_check_interval}s")
            print()

        # Initialize population
        population = [create_random_individual(gear_by_type, components_by_slot, augments_by_slot, gear_slots, locked_items_by_slot) for _ in range(total_population_size)]

        start_time = time.time()
        generation = 0
        evaluations = 0
        last_check_time = start_time
        last_best_score = 0

        # Track best individuals across all generations
        all_time_best_individuals = []

        while time.time() - start_time < time_limit:
            # Check for interrupt
            if interrupted:
                break

            generation += 1

            # Evaluate fitness
            fitnesses = []
            for individual in population:
                fitness = calculate_fitness(individual, gear_slots, header, points_per_unit, max_points, baseline)
                fitnesses.append(fitness)
                evaluations += 1

            # Track best individuals
            sorted_indices = sorted(range(len(population)), key=lambda i: fitnesses[i], reverse=True)
            for i in range(min(top_n, len(sorted_indices))):
                idx = sorted_indices[i]
                all_time_best_individuals.append((fitnesses[idx], population[idx].copy()))

            current_best = max(fitnesses)

            if verbose and generation % 10 == 0:
                avg_fitness = sum(fitnesses) / len(fitnesses)
                print(f"Generation {generation}: Best={current_best:.1f}, Avg={avg_fitness:.1f}")

            # Check if it's time for progress update
            current_time = time.time()
            if current_time - last_check_time >= progress_check_interval:
                elapsed = current_time - start_time
                evals_per_sec = evaluations / elapsed if elapsed > 0 else 0
                print(f"[{elapsed:.1f}s] Best: {current_best:.0f} pts | Gen {generation} | {evals_per_sec/1000:.0f}k evals/s")

                # Check for improvement
                if current_best <= last_best_score:
                    print(f"No improvement after {progress_check_interval:.0f}s plateau. Terminating search.")
                    break

                last_best_score = current_best
                last_check_time = current_time

            # Sort population by fitness
            sorted_population = [population[i] for i in sorted_indices]
            sorted_fitnesses = [fitnesses[i] for i in sorted_indices]

            # Create next generation
            next_generation = []

            # Elitism: keep top individuals
            next_generation.extend(sorted_population[:elitism_count])

            # Generate offspring
            while len(next_generation) < total_population_size:
                parent1 = tournament_selection(population, fitnesses, tournament_size)
                parent2 = tournament_selection(population, fitnesses, tournament_size)

                child = crossover(parent1, parent2, gear_slots, crossover_rate)
                child = mutate(child, gear_by_type, components_by_slot, augments_by_slot, gear_slots, mutation_rate, locked_items_by_slot)

                next_generation.append(child)

            population = next_generation

        # Final evaluation and select top N diverse builds
        final_fitnesses = []
        for individual in population:
            fitness = calculate_fitness(individual, gear_slots, header, points_per_unit, max_points, baseline)
            final_fitnesses.append(fitness)
            evaluations += 1

    # Combine all-time best with final population (for both modes)
    for fitness, individual in all_time_best_individuals:
        population.append(individual)
        final_fitnesses.append(fitness)

    # Sort by fitness
    sorted_indices = sorted(range(len(population)), key=lambda i: final_fitnesses[i], reverse=True)

    # Select top N diverse builds
    top_builds = []
    for idx in sorted_indices:
        if len(top_builds) >= top_n:
            break

        individual = population[idx]
        fitness = final_fitnesses[idx]

        # Check if this build is sufficiently different from existing top builds
        is_diverse = True
        for existing_fitness, existing_individual in top_builds:
            # Count how many base items are the same (ignoring component/augment differences)
            same_items = sum(1 for slot in gear_slots
                           if slot in individual and slot in existing_individual
                           and individual[slot]['base']['name'] == existing_individual[slot]['base']['name'])

            # If too similar (>80% same base items), skip
            if same_items > len(gear_slots) * 0.8:
                is_diverse = False
                break

        if is_diverse or len(top_builds) == 0:
            top_builds.append((fitness, individual))

    if verbose:
        print(f"\nCompleted {generation} generations")
        print(f"Total evaluations: {evaluations:,}")

    # Convert top builds to the expected format (create virtual items for display)
    best_combination = []
    for slot in gear_slots:
        if slot in top_builds[0][1]:
            slot_data = top_builds[0][1][slot]
            base_item = slot_data['base']
            component = slot_data['component']
            augment = slot_data['augment']

            # Combine base + component + augment into a virtual item
            virtual_item = _combine_items(base_item, component, augment, header, slot)
            virtual_item['type'] = slot

            # Calculate stats for the virtual item
            stats = {stat: 0.0 for stat in header}
            for stat, value in virtual_item.items():
                if stat in points_per_unit and value:
                    try:
                        stat_value = float(value)
                        stats[stat] = stat_value
                    except (ValueError, TypeError):
                        pass
            virtual_item['stats'] = stats

            # Calculate individual item benefit for display
            item_benefit = 0
            for stat, value in stats.items():
                if stat in points_per_unit:
                    capped_value = min(value, max_points.get(stat, float('inf')))
                    item_benefit += capped_value * points_per_unit[stat]
            virtual_item['calculated_value'] = item_benefit
            best_combination.append(virtual_item)

    # Get currently equipped gear (base items only, no components/augments)
    currently_equipped_list = []
    currently_equipped_names = {}
    ring1_assigned = False
    for row in gear_data:
        if not any(row):
            continue
        gear_item = {header[i]: row[i] for i in range(len(row))}
        if gear_item.get('tf') == '1':
            gear_type = gear_item['type']
            if gear_type:
                original_gear_type = gear_type
                if gear_type == 'ring':
                    if not ring1_assigned:
                        gear_type = 'ring 1'
                        ring1_assigned = True
                    else:
                        gear_type = 'ring 2'

                lookup_type = 'ring 1' if original_gear_type == 'ring' else original_gear_type

                for base_item in gear_by_type.get(lookup_type, []):
                    if base_item['name'] == gear_item['name']:
                        # Create virtual item with base only (no component/augment)
                        virtual_item = _combine_items(base_item, None, None, header, gear_type)
                        virtual_item['type'] = gear_type

                        # Calculate stats for the virtual item
                        stats = {stat: 0.0 for stat in header}
                        for stat, value in virtual_item.items():
                            if stat in points_per_unit and value:
                                try:
                                    stat_value = float(value)
                                    stats[stat] = stat_value
                                except (ValueError, TypeError):
                                    pass
                        virtual_item['stats'] = stats

                        # Calculate item benefit for display
                        item_benefit = 0
                        for stat, value in stats.items():
                            if stat in points_per_unit:
                                capped_value = min(value, max_points.get(stat, float('inf')))
                                item_benefit += capped_value * points_per_unit[stat]
                        virtual_item['calculated_value'] = item_benefit

                        currently_equipped_list.append(virtual_item)
                        currently_equipped_names[gear_type] = base_item['name']
                        break

    gear_to_switch = {}
    if best_combination:
        for item in best_combination:
            gear_type = item['type']
            if gear_type in currently_equipped_names and item['name'] != currently_equipped_names[gear_type]:
                gear_to_switch[gear_type] = item
            elif gear_type not in currently_equipped_names:
                gear_to_switch[gear_type] = item

    return gear_to_switch, best_combination, currently_equipped_list, header, points_per_unit, max_points, baseline, evaluations, top_builds


if __name__ == '__main__':
    # Register signal handler for graceful Ctrl+C shutdown
    signal.signal(signal.SIGINT, signal_handler)

    parser = argparse.ArgumentParser(description='Find the optimal gear set for Grim Dawn.')
    parser.add_argument('-v', '--verbose', action='store_true',
                        help='Display a verbose breakdown of item counts and combinations.')
    parser.add_argument('-t', '--time-limit', type=float, default=float('inf'),
                        help='Time limit in seconds for genetic algorithm (default: unlimited, stops on 2s plateau)')
    parser.add_argument('--top-n', type=int, default=5,
                        help='Number of top builds to display (default: 5)')
    parser.add_argument('-p', '--parallel', action='store_true', default=True,
                        help='Enable multi-core island model parallelization (default: enabled)')
    parser.add_argument('-s', '--single-core', action='store_true',
                        help='Disable parallelization and use single-core mode')
    parser.add_argument('--swaps-only', action='store_true',
                        help='Only show gear slots with changes (default: show all gear)')
    args = parser.parse_args()

    # Handle single-core override
    if args.single_core:
        args.parallel = False

    check_and_convert_ods()

    with open('grim_items.csv', 'r') as f:
        reader = csv.reader(f)
        data = list(reader)

    total_combinations = calculate_and_display_combinations(data, args.verbose)

    start_time = time.time()

    gear_to_switch, best_combination, currently_equipped, header, points_per_unit, max_points, baseline, comparisons, top_builds = solve_gear_genetic(
        data, time_limit=args.time_limit, top_n=args.top_n, verbose=args.verbose, parallel=args.parallel
    )

    elapsed_time = time.time() - start_time

    if best_combination:
        if currently_equipped:
            # NEW DISPLAY FORMAT
            # Build current gear state with components/augments
            all_items_raw = []
            for row in data[4:]:
                if not any(row):
                    continue
                item = {header[i]: row[i] for i in range(len(row))}
                all_items_raw.append(item)

            # Get gear_by_type, components, and augments for current gear reconstruction
            gear_by_type_raw = {}
            components_raw = []
            augments_raw = []

            for row in data[4:]:
                if not any(row):
                    continue
                item = {header[i]: row[i] for i in range(len(row))}

                item_type = item.get('type', '')
                item_type_normalized = normalize_item_type(item_type)
                if item_type_normalized == 'component':
                    components_raw.append(item)
                elif item_type_normalized == 'augment':
                    augments_raw.append(item)
                else:
                    if item_type not in gear_by_type_raw:
                        gear_by_type_raw[item_type] = []
                    gear_by_type_raw[item_type].append(item)

            current_gear_dict = get_current_gear_with_components_augments(
                all_items_raw, gear_by_type_raw, components_raw, augments_raw
            )

            # Parse stats for items in current_gear_dict (they don't have stats yet)
            for slot, gear_set in current_gear_dict.items():
                # Parse stats for base item
                if gear_set.get('base'):
                    base_item = gear_set['base']
                    stats = {stat: 0.0 for stat in header}
                    for stat, value in base_item.items():
                        if stat in points_per_unit and value:
                            try:
                                stat_value = float(value)
                                stats[stat] = stat_value
                            except (ValueError, TypeError):
                                pass
                    base_item['stats'] = stats

                # Parse stats for component
                if gear_set.get('component'):
                    component = gear_set['component']
                    stats = {stat: 0.0 for stat in header}
                    for stat, value in component.items():
                        if stat in points_per_unit and value:
                            try:
                                stat_value = float(value)
                                stats[stat] = stat_value
                            except (ValueError, TypeError):
                                pass
                    component['stats'] = stats

                # Parse stats for augment
                if gear_set.get('augment'):
                    augment = gear_set['augment']
                    stats = {stat: 0.0 for stat in header}
                    for stat, value in augment.items():
                        if stat in points_per_unit and value:
                            try:
                                stat_value = float(value)
                                stats[stat] = stat_value
                            except (ValueError, TypeError):
                                pass
                    augment['stats'] = stats

            # Get optimal gear dict (top_builds[0][1] is already in the right format!)
            optimal_gear_dict = top_builds[0][1] if top_builds else {}

            # Sort rings by benefit for consistent display (highest benefit ring in ring 1)
            # This prevents spurious swap recommendations when same rings found in different order
            sort_rings_by_benefit(current_gear_dict, header, points_per_unit, max_points)
            sort_rings_by_benefit(optimal_gear_dict, header, points_per_unit, max_points)

            # Calculate current and optimal benefits
            # Need to get gear_slots from solve_gear_genetic's context
            gear_slots_for_fitness = sorted(gear_by_type_raw.keys())
            if 'ring' in gear_slots_for_fitness:
                gear_slots_for_fitness.remove('ring')
                if 'ring 1' not in gear_slots_for_fitness:
                    gear_slots_for_fitness.extend(['ring 1', 'ring 2'])

            current_benefit = calculate_fitness(current_gear_dict, gear_slots_for_fitness, header, points_per_unit, max_points, baseline)
            # Recalculate optimal benefit to ensure consistency with displayed stats
            optimal_benefit = calculate_fitness(optimal_gear_dict, gear_slots_for_fitness, header, points_per_unit, max_points, baseline)

            # Get generation count and num cores
            num_cores = multiprocessing.cpu_count()
            # Generation count is embedded in the top_builds data (we'll estimate it from comparisons)
            estimated_generation = comparisons // (num_cores * 150) if args.parallel else comparisons // (num_cores * 150)

            # Display in new format (bottom to top order):
            # 1. Gear swaps (top of output - scrolls off)
            display_gear_swaps_new(current_gear_dict, optimal_gear_dict, header, points_per_unit, swaps_only=args.swaps_only)

            # 2. Stat comparison (middle) - pass pre-calculated benefits for consistency
            display_stat_comparison_new(current_gear_dict, optimal_gear_dict, header, points_per_unit, max_points, baseline, current_benefit, optimal_benefit)

            # 3. Execution summary (bottom - most visible)
            print()
            display_execution_summary(comparisons, elapsed_time, current_benefit, optimal_benefit, num_cores, estimated_generation)

        else: # Fallback for when no current gear is equipped
            print("\nBest combination of gear found:")
            for item in best_combination:
                print(f"- {item['type'].capitalize()}: {item['name']} (Benefit: {round(item.get('calculated_value', 0))})")