#!/usr/bin/env python3
"""
UTXO Consolidation Economics Visualizer
Demonstrates economic models for UTXO consolidation strategies
"""

import json
import math
from typing import Dict, List, Optional, Any, Tuple
from dataclasses import dataclass
from datetime import datetime

@dataclass
class ConsolidationScenario:
    """UTXO consolidation scenario parameters"""
    num_utxos: int
    average_value: int
    script_type: str
    fee_rate: float
    target_outputs: int

class ConsolidationEconomics:
    """UTXO consolidation economic analysis and visualization"""
    
    def __init__(self):
        self.script_types = ['p2pkh', 'p2wpkh', 'p2tr']
        
        # Map script types for consolidation
        self.script_type_map = {
            'legacy': 'p2pkh',
            'segwit': 'p2wpkh', 
            'taproot': 'p2tr'
        }
        self.fee_rates = [1.0, 2.5, 5.0, 10.0, 25.0, 50.0]
        
        # Transaction size estimates (vbytes)
        self.tx_sizes = {
            'p2pkh': {'input': 148, 'output': 34, 'base': 10},
            'p2wpkh': {'input': 68, 'output': 31, 'base': 11},
            'p2tr': {'input': 64, 'output': 43, 'base': 11}
        }
        
        # Dust thresholds
        self.dust_thresholds = {
            'p2pkh': 546,
            'p2wpkh': 294,
            'p2tr': 330
        }
    
    def calculate_consolidation_cost(self, scenario: ConsolidationScenario) -> Dict[str, Any]:
        """Calculate cost and economics of consolidation"""
        
        # Map script type
        script_type = self.script_type_map.get(scenario.script_type, scenario.script_type)
        
        # Transaction size calculation
        input_size = scenario.num_utxos * self.tx_sizes[script_type]['input']
        output_size = scenario.target_outputs * self.tx_sizes[script_type]['output']
        total_size = input_size + output_size + self.tx_sizes[script_type]['base']
        
        # Fee calculation
        consolidation_fee = math.ceil(total_size * scenario.fee_rate)
        
        # Value calculations
        total_input_value = scenario.num_utxos * scenario.average_value
        net_output_value = total_input_value - consolidation_fee
        
        # Individual spending cost (for comparison)
        individual_tx_size = self.tx_sizes[script_type]['input'] + \
                           self.tx_sizes[script_type]['output'] + \
                           self.tx_sizes[script_type]['base']
        individual_fee = math.ceil(individual_tx_size * scenario.fee_rate)
        total_individual_cost = scenario.num_utxos * individual_fee
        
        # Economic analysis
        fee_savings = total_individual_cost - consolidation_fee
        savings_percentage = (fee_savings / total_individual_cost * 100) if total_individual_cost > 0 else 0
        
        # Break-even analysis
        fee_per_utxo = consolidation_fee / scenario.num_utxos
        is_economical = fee_savings > 0
        break_even_utxos = math.ceil(consolidation_fee / individual_fee) if individual_fee > 0 else float('inf')
        
        # Efficiency metrics
        fee_percentage = (consolidation_fee / total_input_value * 100) if total_input_value > 0 else 100
        consolidation_efficiency = 'high' if fee_percentage < 5 else 'medium' if fee_percentage < 15 else 'low'
        
        return {
            'scenario': {
                'num_utxos': scenario.num_utxos,
                'average_value': scenario.average_value,
                'script_type': scenario.script_type,
                'fee_rate': scenario.fee_rate,
                'target_outputs': scenario.target_outputs
            },
            'costs': {
                'transaction_size': total_size,
                'consolidation_fee': consolidation_fee,
                'individual_fee_per_utxo': individual_fee,
                'total_individual_cost': total_individual_cost,
                'fee_savings': fee_savings,
                'savings_percentage': savings_percentage
            },
            'values': {
                'total_input_value': total_input_value,
                'net_output_value': net_output_value,
                'fee_percentage': fee_percentage
            },
            'economics': {
                'is_economical': is_economical,
                'break_even_utxos': break_even_utxos,
                'fee_per_utxo': fee_per_utxo,
                'consolidation_efficiency': consolidation_efficiency
            }
        }
    
    def generate_consolidation_matrix(self) -> Dict[str, Any]:
        """Generate comprehensive consolidation economics matrix"""
        matrix = {
            'timestamp': datetime.now().isoformat(),
            'script_types': {},
            'summary': {}
        }
        
        # Test different scenarios
        utxo_counts = [2, 3, 5, 10, 15, 20, 25, 50]
        average_values = [1000, 5000, 10000, 25000, 50000, 100000]
        
        for script_type in self.script_types:
            script_matrix = {
                'script_type': script_type,
                'scenarios': []
            }
            
            for fee_rate in self.fee_rates:
                fee_matrix = {
                    'fee_rate': fee_rate,
                    'utxo_counts': []
                }
                
                for num_utxos in utxo_counts:
                    for avg_value in average_values:
                        scenario = ConsolidationScenario(
                            num_utxos=num_utxos,
                            average_value=avg_value,
                            script_type=script_type,
                            fee_rate=fee_rate,
                            target_outputs=1
                        )
                        
                        analysis = self.calculate_consolidation_cost(scenario)
                        fee_matrix['utxo_counts'].append(analysis)
                
                script_matrix['scenarios'].append(fee_matrix)
            
            matrix['script_types'][script_type] = script_matrix
        
        # Generate summary statistics
        matrix['summary'] = self.generate_summary_statistics(matrix)
        
        return matrix
    
    def generate_summary_statistics(self, matrix: Dict[str, Any]) -> Dict[str, Any]:
        """Generate summary statistics for consolidation economics"""
        summary = {
            'optimal_consolidations': {},
            'break_even_analysis': {},
            'fee_sensitivity': {}
        }
        
        for script_type in self.script_types:
            script_data = matrix['script_types'][script_type]
            
            # Find optimal consolidation scenarios
            optimal_scenarios = []
            max_savings = 0
            
            for fee_data in script_data['scenarios']:
                for scenario in fee_data['utxo_counts']:
                    if scenario['economics']['is_economical']:
                        savings = scenario['costs']['savings_percentage']
                        if savings > max_savings:
                            max_savings = savings
                            optimal_scenarios = [scenario]
                        elif savings == max_savings:
                            optimal_scenarios.append(scenario)
            
            summary['optimal_consolidations'][script_type] = {
                'max_savings_percentage': max_savings,
                'optimal_scenarios': optimal_scenarios[:5]  # Top 5
            }
            
            # Break-even analysis
            break_even_data = []
            for fee_data in script_data['scenarios']:
                fee_rate = fee_data['fee_rate']
                for scenario in fee_data['utxo_counts']:
                    if scenario['scenario']['num_utxos'] == 2:  # Focus on 2-UTXO cases
                        break_even_data.append({
                            'fee_rate': fee_rate,
                            'average_value': scenario['scenario']['average_value'],
                            'break_even_utxos': scenario['economics']['break_even_utxos'],
                            'is_economical': scenario['economics']['is_economical']
                        })
            
            summary['break_even_analysis'][script_type] = break_even_data
        
        return summary
    
    def create_visualization_data(self) -> Dict[str, Any]:
        """Create data structures for visualization"""
        viz_data = {
            'timestamp': datetime.now().isoformat(),
            'charts': {}
        }
        
        # Fee sensitivity chart
        fee_sensitivity = {
            'chart_type': 'fee_sensitivity',
            'title': 'Consolidation Savings vs Fee Rate',
            'data': {}
        }
        
        for script_type in self.script_types:
            chart_data = []
            
            for fee_rate in self.fee_rates:
                scenario = ConsolidationScenario(
                    num_utxos=10,
                    average_value=10000,
                    script_type=script_type,
                    fee_rate=fee_rate,
                    target_outputs=1
                )
                
                analysis = self.calculate_consolidation_cost(scenario)
                chart_data.append({
                    'fee_rate': fee_rate,
                    'savings_percentage': analysis['costs']['savings_percentage'],
                    'is_economical': analysis['economics']['is_economical']
                })
            
            fee_sensitivity['data'][script_type] = chart_data
        
        viz_data['charts']['fee_sensitivity'] = fee_sensitivity
        
        # UTXO count efficiency chart
        utxo_efficiency = {
            'chart_type': 'utxo_efficiency',
            'title': 'Consolidation Efficiency vs UTXO Count',
            'data': {}
        }
        
        for script_type in self.script_types:
            chart_data = []
            
            for num_utxos in range(2, 21):
                scenario = ConsolidationScenario(
                    num_utxos=num_utxos,
                    average_value=10000,
                    script_type=script_type,
                    fee_rate=5.0,
                    target_outputs=1
                )
                
                analysis = self.calculate_consolidation_cost(scenario)
                chart_data.append({
                    'num_utxos': num_utxos,
                    'savings_percentage': analysis['costs']['savings_percentage'],
                    'fee_percentage': analysis['values']['fee_percentage'],
                    'is_economical': analysis['economics']['is_economical']
                })
            
            utxo_efficiency['data'][script_type] = chart_data
        
        viz_data['charts']['utxo_efficiency'] = utxo_efficiency
        
        # Value distribution chart
        value_distribution = {
            'chart_type': 'value_distribution',
            'title': 'Consolidation Economics by UTXO Value',
            'data': {}
        }
        
        for script_type in self.script_types:
            chart_data = []
            
            for avg_value in [1000, 2500, 5000, 10000, 25000, 50000, 100000]:
                scenario = ConsolidationScenario(
                    num_utxos=5,
                    average_value=avg_value,
                    script_type=script_type,
                    fee_rate=5.0,
                    target_outputs=1
                )
                
                analysis = self.calculate_consolidation_cost(scenario)
                chart_data.append({
                    'average_value': avg_value,
                    'savings_percentage': analysis['costs']['savings_percentage'],
                    'fee_percentage': analysis['values']['fee_percentage'],
                    'is_economical': analysis['economics']['is_economical']
                })
            
            value_distribution['data'][script_type] = chart_data
        
        viz_data['charts']['value_distribution'] = value_distribution
        
        return viz_data
    
    def find_optimal_consolidation_strategy(self, total_utxos: int, 
                                          total_value: int, script_type: str) -> Dict[str, Any]:
        """Find optimal consolidation strategy for given UTXO set"""
        
        strategies = []
        
        # Test different numbers of target outputs
        for target_outputs in [1, 2, 3, 5]:
            average_value = total_value // total_utxos
            
            scenario = ConsolidationScenario(
                num_utxos=total_utxos,
                average_value=average_value,
                script_type=script_type,
                fee_rate=5.0,  # Standard fee rate
                target_outputs=target_outputs
            )
            
            analysis = self.calculate_consolidation_cost(scenario)
            strategies.append({
                'target_outputs': target_outputs,
                'analysis': analysis
            })
        
        # Find best strategy
        best_strategy = max(strategies, key=lambda x: x['analysis']['costs']['savings_percentage'])
        
        return {
            'total_utxos': total_utxos,
            'total_value': total_value,
            'script_type': script_type,
            'strategies': strategies,
            'recommended_strategy': best_strategy
        }

def main():
    """Run consolidation economics analysis"""
    economics = ConsolidationEconomics()
    
    # Generate comprehensive analysis
    consolidation_matrix = economics.generate_consolidation_matrix()
    visualization_data = economics.create_visualization_data()
    
    # Test optimal strategy finder
    optimal_strategy = economics.find_optimal_consolidation_strategy(15, 75000, 'p2wpkh')
    
    # Example scenario
    example_scenario = ConsolidationScenario(
        num_utxos=8,
        average_value=12500,
        script_type='p2wpkh',
        fee_rate=5.0,
        target_outputs=1
    )
    example_analysis = economics.calculate_consolidation_cost(example_scenario)
    
    results = {
        'consolidation_matrix': consolidation_matrix,
        'visualization_data': visualization_data,
        'optimal_strategy_example': optimal_strategy,
        'example_analysis': example_analysis
    }
    
    # Save results
    with open('consolidation_economics.json', 'w') as f:
        json.dump(results, f, indent=2)
    
    print("✅ Consolidation economics analysis complete")
    print(f"📊 Analyzed {len(consolidation_matrix['script_types'])} script types")
    print(f"💰 Example savings: {example_analysis['costs']['savings_percentage']:.1f}%")
    print(f"🎯 Recommended outputs: {optimal_strategy['recommended_strategy']['target_outputs']}")
    
    return results

if __name__ == "__main__":
    main()