display(df_placements)

get_role_type(7)

"""
==================================
Hold Usage DataFrame
==================================

Explodes climb frames into individual hold usages.
"""

records = []

for _, row in df_climbs.iterrows():
    frames = row['frames']
    if not isinstance(frames, str):
        continue
    
    matches = re.findall(r'p(\d+)r(\d+)', frames)
    
    for p_str, r_str in matches:
        role_type = get_role_type(int(r_str))
        records.append({
            'placement_id': int(p_str),
            'role_id': int(r_str),
            'role_type': role_type,
            'is_hand': role_type in HAND_ROLES,
            'is_foot': role_type in FOOT_ROLES,
            'difficulty': row['display_difficulty'],
            'angle': row['angle'],
            'climb_uuid': row['uuid']
        })

df_hold_usage = pd.DataFrame(records)

print(f"Built hold usage DataFrame: {len(df_hold_usage):,} records")
print(f"Unique placements: {df_hold_usage['placement_id'].nunique():,}")
print(f"Unique angles: {sorted(df_hold_usage['angle'].unique())}")

print("\nRecords by role type:")
display(df_hold_usage['role_type'].value_counts().to_frame('count'))

print(f"\nHand usages: {df_hold_usage['is_hand'].sum():,}")
print(f"Foot usages: {df_hold_usage['is_foot'].sum():,}")

"""
==================================
Bayesian Smoothing
==================================
"""

SMOOTHING_M = 20

def bayesian_smooth(mean_col, count_col, global_mean, m=SMOOTHING_M):
    """
    Bayesian smoothing toward the global mean.
    """
    return (count_col * mean_col + m * global_mean) / (count_col + m)

GLOBAL_DIFFICULTY_MEAN = df_hold_usage['difficulty'].mean()
print(f"Global difficulty mean: {GLOBAL_DIFFICULTY_MEAN:.3f}")

"""
==================================
Raw difficulty score (averged & smoothed)
==================================


Average difficulty of all climbs that use this hold, plus a Bayesian-smoothed
version that is more stable for low-usage holds.
"""

raw_scores = df_hold_usage.groupby('placement_id').agg(
    raw_difficulty=('difficulty', 'mean'),
    usage_count=('climb_uuid', 'count'),
    climbs_count=('climb_uuid', 'nunique')
)

raw_scores['raw_difficulty_smoothed'] = bayesian_smooth(
    raw_scores['raw_difficulty'],
    raw_scores['usage_count'],
    GLOBAL_DIFFICULTY_MEAN
)

raw_scores = raw_scores.round(2)

print("### Top 10 Hardest Holds (Raw)\n")
display(raw_scores.sort_values('raw_difficulty', ascending=False).head(10))

print("\n### Top 10 Easiest Holds (Raw)\n")
display(raw_scores.sort_values('raw_difficulty', ascending=True).head(10))

print("\n### Example of Raw vs Smoothed Difficulty\n")
display(raw_scores[['raw_difficulty', 'raw_difficulty_smoothed', 'usage_count']].head(10))

"""
==================================
Per-Angle Difficulty Score
==================================

Computes difficulty score per angle, then aggregates with weighting.
Uses Bayesian-smoothed per-angle difficulty throughout.
"""

# Calculate per-angle scores
angle_scores = df_hold_usage.groupby(['placement_id', 'angle']).agg(
    avg_difficulty=('difficulty', 'mean'),
    usage_count=('climb_uuid', 'count')
).reset_index()

# Apply Bayesian smoothing
angle_scores['avg_difficulty_smoothed'] = bayesian_smooth(
    angle_scores['avg_difficulty'],
    angle_scores['usage_count'],
    GLOBAL_DIFFICULTY_MEAN
)

# Pivot to see angles side-by-side
angle_pivot = angle_scores.pivot_table(
    index='placement_id',
    columns='angle',
    values='avg_difficulty_smoothed',
    aggfunc='mean'
)
angle_pivot.columns = [f'diff_{int(col)}deg' for col in angle_pivot.columns]

# Calculate weighted average using the smoothed per-angle values
weighted_scores = []

for pid in angle_scores['placement_id'].unique():
    df_pid = angle_scores[angle_scores['placement_id'] == pid].copy()

    total_count = df_pid['usage_count'].sum()
    weighted_diff = (
        df_pid['avg_difficulty_smoothed'] * df_pid['usage_count']
    ).sum() / total_count

    weighted_scores.append({
        'placement_id': pid,
        'angle_weighted_difficulty': weighted_diff,
        'angles_used': len(df_pid),
        'min_angle': int(df_pid['angle'].min()),
        'max_angle': int(df_pid['angle'].max()),
        'angle_range': int(df_pid['angle'].max() - df_pid['angle'].min())
    })

df_angle_scores = pd.DataFrame(weighted_scores).set_index('placement_id')

print("### Per-Angle Difficulty Analysis (Sample)\n")
display(angle_pivot.join(df_angle_scores).head(15))

print(f"\nAngles used per hold:")
print(df_angle_scores['angles_used'].describe())

"""
==================================
Per-Role Difficulty Score
==================================

Individual roles (start, middle, finish, foot) AND aggregate (hand).
All exported difficulty values are Bayesian-smoothed.
"""

# Individual role scores
role_scores = df_hold_usage.groupby(['placement_id', 'role_type']).agg(
    avg_difficulty=('difficulty', 'mean'),
    usage_count=('climb_uuid', 'count')
).reset_index()

# Apply Bayesian smoothing
role_scores['avg_difficulty_smoothed'] = bayesian_smooth(
    role_scores['avg_difficulty'],
    role_scores['usage_count'],
    GLOBAL_DIFFICULTY_MEAN
)

# Pivot for individual roles
role_pivot = role_scores.pivot_table(
    index='placement_id',
    columns='role_type',
    values='avg_difficulty_smoothed',
    aggfunc='mean'
)
role_pivot.columns = [f'diff_as_{col}' for col in role_pivot.columns]

# Usage counts per individual role
role_counts = role_scores.pivot_table(
    index='placement_id',
    columns='role_type',
    values='usage_count',
    aggfunc='sum',
    fill_value=0
)
role_counts.columns = [f'uses_as_{col}' for col in role_counts.columns]

# Aggregate hand difficulty
hand_usage = df_hold_usage[df_hold_usage['is_hand']].groupby('placement_id').agg(
    diff_as_hand_raw=('difficulty', 'mean'),
    uses_as_hand=('climb_uuid', 'count')
)

hand_usage['diff_as_hand'] = bayesian_smooth(
    hand_usage['diff_as_hand_raw'],
    hand_usage['uses_as_hand'],
    GLOBAL_DIFFICULTY_MEAN
)

hand_usage = hand_usage[['diff_as_hand', 'uses_as_hand']]

# Combine role tables
df_role_analysis = role_pivot.join(role_counts).join(hand_usage).round(2)

cols_order = [
    'diff_as_start', 'uses_as_start',
    'diff_as_middle', 'uses_as_middle',
    'diff_as_finish', 'uses_as_finish',
    'diff_as_hand', 'uses_as_hand',
    'diff_as_foot', 'uses_as_foot'
]
cols_order = [c for c in cols_order if c in df_role_analysis.columns]
df_role_analysis = df_role_analysis[cols_order]

print("### Role-Specific Difficulty Scores (Sample)\n")
display(df_role_analysis.head(15))

print("\n### Holds Used as Both Hand and Foot\n")
dual_use = df_role_analysis[
    df_role_analysis['diff_as_hand'].notna() &
    df_role_analysis['diff_as_foot'].notna()
].copy()

if len(dual_use) > 0:
    dual_use['hand_minus_foot'] = dual_use['diff_as_hand'] - dual_use['diff_as_foot']
    display(
        dual_use[['diff_as_hand', 'diff_as_foot', 'hand_minus_foot']]
        .sort_values('hand_minus_foot', ascending=False)
        .head(15)
    )

"""
==================================
Per-Role Per-Angle Difficulty Score
==================================


Granular scores: placement_id × role_type × angle
Includes both individual roles AND aggregate hand.
All downstream tables use the smoothed difficulty values.
"""

# Individual roles per angle
role_angle_scores = df_hold_usage.groupby(['placement_id', 'role_type', 'angle']).agg(
    avg_difficulty=('difficulty', 'mean'),
    usage_count=('climb_uuid', 'count')
).reset_index()

role_angle_scores['avg_difficulty_smoothed'] = bayesian_smooth(
    role_angle_scores['avg_difficulty'],
    role_angle_scores['usage_count'],
    GLOBAL_DIFFICULTY_MEAN
)

# Aggregate hand per angle
hand_angle_scores = df_hold_usage[df_hold_usage['is_hand']].groupby(['placement_id', 'angle']).agg(
    avg_difficulty=('difficulty', 'mean'),
    usage_count=('climb_uuid', 'count')
).reset_index()

hand_angle_scores['avg_difficulty_smoothed'] = bayesian_smooth(
    hand_angle_scores['avg_difficulty'],
    hand_angle_scores['usage_count'],
    GLOBAL_DIFFICULTY_MEAN
)
hand_angle_scores['role_type'] = 'hand'

# Combine all
df_role_angle = pd.concat([role_angle_scores, hand_angle_scores], ignore_index=True)

print(f"Total role-angle records: {len(df_role_angle):,}")
print("\nBreakdown by role_type:")
display(df_role_angle.groupby('role_type').size().to_frame('count'))

print("\n### Per-Role Per-Angle Difficulty Scores (Sample)\n")
display(df_role_angle.head(20))

"""
==================================
Role-Specific Tables
==================================

Tables for: start, middle, finish, hand, foot
Each with per-angle columns and overall average.
Uses Bayesian-smoothed role-angle difficulty values.
"""

angles = sorted(df_hold_usage['angle'].unique())
role_tables = {}

for role in ROLE_TYPES:
    df_role = df_role_angle[df_role_angle['role_type'] == role].copy()

    if df_role.empty:
        print(f"No data for role: {role}")
        continue

    pivot = df_role.pivot_table(
        index='placement_id',
        columns='angle',
        values='avg_difficulty_smoothed',
        aggfunc='mean'
    )
    pivot.columns = [f'{role}_diff_{int(col)}deg' for col in pivot.columns]
    pivot[f'{role}_overall_avg'] = pivot.mean(axis=1).round(2)

    usage_pivot = df_role.pivot_table(
        index='placement_id',
        columns='angle',
        values='usage_count',
        aggfunc='sum',
        fill_value=0
    )
    usage_pivot.columns = [f'{role}_uses_{int(col)}deg' for col in usage_pivot.columns]
    pivot[f'{role}_total_uses'] = usage_pivot.sum(axis=1).astype(int)

    role_tables[role] = pivot.join(usage_pivot)

    print(f"\n### {role.upper()} Difficulty by Angle\n")
    display(role_tables[role].head(8))

"""
==================================
Combined Table for Modelling
==================================

Build a single placement-level table used downstream in feature
engineering. The smoothed overall difficulty is exposed under the simple
name `overall_difficulty`, while the raw version is retained as
`overall_difficulty_raw` for reference.
"""

# Start with placement info
df_model_features = df_placements[['placement_id', 'x', 'y', 'set_name', 'default_role_id']].copy()
df_model_features = df_model_features.set_index('placement_id')
df_model_features = df_model_features.rename(columns={
    'set_name': 'material',
    'default_role_id': 'default_role'
})

# Add raw + smoothed overall scores
df_model_features = df_model_features.join(
    raw_scores[['raw_difficulty', 'raw_difficulty_smoothed', 'usage_count', 'climbs_count']],
    how='left'
)

# Add angle scores
df_model_features = df_model_features.join(
    df_angle_scores[['angle_weighted_difficulty', 'angles_used', 'min_angle', 'max_angle', 'angle_range']],
    how='left'
)

# Add per-role tables
for role in ROLE_TYPES:
    if role in role_tables:
        df_model_features = df_model_features.join(role_tables[role], how='left')

# Add aggregate hand / foot scores if missing
extra_role_cols = [c for c in ['diff_as_hand', 'uses_as_hand', 'diff_as_foot', 'uses_as_foot'] if c in df_role_analysis.columns]
missing_extra_cols = [c for c in extra_role_cols if c not in df_model_features.columns]
if missing_extra_cols:
    df_model_features = df_model_features.join(df_role_analysis[missing_extra_cols], how='left')

# Rename for clarity
df_model_features = df_model_features.rename(columns={
    'raw_difficulty': 'overall_difficulty_raw',
    'raw_difficulty_smoothed': 'overall_difficulty'
})

print("### Combined Model Features Table (Before Mirror)\n")
display(df_model_features.head(10))
print(f"\nShape: {df_model_features.shape}")

"""
==================================
Apply mirror to all difficulty coluns
==================================

Averages mirror pairs for:
- overall difficulty
- angle-weighted difficulty
- per-role overall averages
- per-role per-angle difficulties
"""

overall_cols = [c for c in ['overall_difficulty', 'angle_weighted_difficulty'] if c in df_model_features.columns]
role_avg_cols = [c for c in df_model_features.columns if c.endswith('_overall_avg')]
angle_diff_cols = [c for c in df_model_features.columns if '_diff_' in c and c.endswith('deg')]

all_difficulty_cols = sorted(set(overall_cols + role_avg_cols + angle_diff_cols))

missing_before = df_model_features[all_difficulty_cols].isna().sum().sum()
print(f"Missing values before mirror: {missing_before}")
print(f"Columns affected: {len(all_difficulty_cols)}")

df_model_features = average_with_mirror(df_model_features, all_difficulty_cols, placement_to_mirror)

missing_after = df_model_features[all_difficulty_cols].isna().sum().sum()
print(f"Missing values after mirror: {missing_after}")
print(f"Reduced by: {missing_before - missing_after}")

"""
==================================
Rebuild detailed role-angle table from model features
==================================

Rebuild df_role_angle from the mirror-filled placement-level table so
saved exports and later visualizations reflect the final mirrored values.
"""

records = []

angle_cols = [c for c in df_model_features.columns if '_diff_' in c and c.endswith('deg')]

for col in angle_cols:
    parts = col.split('_')
    role = parts[0]
    angle = int(parts[2].replace('deg', ''))

    for placement_id, val in df_model_features[col].dropna().items():
        records.append({
            'placement_id': placement_id,
            'role_type': role,
            'angle': angle,
            'avg_difficulty_smoothed': val,
            'usage_count': 0
        })

df_role_angle = pd.DataFrame(records)

print(f"Rebuilt role-angle table: {len(df_role_angle)} records")

print("\n### Verify Hand @ 50° Coverage\n")
hand_50 = df_role_angle[(df_role_angle['role_type'] == 'hand') & (df_role_angle['angle'] == 50)]
print(f"Records for Hand @ 50°: {len(hand_50)}")

if placement_to_mirror:
    sample_pid = list(placement_to_mirror.keys())[0]
    sample_mirror = placement_to_mirror[sample_pid]

    print(f"\nSample mirror pair {sample_pid} <-> {sample_mirror}:")
    for role in ['hand', 'foot']:
        for angle in [40, 50]:
            check = df_role_angle[
                (df_role_angle['role_type'] == role) &
                (df_role_angle['angle'] == angle) &
                (df_role_angle['placement_id'].isin([sample_pid, sample_mirror]))
            ]
            if len(check) == 2:
                vals = check['avg_difficulty_smoothed'].values
                print(f"  {role} @ {angle}°: {vals[0]:.2f} <-> {vals[1]:.2f}")