import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_percentage_error

# ========================================
# STEP 1: Create/Load the Dataset
# ========================================
# Simulated quarterly data for TCS (₹ Cr)
np.random.seed(42)
quarters = pd.date_range('2016-Q1', periods=32, freq='Q')

data = pd.DataFrame({
    'Quarter': quarters,
    'Revenue': [26000, 27500, 29000, 30500,
                31000, 32500, 34200, 36000,
                36500, 38200, 40000, 42000,
                43000, 44800, 46500, 48500,
                49200, 51000, 53000, 55500,
                56200, 58500, 61000, 64000,
                65000, 67000, 69500, 72000,
                73000, 75500, 78000, 81000],
    'GDP_Growth': [7.1, 7.3, 7.0, 7.4, 7.5, 7.2, 7.6, 7.3,
                   6.8, 7.0, 6.9, 7.1, 6.5, 6.7, 6.6, 6.8,
                   6.3, 6.5, 6.4, 6.6, 6.1, 6.3, 6.2, 6.4,
                   5.9, 6.1, 6.0, 6.2, 5.8, 6.0, 5.9, 6.1],
    'IT_Index': [100, 102, 105, 108, 112, 115, 118, 122,
                 128, 132, 136, 140, 148, 153, 158, 163,
                 170, 176, 182, 188, 196, 203, 210, 218,
                 225, 233, 240, 248, 255, 264, 272, 280]
})

# ========================================
# STEP 2: Feature Engineering
# ========================================
# Add time-based features
data['Quarter_Num'] = range(1, len(data) + 1)  # Linear time trend
data['Q_Month'] = data['Quarter'].dt.month  # 3, 6, 9, 12

# Cyclical encoding for quarter seasonality
data['Q_Sin'] = np.sin(2 * np.pi * data['Q_Month'] / 12)
data['Q_Cos'] = np.cos(2 * np.pi * data['Q_Month'] / 12)

# Lag features (previous quarter revenue)
data['Revenue_Lag1'] = data['Revenue'].shift(1)
data['Revenue_Lag4'] = data['Revenue'].shift(4)  # Same quarter last year

# YoY growth
data['Revenue_YoY'] = data['Revenue'].pct_change(4) * 100

# Drop rows with NaN (from lagging)
data_clean = data.dropna().reset_index(drop=True)

print("Feature Correlation with Revenue:")
print("=" * 45)
corr = data_clean[['Revenue', 'GDP_Growth', 'IT_Index', 'Quarter_Num',
                    'Q_Sin', 'Q_Cos', 'Revenue_Lag1', 'Revenue_Lag4']].corr()
print(corr['Revenue'].sort_values(ascending=False).round(3))

# ========================================
# STEP 3: Train-Test Split (Time-Series!)
# ========================================
# IMPORTANT: Never shuffle time-series data!
train = data_clean.iloc[:20]  # First 20 quarters for training
test = data_clean.iloc[20:]   # Last 8 quarters for testing

features = ['GDP_Growth', 'IT_Index', 'Quarter_Num', 'Q_Sin', 'Q_Cos',
            'Revenue_Lag1', 'Revenue_Lag4']

X_train = train[features]
y_train = train['Revenue']
X_test = test[features]
y_test = test['Revenue']

# ========================================
# STEP 4: Train the Model
# ========================================
model = LinearRegression()
model.fit(X_train, y_train)

# Predictions
y_pred_train = model.predict(X_train)
y_pred_test = model.predict(X_test)

# ========================================
# STEP 5: Evaluate
# ========================================
print("\n" + "=" * 50)
print("MODEL PERFORMANCE")
print("=" * 50)
print(f"Training R²:    {r2_score(y_train, y_pred_train):.4f}")
print(f"Test R²:        {r2_score(y_test, y_pred_test):.4f}")
print(f"Test RMSE:      ₹{np.sqrt(mean_squared_error(y_test, y_pred_test)):,.0f} Cr")
print(f"Test MAPE:      {mean_absolute_percentage_error(y_test, y_pred_test)*100:.2f}%")

print("\nFeature Coefficients:")
print("-" * 35)
for feat, coef in sorted(zip(features, model.coef_), key=lambda x: abs(x[1]), reverse=True):
    print(f"  {feat:20s}: {coef:>12,.2f}")
print(f"  {'Intercept':20s}: {model.intercept_:>12,.2f}")

# ========================================
# STEP 6: Visualize — Actual vs Predicted
# ========================================
fig, ax = plt.subplots(figsize=(14, 6))
ax.plot(data_clean['Quarter'], data_clean['Revenue'], 'b-o',
        label='Actual Revenue', linewidth=2, markersize=5)
ax.plot(train['Quarter'], y_pred_train, 'g--',
        label='Training Prediction', linewidth=1.5, alpha=0.7)
ax.plot(test['Quarter'], y_pred_test, 'r-s',
        label='Test Prediction', linewidth=2, markersize=6)

# Forecast next 4 quarters
ax.axvline(x=test['Quarter'].iloc[0], color='gray', linestyle=':', alpha=0.5)
ax.text(test['Quarter'].iloc[0], data_clean['Revenue'].max() * 0.95,
        ' ← Train | Test →', fontsize=10, color='gray')

ax.set_title('TCS Revenue: ML Forecast vs Actual', fontsize=14, fontweight='bold')
ax.set_xlabel('Quarter')
ax.set_ylabel('Revenue (₹ Cr)')
ax.legend(fontsize=11)
ax.grid(alpha=0.3)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
plt.tight_layout()
plt.savefig('revenue_forecast.png', dpi=150, bbox_inches='tight')
plt.show()
print("\n✅ Chart saved: revenue_forecast.png")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.tsa.seasonal import seasonal_decompose

# ========================================
# STEP 1: Create HUL Revenue Data
# ========================================
np.random.seed(42)
quarters = pd.date_range('2018-Q1', periods=24, freq='Q')

# HUL quarterly revenue (₹ Cr) — strong seasonality in FMCG
base_trend = np.linspace(9500, 13500, 24)
seasonality = np.tile([200, -300, 400, -100], 6)  # Q2 dip (pre-monsoon), Q3 peak (festive)
noise = np.random.normal(0, 150, 24)
revenue = base_trend + seasonality + noise

data = pd.Series(revenue, index=quarters, name='Revenue')
data.index.name = 'Quarter'

# ========================================
# STEP 2: Decompose
# ========================================
# Multiplicative decomposition (revenue grows over time)
decomposition = seasonal_decompose(data, model='multiplicative', period=4)

# Plot the decomposition
fig, axes = plt.subplots(4, 1, figsize=(14, 12), sharex=True)

decomposition.observed.plot(ax=axes[0], color='#2563EB', linewidth=2)
axes[0].set_ylabel('Observed')
axes[0].set_title('HUL Revenue — Time Series Decomposition', fontweight='bold', fontsize=14)

decomposition.trend.plot(ax=axes[1], color='#10B981', linewidth=2)
axes[1].set_ylabel('Trend')

decomposition.seasonal.plot(ax=axes[2], color='#F59E0B', linewidth=2)
axes[2].set_ylabel('Seasonal')

decomposition.resid.plot(ax=axes[3], color='#EF4444', linewidth=1.5, marker='o', markersize=4)
axes[3].set_ylabel('Residual')

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

plt.xlabel('Quarter')
plt.tight_layout()
plt.savefig('decomposition.png', dpi=150, bbox_inches='tight')
plt.show()

# ========================================
# STEP 3: Extract Seasonal Indices
# ========================================
seasonal_indices = decomposition.seasonal.groupby(decomposition.seasonal.index.month).mean()
print("\nSeasonal Indices (Multiplicative):")
print("=" * 40)
months = {3: 'Q1 (Jan-Mar)', 6: 'Q2 (Apr-Jun)', 9: 'Q3 (Jul-Sep)', 12: 'Q4 (Oct-Dec)'}
for m, name in months.items():
    idx = seasonal_indices.get(m, 1.0)
    effect = "↑ Above avg" if idx > 1 else "↓ Below avg"
    print(f"  {name}: {idx:.4f}  ({effect})")

# ========================================
# STEP 4: Forecast Next 4 Quarters
# ========================================
# Method: Project trend linearly, then multiply by seasonal index
from sklearn.linear_model import LinearRegression

trend_clean = decomposition.trend.dropna()
X_trend = np.arange(len(trend_clean)).reshape(-1, 1)
y_trend = trend_clean.values

trend_model = LinearRegression()
trend_model.fit(X_trend, y_trend)

# Forecast trend for next 4 quarters
future_X = np.arange(len(trend_clean), len(trend_clean) + 4).reshape(-1, 1)
future_trend = trend_model.predict(future_X)

# Apply seasonal indices
future_months = [3, 6, 9, 12]  # Q1-Q4
future_seasonal = np.array([seasonal_indices.get(m, 1.0) for m in future_months])

forecast = future_trend * future_seasonal

print("\n" + "=" * 50)
print("FORECAST: HUL Revenue — Next 4 Quarters")
print("=" * 50)
forecast_quarters = pd.date_range('2024-Q1', periods=4, freq='Q')
for q, t, s, f in zip(forecast_quarters, future_trend, future_seasonal, forecast):
    print(f"  {q.strftime('%Y-Q%q')}:  Trend=₹{t:,.0f}  ×  Seasonal={s:.4f}  =  ₹{f:,.0f} Cr")

print(f"\nTotal FY2024 Forecast: ₹{sum(forecast):,.0f} Cr")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

def create_financial_features(df, revenue_col='Revenue', date_col='Quarter'):
    """Complete feature engineering pipeline for financial forecasting."""
    
    df = df.copy()
    
    # 1. Time-based features
    df['Quarter_Num'] = range(1, len(df) + 1)
    df['Year'] = df[date_col].dt.year
    df['Qtr'] = df[date_col].dt.quarter
    
    # Cyclical encoding
    df['Q_Sin'] = np.sin(2 * np.pi * df['Qtr'] / 4)
    df['Q_Cos'] = np.cos(2 * np.pi * df['Qtr'] / 4)
    
    # 2. Lag features (autocorrelation)
    df[f'{revenue_col}_Lag1'] = df[revenue_col].shift(1)   # Previous quarter
    df[f'{revenue_col}_Lag2'] = df[revenue_col].shift(2)   # 2 quarters ago
    df[f'{revenue_col}_Lag4'] = df[revenue_col].shift(4)   # Same quarter last year
    
    # 3. Rolling statistics
    df[f'{revenue_col}_SMA4'] = df[revenue_col].rolling(4).mean()    # 4Q moving avg
    df[f'{revenue_col}_SMA8'] = df[revenue_col].rolling(8).mean()    # 8Q moving avg
    df[f'{revenue_col}_STD4'] = df[revenue_col].rolling(4).std()     # Volatility
    
    # 4. Change features
    df[f'{revenue_col}_QoQ'] = df[revenue_col].pct_change(1) * 100   # QoQ %
    df[f'{revenue_col}_YoY'] = df[revenue_col].pct_change(4) * 100   # YoY %
    
    # 5. Momentum features
    df[f'{revenue_col}_Accel'] = df[f'{revenue_col}_QoQ'].diff(1)    # Acceleration
    
    # 6. Interaction features (if external data available)
    if 'GDP_Growth' in df.columns and 'IT_Index' in df.columns:
        df['GDP_x_IT'] = df['GDP_Growth'] * df['IT_Index'] / 100
    
    return df

# ========================================
# Apply to TCS data from Example 1
# ========================================
# (Assuming 'data' DataFrame from Example 1)
data_featured = create_financial_features(data)

# Drop NaN rows
data_clean = data_featured.dropna()

# ========================================
# Correlation Analysis
# ========================================
feature_cols = [c for c in data_clean.columns if c not in 
               ['Quarter', 'Revenue', 'Q_Month']]

corr_matrix = data_clean[feature_cols + ['Revenue']].corr()

# Plot correlation heatmap
fig, ax = plt.subplots(figsize=(12, 10))
mask = np.triu(np.ones_like(corr_matrix, dtype=bool))
sns.heatmap(corr_matrix, mask=mask, annot=True, fmt='.2f', 
            cmap='RdYlBu_r', center=0, ax=ax,
            square=True, linewidths=0.5)
ax.set_title('Feature Correlation Matrix — TCS Revenue', 
             fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig('correlation_matrix.png', dpi=150, bbox_inches='tight')
plt.show()

# ========================================
# Feature Selection: Top predictors
# ========================================
revenue_corr = corr_matrix['Revenue'].drop('Revenue').abs().sort_values(ascending=False)
print("TOP FEATURES by |Correlation| with Revenue:")
print("=" * 45)
for feat, corr_val in revenue_corr.head(10).items():
    bar = '█' * int(corr_val * 40)
    print(f"  {feat:25s}: {corr_val:.4f}  {bar}")

# Select features with |correlation| > 0.5
selected_features = revenue_corr[revenue_corr > 0.5].index.tolist()
print(f"\nSelected features (|corr| > 0.5): {len(selected_features)}")
print(f"Features: {selected_features}")

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import r2_score, mean_squared_error
import matplotlib.pyplot as plt

def walk_forward_validation(df, features, target, model_class, 
                            min_train=12, **model_params):
    """Walk-forward validation for time-series."""
    predictions = []
    actuals = []
    
    for i in range(min_train, len(df)):
        # Train on all data up to point i
        X_train = df.iloc[:i][features]
        y_train = df.iloc[:i][target]
        
        # Predict point i
        X_test = df.iloc[i:i+1][features]
        y_test = df.iloc[i:i+1][target]
        
        # Scale features
        scaler = StandardScaler()
        X_train_s = scaler.fit_transform(X_train)
        X_test_s = scaler.transform(X_test)
        
        # Train and predict
        model = model_class(**model_params)
        model.fit(X_train_s, y_train)
        pred = model.predict(X_test_s)[0]
        
        predictions.append(pred)
        actuals.append(y_test.values[0])
    
    return np.array(predictions), np.array(actuals)

# Prepare data (using data_clean from earlier examples)
features = ['GDP_Growth', 'IT_Index', 'Quarter_Num', 'Q_Sin', 'Q_Cos',
            'Revenue_Lag1', 'Revenue_Lag4']
target = 'Revenue'

# Run walk-forward for all 3 models
results = {}
for name, cls, params in [
    ('OLS', LinearRegression, {}),
    ('Ridge', Ridge, {'alpha': 1.0}),
    ('Lasso', Lasso, {'alpha': 100.0})
]:
    preds, actuals = walk_forward_validation(
        data_clean, features, target, cls, min_train=12, **params)
    
    results[name] = {
        'R²': r2_score(actuals, preds),
        'RMSE': np.sqrt(mean_squared_error(actuals, preds)),
        'MAPE': np.mean(np.abs((actuals - preds) / actuals)) * 100,
        'Predictions': preds,
        'Actuals': actuals
    }

# ========================================
# Compare Results
# ========================================
print("MODEL COMPARISON — Walk-Forward Validation")
print("=" * 55)
print(f"{'Model':<10} {'R²':>8} {'RMSE (₹ Cr)':>14} {'MAPE (%)':>10}")
print("-" * 55)
for name, r in results.items():
    print(f"{name:<10} {r['R']:>8.4f} {r['RMSE']:>14,.0f} {r['MAPE']:>10.2f}")

best = min(results.items(), key=lambda x: x[1]['RMSE'])
print(f"\n🏆 Best Model: {best[0]} (lowest RMSE)")

# ========================================
# Visualization
# ========================================
fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# Plot 1: Actual vs Predicted
test_quarters = data_clean['Quarter'].iloc[12:]
for name, r in results.items():
    style = '-' if name == 'OLS' else '--' if name == 'Ridge' else ':'
    axes[0].plot(test_quarters, r['Predictions'], style, label=name, linewidth=2)
axes[0].plot(test_quarters, results['OLS']['Actuals'], 'ko', markersize=4, 
             label='Actual', alpha=0.6)
axes[0].set_title('Walk-Forward Predictions', fontweight='bold')
axes[0].legend()
axes[0].grid(alpha=0.3)
axes[0].tick_params(axis='x', rotation=45)

# Plot 2: Error distribution
for name, r in results.items():
    errors = (r['Actuals'] - r['Predictions']) / r['Actuals'] * 100
    axes[1].hist(errors, bins=10, alpha=0.5, label=f'{name} (mean={errors.mean():.2f}%)')
axes[1].set_title('Prediction Error Distribution (%)', fontweight='bold')
axes[1].legend()
axes[1].grid(alpha=0.3)

plt.tight_layout()
plt.savefig('model_comparison.png', dpi=150, bbox_inches='tight')
plt.show()