"""
Grade Calculator Utility

Pure functions for calculating durian grades and retrieving color representations
for different classifications.
"""

from typing import Optional, Tuple


def calculate_durian_grade(
    locule_count: int,
    has_defects: bool,
    shape_class: Optional[str] = None,
    maturity_class: Optional[str] = None
) -> Tuple[str, str]:
    """
    Calculate durian grade based on locule count, defect status, shape, and maturity.
    
    Rules:
    - Has defects (any locule count) = Class C
    - Class A: 5 locules + Regular shape + no defects + Mature
    - Class B: Good quality but missing one or more Class A requirements (irregular shape, <5 locules, immature/overmature)
    - Class C: Has defects or doesn't meet Grade I requirements
    
    Args:
        locule_count: Number of locules detected
        has_defects: True if defects are present, False otherwise
        shape_class: Shape classification ('Regular' or 'Irregular')
        maturity_class: Maturity classification ('Immature', 'Mature', or 'Overmature')
    
    Returns:
        tuple: (grade_letter, grade_description)
    """
    if has_defects:
        return ('C', 'Durian with defects detected - Grade C (Grade II)')
    
    # Check if mature (Class A requires Mature status)
    is_mature = maturity_class == 'Mature' if maturity_class else True  # Assume mature if not provided
    
    # No defects, now check locules, shape, and maturity
    if locule_count == 5 and shape_class == 'Regular' and is_mature:
        # Perfect conditions for Class A
        return ('A', 'Premium Grade: 5 locules, regular shape, mature, no defects - Class A')
    elif has_defects or maturity_class == 'Overmature':
        # Defects or overmature = Class C
        return ('C', f'Grade II: Has defects or is overmature - Class C')
    elif maturity_class == 'Immature':
        # Immature durian = Class B
        return ('B', f'Grade I: Immature durian with {locule_count} locules - Class B')
    elif locule_count == 5:
        # 5 locules but might have irregular shape or not mature
        if shape_class == 'Irregular':
            return ('B', f'Grade I: 5 locules with irregular shape - Class B')
        elif is_mature:
            return ('A', 'Premium Grade: 5 locules, regular shape, mature, no defects - Class A')
        else:
            return ('B', f'Grade I: 5 locules but not mature - Class B')
    elif locule_count < 5:
        return ('B', f'Grade I: Good quality with {locule_count} locules, no defects - Class B')
    else:
        # More than 5 locules but no defects
        return ('B', f'Grade I: Good quality with {locule_count} locules, no defects - Class B')


def get_ripeness_color(ripeness: str) -> str:
    """Get color for ripeness status."""
    colors = {
        'Unripe': '#3498db',
        'Ripe': '#27ae60',
        'Overripe': '#e74c3c'
    }
    return colors.get(ripeness, '#555')


def get_maturity_color(maturity: str) -> str:
    """Get color for maturity status."""
    colors = {
        'Immature': '#3498db',
        'Mature': '#27ae60',
        'Overmature': '#e74c3c'
    }
    return colors.get(maturity, '#555')


def get_grade_color(grade: str) -> str:
    """Get color for overall grade."""
    colors = {
        'A': '#27ae60',
        'B': '#f39c12',
        'C': '#e74c3c'
    }
    return colors.get(grade, '#555')