Analytical Tools for Tax Strategy

Python: Luxury Tax Calculator and Strategy Analyzer

"""
NBA Luxury Tax Strategy Analysis Tools
Advanced calculators for tax bills, apron implications, and multi-year planning

Install: pip install pandas numpy matplotlib seaborn
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from typing import Dict, List, Tuple, Optional
from dataclasses import dataclass

# 2023-24 CBA Constants
SALARY_CAP = 136_021_000
LUXURY_TAX = 165_294_000
FIRST_APRON = 172_346_000
SECOND_APRON = 182_794_000
MIN_TEAM_SALARY = 122_418_900

# Projected cap growth (5-8% typical)
CAP_GROWTH_RATE = 0.065  # 6.5% average


@dataclass
class TaxThresholds:
    """Tax threshold data for a season"""
    salary_cap: float
    luxury_tax: float
    first_apron: float
    second_apron: float
    season: str


def calculate_luxury_tax_detailed(
    team_salary: float,
    is_repeater: bool = False,
    breakdown: bool = True
) -> Dict:
    """
    Calculate luxury tax with detailed breakdown of brackets

    Args:
        team_salary: Total team salary
        is_repeater: Whether team is repeater offender
        breakdown: Return detailed bracket breakdown

    Returns:
        Dictionary with tax calculation details
    """
    if team_salary <= LUXURY_TAX:
        return {
            'overage': 0,
            'tax_bill': 0,
            'total_cost': team_salary,
            'effective_rate': 0,
            'brackets': []
        }

    overage = team_salary - LUXURY_TAX

    # Define progressive tax brackets
    if is_repeater:
        brackets = [
            (0, 5_000_000, 2.50),
            (5_000_000, 10_000_000, 2.75),
            (10_000_000, 15_000_000, 3.50),
            (15_000_000, 20_000_000, 4.25),
            (20_000_000, 25_000_000, 4.75),
            (25_000_000, 30_000_000, 5.25),
            (30_000_000, 35_000_000, 5.75),
            (35_000_000, 40_000_000, 6.25),
        ]
    else:
        brackets = [
            (0, 5_000_000, 1.50),
            (5_000_000, 10_000_000, 1.75),
            (10_000_000, 15_000_000, 2.50),
            (15_000_000, 20_000_000, 3.25),
            (20_000_000, 25_000_000, 3.75),
            (25_000_000, 30_000_000, 4.25),
            (30_000_000, 35_000_000, 4.75),
            (35_000_000, 40_000_000, 5.25),
        ]

    tax_bill = 0
    bracket_details = []

    for start, end, rate in brackets:
        if overage <= start:
            break

        taxable_amount = min(overage, end) - start
        bracket_tax = taxable_amount * rate
        tax_bill += bracket_tax

        if breakdown:
            bracket_details.append({
                'range': f'${start/1e6:.1f}M - ${end/1e6:.1f}M',
                'amount': taxable_amount,
                'rate': rate,
                'tax': bracket_tax
            })

    # Handle amounts over highest defined bracket
    if overage > brackets[-1][1]:
        remaining = overage - brackets[-1][1]
        # Incremental rate increases by $0.50 per $5M
        base_rate = brackets[-1][2]
        additional_brackets = int(remaining / 5_000_000) + 1

        for i in range(additional_brackets):
            bracket_start = brackets[-1][1] + (i * 5_000_000)
            bracket_end = bracket_start + 5_000_000
            rate = base_rate + (0.50 * (i + 1))

            taxable_amount = min(remaining, 5_000_000)
            bracket_tax = taxable_amount * rate
            tax_bill += bracket_tax

            if breakdown:
                bracket_details.append({
                    'range': f'${bracket_start/1e6:.1f}M - ${bracket_end/1e6:.1f}M',
                    'amount': taxable_amount,
                    'rate': rate,
                    'tax': bracket_tax
                })

            remaining -= taxable_amount
            if remaining <= 0:
                break

    total_cost = team_salary + tax_bill
    effective_rate = tax_bill / overage if overage > 0 else 0

    return {
        'team_salary': team_salary,
        'overage': overage,
        'tax_bill': tax_bill,
        'total_cost': total_cost,
        'effective_rate': effective_rate,
        'repeater': is_repeater,
        'brackets': bracket_details
    }


def check_apron_restrictions(team_salary: float) -> Dict:
    """
    Check which apron restrictions apply to team

    Args:
        team_salary: Total team salary

    Returns:
        Dictionary with restriction details
    """
    restrictions = {
        'under_tax': team_salary < LUXURY_TAX,
        'under_first_apron': team_salary < FIRST_APRON,
        'under_second_apron': team_salary < SECOND_APRON,
        'restrictions': []
    }

    if team_salary >= LUXURY_TAX:
        restrictions['restrictions'].append('Paying luxury tax')

    if team_salary >= FIRST_APRON:
        restrictions['restrictions'].extend([
            'No sign-and-trade acquisitions',
            'Only Taxpayer MLE ($5M)',
            'No cash in trades',
            '110% trade matching only'
        ])

    if team_salary >= SECOND_APRON:
        restrictions['restrictions'].extend([
            'No salary aggregation in trades',
            'No multi-for-one trades',
            '100% trade matching (dollar-for-dollar)',
            'Future first-round pick frozen',
            'Risk of draft pick penalty'
        ])

    return restrictions


def calculate_marginal_cost(
    current_salary: float,
    player_salary: float,
    is_repeater: bool = False
) -> Dict:
    """
    Calculate marginal cost of adding a player

    Args:
        current_salary: Current team salary
        player_salary: Salary of player to add
        is_repeater: Repeater tax status

    Returns:
        Dictionary with marginal cost analysis
    """
    baseline = calculate_luxury_tax_detailed(current_salary, is_repeater, False)
    with_player = calculate_luxury_tax_detailed(
        current_salary + player_salary,
        is_repeater,
        False
    )

    marginal_cost = with_player['total_cost'] - baseline['total_cost']
    cost_multiplier = marginal_cost / player_salary

    # Check if crosses apron thresholds
    crosses_tax = (current_salary < LUXURY_TAX <= current_salary + player_salary)
    crosses_first_apron = (current_salary < FIRST_APRON <= current_salary + player_salary)
    crosses_second_apron = (current_salary < SECOND_APRON <= current_salary + player_salary)

    return {
        'player_salary': player_salary,
        'marginal_cost': marginal_cost,
        'cost_multiplier': cost_multiplier,
        'baseline_tax': baseline['tax_bill'],
        'new_tax': with_player['tax_bill'],
        'tax_increase': with_player['tax_bill'] - baseline['tax_bill'],
        'crosses_tax_line': crosses_tax,
        'crosses_first_apron': crosses_first_apron,
        'crosses_second_apron': crosses_second_apron
    }


def simulate_repeater_scenarios(
    team_salary: float,
    years: int = 5,
    salary_changes: List[float] = None
) -> pd.DataFrame:
    """
    Simulate tax bills under different repeater scenarios

    Args:
        team_salary: Current team salary
        years: Number of years to project
        salary_changes: Annual salary changes (or None for constant)

    Returns:
        DataFrame with year-by-year projections
    """
    if salary_changes is None:
        salary_changes = [0] * years

    results = []
    repeater_tracker = []  # Track last 4 years

    for year in range(1, years + 1):
        # Adjust team salary
        if year == 1:
            current_salary = team_salary
        else:
            current_salary = results[-1]['team_salary'] + salary_changes[year - 1]

        # Adjust for cap growth
        year_cap_growth = (1 + CAP_GROWTH_RATE) ** (year - 1)
        adjusted_tax_line = LUXURY_TAX * year_cap_growth

        # Determine if repeater
        is_repeater = sum(repeater_tracker[-4:]) >= 3 if len(repeater_tracker) >= 4 else False

        # Calculate tax
        paying_tax = current_salary > adjusted_tax_line
        repeater_tracker.append(1 if paying_tax else 0)

        if paying_tax:
            overage = current_salary - adjusted_tax_line
            # Simplified calculation for projection
            if is_repeater:
                avg_rate = 3.5  # Conservative average repeater rate
            else:
                avg_rate = 2.0  # Conservative average non-repeater rate

            tax_bill = overage * avg_rate
        else:
            tax_bill = 0
            overage = 0

        results.append({
            'year': f'Year {year}',
            'team_salary': current_salary,
            'tax_threshold': adjusted_tax_line,
            'overage': overage,
            'is_repeater': is_repeater,
            'tax_bill': tax_bill,
            'total_cost': current_salary + tax_bill
        })

    df = pd.DataFrame(results)
    df['cumulative_tax'] = df['tax_bill'].cumsum()

    return df


def compare_tax_strategies(
    base_salary: float,
    strategies: List[Dict]
) -> pd.DataFrame:
    """
    Compare different tax management strategies

    Args:
        base_salary: Starting team salary
        strategies: List of strategy dictionaries with 'name' and 'salaries' (5-year list)

    Returns:
        Comparison DataFrame
    """
    results = []

    for strategy in strategies:
        name = strategy['name']
        salaries = strategy['salaries']

        total_tax = 0
        repeater_tracker = []

        for year, salary in enumerate(salaries, 1):
            year_cap_growth = (1 + CAP_GROWTH_RATE) ** (year - 1)
            adjusted_tax_line = LUXURY_TAX * year_cap_growth

            is_repeater = sum(repeater_tracker[-4:]) >= 3 if len(repeater_tracker) >= 4 else False

            if salary > adjusted_tax_line:
                paying_tax = True
                repeater_tracker.append(1)

                overage = salary - adjusted_tax_line
                avg_rate = 3.5 if is_repeater else 2.0
                year_tax = overage * avg_rate
                total_tax += year_tax
            else:
                repeater_tracker.append(0)

        results.append({
            'strategy': name,
            'total_tax_paid': total_tax,
            'avg_annual_tax': total_tax / len(salaries),
            'years_paying_tax': sum(repeater_tracker),
            'became_repeater': sum(repeater_tracker[-4:]) >= 3 if len(repeater_tracker) >= 4 else False
        })

    return pd.DataFrame(results).sort_values('total_tax_paid')


def visualize_tax_scenarios(team_salaries: List[float], labels: List[str]):
    """
    Visualize tax bills for different team salary scenarios

    Args:
        team_salaries: List of team salary amounts
        labels: Labels for each scenario
    """
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))

    # Calculate tax bills
    data = []
    for salary, label in zip(team_salaries, labels):
        regular = calculate_luxury_tax_detailed(salary, is_repeater=False, breakdown=False)
        repeater = calculate_luxury_tax_detailed(salary, is_repeater=True, breakdown=False)

        data.append({
            'Scenario': label,
            'Salary': salary,
            'Tax (Regular)': regular['tax_bill'],
            'Tax (Repeater)': repeater['tax_bill'],
            'Total Cost (Regular)': regular['total_cost'],
            'Total Cost (Repeater)': repeater['total_cost']
        })

    df = pd.DataFrame(data)

    # Tax bill comparison
    x = np.arange(len(labels))
    width = 0.35

    ax1.bar(x - width/2, df['Tax (Regular)'] / 1e6, width, label='Non-Repeater', color='#1f77b4')
    ax1.bar(x + width/2, df['Tax (Repeater)'] / 1e6, width, label='Repeater', color='#ff7f0e')

    ax1.set_xlabel('Scenario', fontsize=12)
    ax1.set_ylabel('Tax Bill (Millions)', fontsize=12)
    ax1.set_title('Luxury Tax Bills by Scenario', fontsize=14, fontweight='bold')
    ax1.set_xticks(x)
    ax1.set_xticklabels(labels, rotation=45, ha='right')
    ax1.legend()
    ax1.grid(True, alpha=0.3, axis='y')

    # Total cost comparison
    ax2.bar(x - width/2, df['Total Cost (Regular)'] / 1e6, width, label='Non-Repeater', color='#1f77b4')
    ax2.bar(x + width/2, df['Total Cost (Repeater)'] / 1e6, width, label='Repeater', color='#ff7f0e')

    ax2.axhline(y=LUXURY_TAX / 1e6, color='red', linestyle='--', linewidth=1, label='Tax Threshold')
    ax2.set_xlabel('Scenario', fontsize=12)
    ax2.set_ylabel('Total Cost (Millions)', fontsize=12)
    ax2.set_title('Total Team Cost (Salary + Tax)', fontsize=14, fontweight='bold')
    ax2.set_xticks(x)
    ax2.set_xticklabels(labels, rotation=45, ha='right')
    ax2.legend()
    ax2.grid(True, alpha=0.3, axis='y')

    plt.tight_layout()
    plt.savefig('tax_strategy_comparison.png', dpi=300, bbox_inches='tight')
    plt.show()


# Example Usage
if __name__ == "__main__":
    print("=" * 60)
    print("NBA LUXURY TAX STRATEGY ANALYSIS")
    print("=" * 60)

    # Example 1: Detailed tax calculation
    print("\n1. DETAILED TAX CALCULATION (Warriors-style)")
    print("-" * 60)
    warriors_salary = 207_900_000
    tax_result = calculate_luxury_tax_detailed(warriors_salary, is_repeater=True)

    print(f"Team Salary: ${tax_result['team_salary']:,.0f}")
    print(f"Overage: ${tax_result['overage']:,.0f}")
    print(f"Tax Bill: ${tax_result['tax_bill']:,.0f}")
    print(f"Total Cost: ${tax_result['total_cost']:,.0f}")
    print(f"Effective Rate: {tax_result['effective_rate']:.2f}x")
    print(f"\nBracket Breakdown:")
    for bracket in tax_result['brackets'][:5]:  # Show first 5 brackets
        print(f"  {bracket['range']}: ${bracket['amount']:,.0f} @ {bracket['rate']:.2f}x = ${bracket['tax']:,.0f}")

    # Example 2: Apron restrictions
    print("\n2. APRON RESTRICTIONS CHECK")
    print("-" * 60)
    test_salaries = [170_000_000, 175_000_000, 185_000_000]
    for salary in test_salaries:
        restrictions = check_apron_restrictions(salary)
        print(f"\nSalary: ${salary:,.0f}")
        print(f"Restrictions: {len(restrictions['restrictions'])}")
        for r in restrictions['restrictions'][:3]:
            print(f"  - {r}")

    # Example 3: Marginal cost analysis
    print("\n3. MARGINAL COST OF SIGNING PLAYER")
    print("-" * 60)
    current = 170_000_000
    player = 15_000_000

    marginal = calculate_marginal_cost(current, player, is_repeater=False)
    print(f"Current Salary: ${current:,.0f}")
    print(f"Player Salary: ${player:,.0f}")
    print(f"Marginal Cost: ${marginal['marginal_cost']:,.0f}")
    print(f"Cost Multiplier: {marginal['cost_multiplier']:.2f}x")
    print(f"Crosses First Apron: {marginal['crosses_first_apron']}")

    # Example 4: Repeater scenario simulation
    print("\n4. FIVE-YEAR TAX PROJECTION")
    print("-" * 60)
    projection = simulate_repeater_scenarios(
        team_salary=175_000_000,
        years=5,
        salary_changes=[5_000_000, 3_000_000, -2_000_000, 4_000_000, 0]
    )
    print(projection[['year', 'team_salary', 'is_repeater', 'tax_bill', 'cumulative_tax']].to_string(index=False))

    # Example 5: Strategy comparison
    print("\n5. TAX STRATEGY COMPARISON")
    print("-" * 60)
    strategies = [
        {
            'name': 'All-In (Pay Every Year)',
            'salaries': [180e6, 185e6, 190e6, 192e6, 195e6]
        },
        {
            'name': 'Strategic Gap (Reset Year 3)',
            'salaries': [180e6, 185e6, 160e6, 190e6, 195e6]
        },
        {
            'name': 'Conservative (Below Tax)',
            'salaries': [160e6, 162e6, 164e6, 166e6, 168e6]
        }
    ]

    comparison = compare_tax_strategies(175_000_000, strategies)
    print(comparison.to_string(index=False))

    # Example 6: Visualization
    print("\n6. GENERATING VISUALIZATIONS...")
    print("-" * 60)
    scenarios = [150e6, 165e6, 172e6, 180e6, 190e6, 210e6]
    labels = ['Under Tax', 'At Tax', 'First Apron', 'Light Tax', 'Heavy Tax', 'Max Tax']
    visualize_tax_scenarios(scenarios, labels)

    print("\nAnalysis complete! Check 'tax_strategy_comparison.png' for visualizations.")

R: Luxury Tax Strategy and Financial Modeling

# NBA Luxury Tax Strategy Analysis in R
# Financial modeling and strategic planning tools
# Install: install.packages(c("tidyverse", "scales", "ggplot2", "patchwork"))

library(tidyverse)
library(scales)
library(ggplot2)
library(patchwork)

# 2023-24 CBA Constants
SALARY_CAP <- 136021000
LUXURY_TAX <- 165294000
FIRST_APRON <- 172346000
SECOND_APRON <- 182794000
CAP_GROWTH_RATE <- 0.065  # 6.5% projected annual growth

#' Calculate luxury tax with detailed breakdown
#'
#' @param team_salary Total team salary
#' @param is_repeater Whether team is repeater offender
#' @return List with tax details and bracket breakdown
calculate_luxury_tax_detailed <- function(team_salary, is_repeater = FALSE) {
  if (team_salary <= LUXURY_TAX) {
    return(list(
      team_salary = team_salary,
      overage = 0,
      tax_bill = 0,
      total_cost = team_salary,
      effective_rate = 0,
      brackets = tibble()
    ))
  }

  overage <- team_salary - LUXURY_TAX

  # Define progressive brackets
  if (is_repeater) {
    brackets <- tibble(
      start = c(0, 5e6, 10e6, 15e6, 20e6, 25e6, 30e6, 35e6),
      end = c(5e6, 10e6, 15e6, 20e6, 25e6, 30e6, 35e6, 40e6),
      rate = c(2.50, 2.75, 3.50, 4.25, 4.75, 5.25, 5.75, 6.25)
    )
  } else {
    brackets <- tibble(
      start = c(0, 5e6, 10e6, 15e6, 20e6, 25e6, 30e6, 35e6),
      end = c(5e6, 10e6, 15e6, 20e6, 25e6, 30e6, 35e6, 40e6),
      rate = c(1.50, 1.75, 2.50, 3.25, 3.75, 4.25, 4.75, 5.25)
    )
  }

  # Calculate tax by bracket
  tax_bill <- 0
  bracket_details <- tibble()

  for (i in 1:nrow(brackets)) {
    if (overage <= brackets$start[i]) break

    taxable_amount <- min(overage, brackets$end[i]) - brackets$start[i]
    bracket_tax <- taxable_amount * brackets$rate[i]
    tax_bill <- tax_bill + bracket_tax

    bracket_details <- bind_rows(
      bracket_details,
      tibble(
        range = sprintf("$%.1fM - $%.1fM", brackets$start[i]/1e6, brackets$end[i]/1e6),
        amount = taxable_amount,
        rate = brackets$rate[i],
        tax = bracket_tax
      )
    )
  }

  # Handle amounts over highest bracket
  if (overage > max(brackets$end)) {
    remaining <- overage - max(brackets$end)
    base_rate <- max(brackets$rate)

    while (remaining > 0) {
      bracket_num <- floor((overage - max(brackets$end)) / 5e6)
      rate <- base_rate + (0.50 * (bracket_num + 1))
      taxable_amount <- min(remaining, 5e6)
      bracket_tax <- taxable_amount * rate
      tax_bill <- tax_bill + bracket_tax
      remaining <- remaining - taxable_amount
    }
  }

  total_cost <- team_salary + tax_bill
  effective_rate <- if (overage > 0) tax_bill / overage else 0

  list(
    team_salary = team_salary,
    overage = overage,
    tax_bill = tax_bill,
    total_cost = total_cost,
    effective_rate = effective_rate,
    repeater = is_repeater,
    brackets = bracket_details
  )
}


#' Check apron restrictions for given salary
#'
#' @param team_salary Total team salary
#' @return List with restriction information
check_apron_restrictions <- function(team_salary) {
  restrictions <- character(0)

  if (team_salary >= LUXURY_TAX) {
    restrictions <- c(restrictions, "Paying luxury tax")
  }

  if (team_salary >= FIRST_APRON) {
    restrictions <- c(
      restrictions,
      "No sign-and-trade acquisitions",
      "Only Taxpayer MLE ($5M)",
      "No cash in trades",
      "110% trade matching only"
    )
  }

  if (team_salary >= SECOND_APRON) {
    restrictions <- c(
      restrictions,
      "No salary aggregation in trades",
      "No multi-for-one trades",
      "100% trade matching (dollar-for-dollar)",
      "Future first-round pick frozen",
      "Risk of draft pick penalty"
    )
  }

  list(
    salary = team_salary,
    under_tax = team_salary < LUXURY_TAX,
    under_first_apron = team_salary < FIRST_APRON,
    under_second_apron = team_salary < SECOND_APRON,
    num_restrictions = length(restrictions),
    restrictions = restrictions
  )
}


#' Calculate marginal cost of adding a player
#'
#' @param current_salary Current team salary
#' @param player_salary Salary of player to add
#' @param is_repeater Repeater tax status
#' @return Tibble with marginal cost analysis
calculate_marginal_cost <- function(current_salary, player_salary, is_repeater = FALSE) {
  baseline <- calculate_luxury_tax_detailed(current_salary, is_repeater)
  with_player <- calculate_luxury_tax_detailed(current_salary + player_salary, is_repeater)

  marginal_cost <- with_player$total_cost - baseline$total_cost
  cost_multiplier <- marginal_cost / player_salary

  # Check threshold crossings
  crosses_tax <- current_salary < LUXURY_TAX && (current_salary + player_salary) >= LUXURY_TAX
  crosses_first <- current_salary < FIRST_APRON && (current_salary + player_salary) >= FIRST_APRON
  crosses_second <- current_salary < SECOND_APRON && (current_salary + player_salary) >= SECOND_APRON

  tibble(
    player_salary = player_salary,
    marginal_cost = marginal_cost,
    cost_multiplier = cost_multiplier,
    baseline_tax = baseline$tax_bill,
    new_tax = with_player$tax_bill,
    tax_increase = with_player$tax_bill - baseline$tax_bill,
    crosses_tax_line = crosses_tax,
    crosses_first_apron = crosses_first,
    crosses_second_apron = crosses_second
  )
}


#' Simulate multi-year tax scenarios
#'
#' @param team_salary Starting team salary
#' @param years Number of years to project
#' @param salary_changes Annual salary changes
#' @return Tibble with year-by-year projections
simulate_repeater_scenarios <- function(team_salary, years = 5, salary_changes = NULL) {
  if (is.null(salary_changes)) {
    salary_changes <- rep(0, years)
  }

  results <- tibble()
  repeater_tracker <- numeric(0)
  current_salary <- team_salary

  for (year in 1:years) {
    # Adjust for salary changes
    if (year > 1) {
      current_salary <- current_salary + salary_changes[year - 1]
    }

    # Adjust tax threshold for cap growth
    year_cap_growth <- (1 + CAP_GROWTH_RATE) ^ (year - 1)
    adjusted_tax_line <- LUXURY_TAX * year_cap_growth

    # Determine repeater status
    is_repeater <- if (length(repeater_tracker) >= 4) {
      sum(tail(repeater_tracker, 4)) >= 3
    } else {
      FALSE
    }

    # Calculate tax
    paying_tax <- current_salary > adjusted_tax_line
    repeater_tracker <- c(repeater_tracker, ifelse(paying_tax, 1, 0))

    if (paying_tax) {
      overage <- current_salary - adjusted_tax_line
      avg_rate <- if (is_repeater) 3.5 else 2.0
      tax_bill <- overage * avg_rate
    } else {
      overage <- 0
      tax_bill <- 0
    }

    results <- bind_rows(
      results,
      tibble(
        year = sprintf("Year %d", year),
        team_salary = current_salary,
        tax_threshold = adjusted_tax_line,
        overage = overage,
        is_repeater = is_repeater,
        tax_bill = tax_bill,
        total_cost = current_salary + tax_bill
      )
    )
  }

  results %>%
    mutate(cumulative_tax = cumsum(tax_bill))
}


#' Compare different tax management strategies
#'
#' @param strategies List of strategy data frames
#' @return Comparison tibble
compare_tax_strategies <- function(strategies) {
  results <- map_dfr(strategies, function(strategy) {
    name <- strategy$name
    salaries <- strategy$salaries

    total_tax <- 0
    repeater_tracker <- numeric(0)

    for (year in seq_along(salaries)) {
      salary <- salaries[year]
      year_cap_growth <- (1 + CAP_GROWTH_RATE) ^ (year - 1)
      adjusted_tax_line <- LUXURY_TAX * year_cap_growth

      is_repeater <- if (length(repeater_tracker) >= 4) {
        sum(tail(repeater_tracker, 4)) >= 3
      } else {
        FALSE
      }

      if (salary > adjusted_tax_line) {
        repeater_tracker <- c(repeater_tracker, 1)
        overage <- salary - adjusted_tax_line
        avg_rate <- if (is_repeater) 3.5 else 2.0
        total_tax <- total_tax + (overage * avg_rate)
      } else {
        repeater_tracker <- c(repeater_tracker, 0)
      }
    }

    tibble(
      strategy = name,
      total_tax_paid = total_tax,
      avg_annual_tax = total_tax / length(salaries),
      years_paying_tax = sum(repeater_tracker),
      became_repeater = if (length(repeater_tracker) >= 4) {
        sum(tail(repeater_tracker, 4)) >= 3
      } else {
        FALSE
      }
    )
  }) %>%
    arrange(total_tax_paid)

  results
}


#' Visualize tax bill comparison across scenarios
#'
#' @param team_salaries Vector of team salaries
#' @param labels Labels for each scenario
visualize_tax_scenarios <- function(team_salaries, labels) {
  # Calculate tax bills
  data <- map2_dfr(team_salaries, labels, function(salary, label) {
    regular <- calculate_luxury_tax_detailed(salary, is_repeater = FALSE)
    repeater <- calculate_luxury_tax_detailed(salary, is_repeater = TRUE)

    tibble(
      scenario = label,
      salary = salary,
      tax_regular = regular$tax_bill,
      tax_repeater = repeater$tax_bill,
      total_regular = regular$total_cost,
      total_repeater = repeater$total_cost
    )
  })

  # Tax bill plot
  p1 <- data %>%
    pivot_longer(
      cols = c(tax_regular, tax_repeater),
      names_to = "type",
      values_to = "tax_bill"
    ) %>%
    mutate(
      type = recode(type,
                    "tax_regular" = "Non-Repeater",
                    "tax_repeater" = "Repeater"),
      scenario = factor(scenario, levels = labels)
    ) %>%
    ggplot(aes(x = scenario, y = tax_bill / 1e6, fill = type)) +
    geom_col(position = "dodge", width = 0.7) +
    scale_fill_manual(values = c("Non-Repeater" = "#1f77b4", "Repeater" = "#ff7f0e")) +
    labs(
      title = "Luxury Tax Bills by Scenario",
      x = "Scenario",
      y = "Tax Bill (Millions)",
      fill = "Tax Status"
    ) +
    theme_minimal() +
    theme(
      plot.title = element_text(size = 14, face = "bold"),
      axis.text.x = element_text(angle = 45, hjust = 1),
      legend.position = "top"
    )

  # Total cost plot
  p2 <- data %>%
    pivot_longer(
      cols = c(total_regular, total_repeater),
      names_to = "type",
      values_to = "total_cost"
    ) %>%
    mutate(
      type = recode(type,
                    "total_regular" = "Non-Repeater",
                    "total_repeater" = "Repeater"),
      scenario = factor(scenario, levels = labels)
    ) %>%
    ggplot(aes(x = scenario, y = total_cost / 1e6, fill = type)) +
    geom_col(position = "dodge", width = 0.7) +
    geom_hline(yintercept = LUXURY_TAX / 1e6, linetype = "dashed",
               color = "red", size = 0.8) +
    scale_fill_manual(values = c("Non-Repeater" = "#1f77b4", "Repeater" = "#ff7f0e")) +
    labs(
      title = "Total Team Cost (Salary + Tax)",
      x = "Scenario",
      y = "Total Cost (Millions)",
      fill = "Tax Status"
    ) +
    theme_minimal() +
    theme(
      plot.title = element_text(size = 14, face = "bold"),
      axis.text.x = element_text(angle = 45, hjust = 1),
      legend.position = "top"
    )

  # Combine plots
  combined <- p1 + p2

  ggsave("tax_strategy_comparison_r.png", combined,
         width = 14, height = 6, dpi = 300)

  combined
}


#' Visualize multi-year tax projection
#'
#' @param projection_data Tibble from simulate_repeater_scenarios
visualize_projection <- function(projection_data) {
  p <- projection_data %>%
    ggplot(aes(x = year)) +
    geom_col(aes(y = tax_bill / 1e6, fill = is_repeater), width = 0.6) +
    geom_line(aes(y = team_salary / 1e6, group = 1),
              color = "darkblue", size = 1.2, linetype = "dashed") +
    geom_point(aes(y = team_salary / 1e6), color = "darkblue", size = 3) +
    scale_fill_manual(
      values = c("FALSE" = "#2ecc71", "TRUE" = "#e74c3c"),
      labels = c("Non-Repeater", "Repeater")
    ) +
    labs(
      title = "Five-Year Luxury Tax Projection",
      subtitle = "Bars = Tax Bill | Line = Team Salary",
      x = "Year",
      y = "Amount (Millions)",
      fill = "Tax Status"
    ) +
    theme_minimal() +
    theme(
      plot.title = element_text(size = 14, face = "bold"),
      legend.position = "top"
    )

  ggsave("multi_year_projection.png", p, width = 10, height = 6, dpi = 300)

  p
}


# Example Usage
main <- function() {
  cat("=" %s+% "60" %s+% "\n")
  cat("NBA LUXURY TAX STRATEGY ANALYSIS\n")
  cat("=" %s+% "60" %s+% "\n\n")

  # Example 1: Detailed tax calculation
  cat("1. DETAILED TAX CALCULATION (Warriors-style)\n")
  cat("-" %s+% "60" %s+% "\n")
  warriors_salary <- 207900000
  tax_result <- calculate_luxury_tax_detailed(warriors_salary, is_repeater = TRUE)

  cat(sprintf("Team Salary: %s\n", dollar(tax_result$team_salary)))
  cat(sprintf("Overage: %s\n", dollar(tax_result$overage)))
  cat(sprintf("Tax Bill: %s\n", dollar(tax_result$tax_bill)))
  cat(sprintf("Total Cost: %s\n", dollar(tax_result$total_cost)))
  cat(sprintf("Effective Rate: %.2fx\n\n", tax_result$effective_rate))

  # Example 2: Apron restrictions
  cat("2. APRON RESTRICTIONS CHECK\n")
  cat("-" %s+% "60" %s+% "\n")
  test_salaries <- c(170e6, 175e6, 185e6)
  for (salary in test_salaries) {
    restrictions <- check_apron_restrictions(salary)
    cat(sprintf("\nSalary: %s\n", dollar(salary)))
    cat(sprintf("Restrictions: %d\n", restrictions$num_restrictions))
    for (r in head(restrictions$restrictions, 3)) {
      cat(sprintf("  - %s\n", r))
    }
  }

  # Example 3: Marginal cost
  cat("\n3. MARGINAL COST OF SIGNING PLAYER\n")
  cat("-" %s+% "60" %s+% "\n")
  marginal <- calculate_marginal_cost(170e6, 15e6, is_repeater = FALSE)
  print(marginal)

  # Example 4: Five-year projection
  cat("\n4. FIVE-YEAR TAX PROJECTION\n")
  cat("-" %s+% "60" %s+% "\n")
  projection <- simulate_repeater_scenarios(
    team_salary = 175e6,
    years = 5,
    salary_changes = c(5e6, 3e6, -2e6, 4e6, 0)
  )
  print(projection)

  # Visualize projection
  visualize_projection(projection)

  # Example 5: Strategy comparison
  cat("\n5. TAX STRATEGY COMPARISON\n")
  cat("-" %s+% "60" %s+% "\n")
  strategies <- list(
    list(name = "All-In (Pay Every Year)",
         salaries = c(180e6, 185e6, 190e6, 192e6, 195e6)),
    list(name = "Strategic Gap (Reset Year 3)",
         salaries = c(180e6, 185e6, 160e6, 190e6, 195e6)),
    list(name = "Conservative (Below Tax)",
         salaries = c(160e6, 162e6, 164e6, 166e6, 168e6))
  )

  comparison <- compare_tax_strategies(strategies)
  print(comparison)

  # Example 6: Visualization
  cat("\n6. GENERATING VISUALIZATIONS...\n")
  cat("-" %s+% "60" %s+% "\n")
  scenarios <- c(150e6, 165e6, 172e6, 180e6, 190e6, 210e6)
  labels <- c("Under Tax", "At Tax", "First Apron", "Light Tax", "Heavy Tax", "Max Tax")
  visualize_tax_scenarios(scenarios, labels)

  cat("\nAnalysis complete! Check PNG files for visualizations.\n")
}

# Run analysis
main()