import pandas as pd
import numpy as np
import yfinance as yf

class DCFModel:
    """Full DCF valuation model for any company."""
    
    def __init__(self, ticker, risk_free_rate=0.07, market_premium=0.08,
                 terminal_growth=0.03, projection_years=5):
        self.ticker = ticker
        self.rf = risk_free_rate          # India 10Y govt bond ~7%
        self.market_premium = market_premium  # Equity risk premium ~8%
        self.g_term = terminal_growth     # 3% perpetual growth
        self.n_years = projection_years
        self.stock = yf.Ticker(ticker)
    
    def calculate_beta(self):
        """Calculate beta from 2-year weekly returns vs Nifty 50."""
        # Download stock and Nifty data
        stock_data = self.stock.history(period="2y")
        nifty = yf.Ticker("^NSEI").history(period="2y")
        
        # Weekly returns
        stock_weekly = stock_data['Close'].resample('W').last().pct_change().dropna()
        nifty_weekly = nifty['Close'].resample('W').last().pct_change().dropna()
        
        # Align dates
        aligned = pd.concat([stock_weekly, nifty_weekly], axis=1, join='inner')
        aligned.columns = ['stock', 'market']
        
        # Beta = Cov(stock, market) / Var(market)
        cov_matrix = aligned.cov()
        self.beta = cov_matrix.loc['stock', 'market'] / cov_matrix.loc['market', 'market']
        return self.beta
    
    def calculate_wacc(self, tax_rate=0.2517):
        """Calculate WACC using CAPM for cost of equity."""
        # Cost of Equity (CAPM)
        self.cost_of_equity = self.rf + self.beta * self.market_premium
        
        # Simplified: assume cost of debt = risk-free + 2% spread
        self.cost_of_debt = self.rf + 0.02
        
        # Get market cap and debt from yfinance
        info = self.stock.info
        market_cap = info.get('marketCap', 0)
        total_debt = info.get('totalDebt', 0)
        
        if market_cap == 0:
            # Fallback: use 70% equity, 30% debt
            equity_weight = 0.70
        else:
            total_capital = market_cap + total_debt
            equity_weight = market_cap / total_capital if total_capital > 0 else 0.70
        
        debt_weight = 1 - equity_weight
        
        self.wacc = (equity_weight * self.cost_of_equity + 
                     debt_weight * self.cost_of_debt * (1 - tax_rate))
        
        print(f"  Beta:              {self.beta:.3f}")
        print(f"  Cost of Equity:    {self.cost_of_equity*100:.2f}%")
        print(f"  Cost of Debt:      {self.cost_of_debt*100:.2f}%")
        print(f"  Equity Weight:     {equity_weight*100:.1f}%")
        print(f"  Debt Weight:       {debt_weight*100:.1f}%")
        print(f"  WACC:              {self.wacc*100:.2f}%")
        
        return self.wacc
    
    def project_fcfs(self, base_ebitda, ebitda_margin, growth_rates,
                     capex_pct, dnwc_pct, tax_rate=0.2517, da_pct=0.03):
        """Project Free Cash Flows from revenue assumptions."""
        projections = []
        
        for i, growth in enumerate(growth_rates):
            year = i + 1
            revenue = base_ebitda * (1 + growth)
            ebitda = revenue * ebitda_margin
            ebit = ebitda - (revenue * da_pct)  # EBIT after D&A
            tax = ebit * tax_rate
            nopat = ebit - tax
            capex = revenue * capex_pct
            dnwc = revenue * dnwc_pct
            fcf = nopat + (revenue * da_pct) - capex - dnwc  # Add back D&A
            
            projections.append({
                'Year': year,
                'Revenue': round(revenue, 2),
                'EBITDA': round(ebitda, 2),
                'EBIT': round(ebit, 2),
                'Tax': round(tax, 2),
                'NOPAT': round(nopat, 2),
                'CapEx': round(capex, 2),
                'dNWC': round(dnwc, 2),
                'FCF': round(fcf, 2)
            })
        
        self.projections = pd.DataFrame(projections)
        self.fcfs = self.projections['FCF'].tolist()
        return self.projections
    
    def value(self, shares_outstanding, net_debt=0, exit_multiple=None):
        """Calculate Enterprise Value, Equity Value, and Per-Share Value."""
        # PV of projected FCFs
        pv_fcfs = [fcf / (1 + self.wacc)**t for t, fcf in enumerate(self.fcfs, 1)]
        sum_pv_fcfs = sum(pv_fcfs)
        
        # Terminal Value — Gordon Growth
        terminal_fcf = self.fcfs[-1] * (1 + self.g_term)
        tv_gordon = terminal_fcf / (self.wacc - self.g_term)
        pv_tv_gordon = tv_gordon / (1 + self.wacc)**self.n_years
        
        # Terminal Value — Exit Multiple (if provided)
        if exit_multiple:
            tv_multiple = self.projections['EBITDA'].iloc[-1] * exit_multiple
            pv_tv_multiple = tv_multiple / (1 + self.wacc)**self.n_years
        else:
            tv_multiple = None
            pv_tv_multiple = None
        
        # Use Gordon Growth as primary
        ev = sum_pv_fcfs + pv_tv_gordon
        equity_value = ev - net_debt
        price_per_share = equity_value / shares_outstanding
        
        self.results = {
            'sum_pv_fcfs': sum_pv_fcfs,
            'tv_gordon': tv_gordon,
            'pv_tv_gordon': pv_tv_gordon,
            'tv_multiple': tv_multiple,
            'pv_tv_multiple': pv_tv_multiple,
            'enterprise_value': ev,
            'net_debt': net_debt,
            'equity_value': equity_value,
            'shares': shares_outstanding,
            'price_per_share': price_per_share,
            'pv_fcfs': pv_fcfs
        }
        return self.results
    
    def summary(self):
        """Print professional valuation summary."""
        r = self.results
        print("=" * 60)
        print(f"DCF VALUATION: {self.ticker}")
        print("=" * 60)
        print(f"WACC:                    {self.wacc*100:.2f}%")
        print(f"Terminal Growth:         {self.g_term*100:.2f}%")
        print(f"")
        print(f"PV of FCFs:              ₹{r['sum_pv_fcfs']:>12,.2f} Cr")
        print(f"Terminal Value (Gordon): ₹{r['tv_gordon']:>12,.2f} Cr")
        print(f"PV of Terminal Value:    ₹{r['pv_tv_gordon']:>12,.2f} Cr")
        if r['tv_multiple']:
            print(f"Terminal Value (Exit):   ₹{r['tv_multiple']:>12,.2f} Cr")
            print(f"PV of Terminal (Exit):   ₹{r['pv_tv_multiple']:>12,.2f} Cr")
        print(f"")
        print(f"Enterprise Value:        ₹{r['enterprise_value']:>12,.2f} Cr")
        print(f"Less: Net Debt:          ₹{r['net_debt']:>12,.2f} Cr")
        print(f"Equity Value:            ₹{r['equity_value']:>12,.2f} Cr")
        print(f"Shares Outstanding:      {r['shares']:>12,.2f} Cr")
        print(f"Implied Share Price:     ₹{r['price_per_share']:>12,.2f}")
        print("=" * 60)
        
        print("\nProjected FCFs:")
        print(self.projections[['Year','Revenue','EBITDA','FCF']].to_string(index=False))

# ========================================
# RUN THE MODEL
# ========================================
model = DCFModel("TATAMOTORS.NS")

print("Step 1: Calculating Beta from market data...")
beta = model.calculate_beta()

print("\nStep 2: Calculating WACC...")
wacc = model.calculate_wacc()

print("\nStep 3: Projecting FCFs...")
# Assumptions for Tata Motors (₹ Cr)
projections = model.project_fcfs(
    base_ebitda=160000,        # ~₹1,60,000 Cr base EBITDA
    ebitda_margin=0.12,        # 12% EBITDA margin
    growth_rates=[0.08, 0.10, 0.12, 0.10, 0.08],  # Revenue growth
    capex_pct=0.05,            # CapEx = 5% of revenue
    dnwc_pct=0.01,             # Change in NWC = 1% of revenue
    da_pct=0.03                # D&A = 3% of revenue
)

print("\nStep 4: Calculating Valuation...")
results = model.value(
    shares_outstanding=368,    # 368 Cr shares
    net_debt=80000,            # ₹80,000 Cr net debt
    exit_multiple=6.0          # 6x EV/EBITDA exit multiple
)

print("\n")
model.summary()

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

def sensitivity_analysis(fcfs, wacc_range, growth_range, net_debt, shares):
    """
    Two-way sensitivity: Share Price vs WACC and Terminal Growth.
    """
    results = []
    
    for wacc in wacc_range:
        row = {}
        for g_term in growth_range:
            # PV of FCFs
            pv_fcfs = sum(f / (1 + wacc)**t for t, f in enumerate(fcfs, 1))
            
            # Terminal Value (Gordon Growth)
            terminal_fcf = fcfs[-1] * (1 + g_term)
            tv = terminal_fcf / (wacc - g_term)
            pv_tv = tv / (1 + wacc)**len(fcfs)
            
            # Equity Value & Share Price
            ev = pv_fcfs + pv_tv
            equity = ev - net_debt
            price = equity / shares
            
            row[f"{g_term*100:.1f}%"] = round(price, 2)
        results.append(row)
    
    df = pd.DataFrame(results, index=[f"{w*100:.1f}%" for w in wacc_range])
    df.index.name = "WACC \\ Growth"
    return df

# Define ranges
wacc_range = np.arange(0.10, 0.185, 0.01)    # 10% to 18%
growth_range = np.arange(0.01, 0.055, 0.01)   # 1% to 5%

# Using Tata Motors FCFs from Section 1
fcfs = [8640.0, 11616.0, 15360.0, 16128.0, 15360.0]  # Example FCFs

sensitivity = sensitivity_analysis(
    fcfs=fcfs,
    wacc_range=wacc_range,
    growth_range=growth_range,
    net_debt=80000,
    shares=368
)

print("SENSITIVITY TABLE: Implied Share Price (₹)")
print("=" * 60)
print(sensitivity.to_string())

# ========================================
# HEATMAP VISUALIZATION
# ========================================
fig, ax = plt.subplots(figsize=(10, 7))

# Convert to numpy array for heatmap
data = sensitivity.values.astype(float)

im = ax.imshow(data, cmap='RdYlGn', aspect='auto')
ax.set_xticks(range(len(sensitivity.columns)))
ax.set_xticklabels(sensitivity.columns, fontsize=10)
ax.set_yticks(range(len(sensitivity.index)))
ax.set_yticklabels(sensitivity.index, fontsize=10)
ax.set_xlabel('Terminal Growth Rate', fontsize=12, fontweight='bold')
ax.set_ylabel('WACC', fontsize=12, fontweight='bold')
ax.set_title('DCF Sensitivity: Implied Share Price (₹)\nTata Motors', 
             fontsize=14, fontweight='bold', pad=15)

# Add value annotations
for i in range(len(sensitivity.index)):
    for j in range(len(sensitivity.columns)):
        val = data[i, j]
        color = 'white' if abs(val) > 300 else 'black'
        ax.text(j, i, f'₹{val:.0f}', ha='center', va='center', 
                fontsize=9, fontweight='bold', color=color)

plt.colorbar(im, label='Share Price (₹)', shrink=0.8)
plt.tight_layout()
plt.savefig('sensitivity_heatmap.png', dpi=150, bbox_inches='tight')
plt.show()
print("\n✅ Heatmap saved as sensitivity_heatmap.png")

import pandas as pd

def scenario_dcf(scenarios, wacc=0.1467, g_term=0.03, net_debt=80000, shares=368):
    """Run multiple DCF scenarios and probability-weight them."""
    results = []
    
    for name, params in scenarios.items():
        # Project FCFs
        fcfs = []
        base = params['base_revenue']
        for i in range(5):
            base = base * (1 + params['growth_rates'][i])
            ebitda = base * params['ebitda_margin']
            fcf = ebitda * params['fcf_conversion']  # Simplified
            fcfs.append(fcf)
        
        # DCF Calculation
        pv_fcfs = sum(f / (1 + wacc)**t for t, f in enumerate(fcfs, 1))
        tv = fcfs[-1] * (1 + g_term) / (wacc - g_term)
        pv_tv = tv / (1 + wacc)**5
        ev = pv_fcfs + pv_tv
        equity = ev - net_debt
        price = equity / shares
        
        results.append({
            'Scenario': name,
            'Probability': f"{params['probability']*100:.0f}%",
            'Revenue Y5': round(base, 0),
            'FCF Y5': round(fcfs[-1], 0),
            'EV': round(ev, 0),
            'Equity': round(equity, 0),
            'Share Price': round(price, 2),
            'Prob-Weighted Price': round(price * params['probability'], 2)
        })
    
    df = pd.DataFrame(results)
    
    # Add probability-weighted average
    weighted_avg = df['Prob-Weighted Price'].sum()
    total_row = pd.DataFrame([{
        'Scenario': 'WEIGHTED AVERAGE',
        'Probability': '100%',
        'Revenue Y5': '-',
        'FCF Y5': '-',
        'EV': '-',
        'Equity': '-',
        'Share Price': '-',
        'Prob-Weighted Price': round(weighted_avg, 2)
    }])
    
    df = pd.concat([df, total_row], ignore_index=True)
    return df

# Define scenarios
scenarios = {
    '🐂 Bull': {
        'base_revenue': 450000,
        'growth_rates': [0.12, 0.15, 0.18, 0.15, 0.12],
        'ebitda_margin': 0.14,
        'fcf_conversion': 0.40,
        'probability': 0.25
    },
    '📊 Base': {
        'base_revenue': 420000,
        'growth_rates': [0.08, 0.10, 0.12, 0.10, 0.08],
        'ebitda_margin': 0.12,
        'fcf_conversion': 0.35,
        'probability': 0.50
    },
    '🐻 Bear': {
        'base_revenue': 400000,
        'growth_rates': [0.03, 0.04, 0.05, 0.04, 0.03],
        'ebitda_margin': 0.09,
        'fcf_conversion': 0.25,
        'probability': 0.25
    }
}

results = scenario_dcf(scenarios)
print("SCENARIO ANALYSIS — Tata Motors DCF")
print("=" * 80)
print(results.to_string(index=False))

import matplotlib.pyplot as plt
import numpy as np

# ========================================
# CHART 1: Waterfall — DCF Value Bridge
# ========================================
def waterfall_chart(categories, values, title="DCF Value Bridge"):
    """Create a professional waterfall chart."""
    fig, ax = plt.subplots(figsize=(12, 6))
    
    # Calculate cumulative positions
    cumulative = [0]
    for v in values[:-1]:
        cumulative.append(cumulative[-1] + v)
    
    # Colors: green for positive, red for negative, blue for totals
    colors = []
    for i, v in enumerate(values):
        if i == 0:  # First item (PV of FCFs)
            colors.append('#2563EB')
        elif i == len(values) - 1:  # Last item (total)
            colors.append('#1E3A5F')
        elif v >= 0:
            colors.append('#10B981')
        else:
            colors.append('#EF4444')
    
    # Draw bars
    bottoms = []
    for i in range(len(values)):
        if i == 0:
            bottoms.append(0)
        elif i == len(values) - 1:
            bottoms.append(0)
        else:
            bottoms.append(cumulative[i] if values[i] >= 0 else cumulative[i] + values[i])
    
    bars = ax.bar(categories, [abs(v) for v in values], bottom=bottoms, 
                  color=colors, edgecolor='white', linewidth=1.5, width=0.6)
    
    # Add value labels
    for i, (bar, val) in enumerate(zip(bars, values)):
        y_pos = bar.get_y() + bar.get_height() + 500
        label = f'₹{val:,.0f}' if val > 0 else f'-₹{abs(val):,.0f}'
        ax.text(bar.get_x() + bar.get_width()/2, y_pos, label,
                ha='center', va='bottom', fontweight='bold', fontsize=10)
    
    # Connector lines
    for i in range(len(values) - 2):
        x1 = i + 0.3
        x2 = i + 0.7
        y = cumulative[i + 1]
        ax.plot([x1, x2], [y, y], color='gray', linewidth=1, linestyle='--')
    
    ax.set_title(title, fontsize=14, fontweight='bold', pad=15)
    ax.set_ylabel('Value (₹ Cr)', fontsize=12)
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.grid(axis='y', alpha=0.3)
    plt.tight_layout()
    plt.savefig('dcf_waterfall.png', dpi=150, bbox_inches='tight')
    plt.show()

# DCF Value Bridge data
categories = ['PV of\nFCFs', 'PV of Terminal\nValue', 'Enterprise\nValue', 'Net\nDebt', 'Equity\nValue']
values = [12845, 72346, 0, -80000, 0]

# Recalculate: EV = PV FCFs + PV TV, Equity = EV - Debt
values[2] = values[0] + values[1]  # EV
values[4] = values[2] + values[3]  # Equity Value

waterfall_chart(categories, values, "DCF Value Bridge — Tata Motors (₹ Cr)")

# ========================================
# CHART 2: Peer Comparison — Bar Chart
# ========================================
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

peers = ['Tata Motors', 'M&M', 'Maruti', 'Ashok Leyland']
colors = ['#2563EB', '#10B981', '#F59E0B', '#EF4444']

# P/E Ratio
pe_ratios = [28.5, 32.1, 35.8, 24.2]
axes[0].barh(peers, pe_ratios, color=colors)
axes[0].set_title('P/E Ratio', fontweight='bold')
axes[0].set_xlabel('x')
for i, v in enumerate(pe_ratios):
    axes[0].text(v + 0.3, i, f'{v:.1f}x', va='center', fontweight='bold')

# EV/EBITDA
ev_ebitda = [8.2, 14.5, 12.3, 7.8]
axes[1].barh(peers, ev_ebitda, color=colors)
axes[1].set_title('EV/EBITDA', fontweight='bold')
axes[1].set_xlabel('x')
for i, v in enumerate(ev_ebitda):
    axes[1].text(v + 0.2, i, f'{v:.1f}x', va='center', fontweight='bold')

# Revenue Growth %
growth = [15.2, 18.5, 12.1, 22.8]
axes[2].barh(peers, growth, color=colors)
axes[2].set_title('Revenue Growth %', fontweight='bold')
axes[2].set_xlabel('%')
for i, v in enumerate(growth):
    axes[2].text(v + 0.3, i, f'{v:.1f}%', va='center', fontweight='bold')

for ax in axes:
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.grid(axis='x', alpha=0.3)

fig.suptitle('Auto Sector — Comparable Company Analysis', 
             fontsize=14, fontweight='bold', y=1.02)
plt.tight_layout()
plt.savefig('peer_comparison.png', dpi=150, bbox_inches='tight')
plt.show()
print("✅ Charts saved: dcf_waterfall.png, peer_comparison.png")