# 月間コスト計算
def calculate_cloud_cost(gpu_hours, storage_tb, experiments):
    gpu_cost = gpu_hours * 3.06  # p3.2xlarge
    storage_cost = storage_tb * 23  # S3 standard
    experiment_cost = experiments * 50  # SageMaker jobs
    
    total = gpu_cost + storage_cost + experiment_cost
    return {
        'gpu': gpu_cost,
        'storage': storage_cost,
        'experiments': experiment_cost,
        'total': total
    }

# 使用例
monthly_usage = calculate_cloud_cost(
    gpu_hours=500,
    storage_tb=5,
    experiments=20
)
# 結果: {'gpu': 1530, 'storage': 115, 'experiments': 1000, 'total': 2645}

# 初期投資と月間コスト
def calculate_onprem_cost(servers=2, years=3):
    # 初期投資
    server_cost = servers * 15000  # DGX Station相当
    setup_cost = 5000
    initial = server_cost + setup_cost
    
    # 月間運用コスト
    electricity = servers * 200  # 電気代
    maintenance = initial * 0.10 / 12  # 年10%
    cooling = servers * 100
    monthly = electricity + maintenance + cooling
    
    # 3年間の総コスト
    total_cost = initial + (monthly * 12 * years)
    monthly_effective = total_cost / (12 * years)
    
    return {
        'initial': initial,
        'monthly_operating': monthly,
        'monthly_effective': monthly_effective,
        'breakeven_months': initial / (2645 - monthly)  # クラウドとの比較
    }

# 結果: 約18ヶ月で損益分岐点

# 使用率モニタリング
class UsageOptimizer:
    def analyze_github_actions(self, workflow_runs):
        """Actions使用率を分析"""
        total_minutes = sum(run['duration'] for run in workflow_runs)
        billable_minutes = sum(
            run['duration'] * self.get_multiplier(run['os'])
            for run in workflow_runs
        )
        
        optimization = {
            'current_cost': billable_minutes * 0.008,
            'optimized_cost': self.calculate_optimized(workflow_runs),
            'savings': None
        }
        optimization['savings'] = (
            optimization['current_cost'] - optimization['optimized_cost']
        )
        
        return optimization
    
    def calculate_optimized(self, runs):
        """最適化後のコスト計算"""
        # Linux runnersへの移行
        # キャッシュの活用
        # 並列実行の最適化
        return sum(run['duration'] * 0.008 * 0.6 for run in runs)

# アクティブユーザー分析
def optimize_licenses(user_activity_log):
    """非アクティブユーザーを特定"""
    thirty_days_ago = datetime.now() - timedelta(days=30)
    
    inactive_users = []
    for user, last_activity in user_activity_log.items():
        if last_activity < thirty_days_ago:
            inactive_users.append(user)
    
    potential_savings = len(inactive_users) * 21  # Enterprise
    
    return {
        'inactive_users': inactive_users,
        'count': len(inactive_users),
        'potential_monthly_savings': potential_savings,
        'recommendation': 'Downgrade to Team or remove access'
    }

def create_quarterly_budget(team_size, project_phase):
    """四半期予算を計算"""
    
    base_costs = {
        'github_enterprise': team_size * 21 * 3,
        'copilot_business': team_size * 19 * 3,
        'git_lfs': 50 * 3
    }
    
    phase_multipliers = {
        'research': {'compute': 0.5, 'storage': 0.3},
        'development': {'compute': 1.0, 'storage': 0.5},
        'production': {'compute': 1.5, 'storage': 1.0},
        'scaling': {'compute': 2.0, 'storage': 1.5}
    }
    
    compute_base = team_size * 500  # 基本コンピュート費用
    storage_base = team_size * 50   # 基本ストレージ費用
    
    phase_costs = {
        'compute': compute_base * phase_multipliers[project_phase]['compute'],
        'storage': storage_base * phase_multipliers[project_phase]['storage']
    }
    
    total_quarterly = (
        sum(base_costs.values()) + 
        sum(phase_costs.values()) * 3
    )
    
    return {
        'breakdown': {
            **base_costs,
            **{k: v*3 for k, v in phase_costs.items()}
        },
        'total_quarterly': total_quarterly,
        'monthly_average': total_quarterly / 3,
        'per_person': total_quarterly / 3 / team_size
    }

def calculate_ideal_allocation(total_budget):
    """予算の理想的な配分を計算"""
    allocation = {
        'version_control': 0.05,      # GitHub等
        'ai_tools': 0.10,            # Copilot等
        'compute': 0.50,             # GPU/CPU
        'storage': 0.15,             # データ/モデル保存
        'monitoring': 0.10,          # MLOps/監視
        'security': 0.05,            # セキュリティツール
        'contingency': 0.05          # 予備費
    }
    
    return {
        category: total_budget * ratio
        for category, ratio in allocation.items()
    }

# 月間予算$10,000の場合
budget_allocation = calculate_ideal_allocation(10000)
# 結果:
# {
#   'version_control': 500,
#   'ai_tools': 1000,
#   'compute': 5000,
#   'storage': 1500,
#   'monitoring': 1000,
#   'security': 500,
#   'contingency': 500
# }