import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# Settings
plt.style.use('seaborn-v0_8-whitegrid')
sns.set_palette('husl')
np.random.seed(42)

print("Libraries imported successfully!")

# Create customer churn dataset
n_customers = 1000

data = {
    'CustomerID': range(1, n_customers + 1),
    'Gender': np.random.choice(['Male', 'Female'], n_customers),
    'Age': np.random.randint(18, 70, n_customers),
    'Tenure': np.random.randint(1, 72, n_customers),  # months with company
    'MonthlyCharges': np.round(np.random.uniform(20, 100, n_customers), 2),
    'TotalCharges': np.zeros(n_customers),  # will calculate
    'Contract': np.random.choice(['Month-to-month', 'One year', 'Two year'], n_customers, p=[0.5, 0.3, 0.2]),
    'PaymentMethod': np.random.choice(['Credit Card', 'Bank Transfer', 'Electronic Check', 'Mailed Check'], n_customers),
    'TechSupport': np.random.choice(['Yes', 'No'], n_customers),
    'OnlineSecurity': np.random.choice(['Yes', 'No'], n_customers),
}

df = pd.DataFrame(data)

# Calculate TotalCharges
df['TotalCharges'] = df['Tenure'] * df['MonthlyCharges']

# Create Churn (target variable) - based on realistic patterns
churn_probability = (
    (df['Contract'] == 'Month-to-month').astype(int) * 0.3 +
    (df['Tenure'] < 12).astype(int) * 0.2 +
    (df['MonthlyCharges'] > 70).astype(int) * 0.15 +
    (df['TechSupport'] == 'No').astype(int) * 0.1 +
    np.random.uniform(0, 0.25, n_customers)
)

df['Churn'] = (churn_probability > 0.5).astype(int)

print("Dataset created!")
print(f"Total customers: {len(df)}")
print(f"Churned customers: {df['Churn'].sum()}")
print(f"Churn rate: {df['Churn'].mean():.1%}")

# First look
print("=== First 5 Rows ===")
print(df.head())

# Data types and info
print("\n=== Data Info ===")
print(df.dtypes)

# Statistics for numerical columns
print("\n=== Statistics ===")
print(df.describe())

# Overall churn distribution
churn_counts = df['Churn'].value_counts()
churn_pct = df['Churn'].value_counts(normalize=True) * 100

print("=== Churn Distribution ===")
print(f"Stayed (0): {churn_counts[0]} ({churn_pct[0]:.1f}%)")
print(f"Churned (1): {churn_counts[1]} ({churn_pct[1]:.1f}%)")

# Visualize churn distribution
plt.figure(figsize=(8, 5))
colors = ['#2ecc71', '#e74c3c']
df['Churn'].value_counts().plot(kind='bar', color=colors, edgecolor='black')
plt.title('Customer Churn Distribution', fontsize=14, fontweight='bold')
plt.xlabel('Churn (0=Stayed, 1=Left)')
plt.ylabel('Number of Customers')
plt.xticks([0, 1], ['Stayed', 'Churned'], rotation=0)
plt.tight_layout()
plt.show()

# Churn rate by contract
contract_churn = df.groupby('Contract')['Churn'].mean() * 100
print("=== Churn Rate by Contract ===")
print(contract_churn.sort_values(ascending=False))

# Visualize
plt.figure(figsize=(8, 5))
contract_churn.sort_values().plot(kind='barh', color='coral', edgecolor='black')
plt.title('Churn Rate by Contract Type', fontsize=14, fontweight='bold')
plt.xlabel('Churn Rate (%)')
plt.tight_layout()
plt.show()

# Create tenure groups
df['TenureGroup'] = pd.cut(df['Tenure'],
                           bins=[0, 12, 24, 48, 72],
                           labels=['0-12 mo', '12-24 mo', '24-48 mo', '48+ mo'])

tenure_churn = df.groupby('TenureGroup')['Churn'].mean() * 100
print("=== Churn Rate by Tenure ===")
print(tenure_churn)

# Visualize
plt.figure(figsize=(8, 5))
tenure_churn.plot(kind='bar', color='steelblue', edgecolor='black')
plt.title('Churn Rate by Customer Tenure', fontsize=14, fontweight='bold')
plt.xlabel('Tenure Group')
plt.ylabel('Churn Rate (%)')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Compare charges for churned vs stayed
plt.figure(figsize=(10, 5))
df.groupby('Churn')['MonthlyCharges'].plot(kind='hist', alpha=0.7,
                                            bins=20, legend=True)
plt.title('Monthly Charges: Churned vs Stayed', fontsize=14, fontweight='bold')
plt.xlabel('Monthly Charges ($)')
plt.legend(['Stayed', 'Churned'])
plt.tight_layout()
plt.show()

# Average charges
print("=== Average Monthly Charges ===")
print(df.groupby('Churn')['MonthlyCharges'].mean())

# Churn rate by tech support
support_churn = df.groupby('TechSupport')['Churn'].mean() * 100
print("=== Churn Rate by Tech Support ===")
print(support_churn)

# Create a copy for ML
df_ml = df.copy()

# Drop columns we don't need
df_ml = df_ml.drop(['CustomerID', 'TenureGroup'], axis=1)

# Encode categorical variables
label_encoders = {}
categorical_cols = ['Gender', 'Contract', 'PaymentMethod', 'TechSupport', 'OnlineSecurity']

for col in categorical_cols:
    le = LabelEncoder()
    df_ml[col] = le.fit_transform(df_ml[col])
    label_encoders[col] = le

print("=== Encoded Data ===")
print(df_ml.head())

# Separate features (X) and target (y)
X = df_ml.drop('Churn', axis=1)
y = df_ml['Churn']

print(f"Features shape: {X.shape}")
print(f"Target shape: {y.shape}")
print(f"\nFeatures: {list(X.columns)}")

# Split data: 80% train, 20% test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print("=== Data Split ===")
print(f"Training samples: {len(X_train)}")
print(f"Test samples: {len(X_test)}")
print(f"Training churn rate: {y_train.mean():.1%}")
print(f"Test churn rate: {y_test.mean():.1%}")

# Scale numerical features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print("Features scaled successfully!")

# Train Logistic Regression
lr_model = LogisticRegression(random_state=42, max_iter=1000)
lr_model.fit(X_train_scaled, y_train)

# Predict
lr_pred = lr_model.predict(X_test_scaled)

# Evaluate
lr_accuracy = accuracy_score(y_test, lr_pred)
print("=== Logistic Regression Results ===")
print(f"Accuracy: {lr_accuracy:.1%}")

# Detailed report
print("\nClassification Report:")
print(classification_report(y_test, lr_pred, target_names=['Stayed', 'Churned']))

# Train Random Forest
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train_scaled, y_train)

# Predict
rf_pred = rf_model.predict(X_test_scaled)

# Evaluate
rf_accuracy = accuracy_score(y_test, rf_pred)
print("=== Random Forest Results ===")
print(f"Accuracy: {rf_accuracy:.1%}")

# Detailed report
print("\nClassification Report:")
print(classification_report(y_test, rf_pred, target_names=['Stayed', 'Churned']))

print("=== Model Comparison ===")
print(f"Logistic Regression: {lr_accuracy:.1%}")
print(f"Random Forest: {rf_accuracy:.1%}")
print(f"\nBest Model: {'Random Forest' if rf_accuracy > lr_accuracy else 'Logistic Regression'}")

# Confusion matrix for best model
cm = confusion_matrix(y_test, rf_pred)

plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=['Stayed', 'Churned'],
            yticklabels=['Stayed', 'Churned'])
plt.title('Confusion Matrix - Random Forest', fontsize=14, fontweight='bold')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.tight_layout()
plt.show()

# Get feature importance from Random Forest
importance = pd.DataFrame({
    'Feature': X.columns,
    'Importance': rf_model.feature_importances_
}).sort_values('Importance', ascending=False)

print("=== Feature Importance ===")
print(importance)

# Visualize
plt.figure(figsize=(10, 6))
plt.barh(importance['Feature'], importance['Importance'], color='teal', edgecolor='black')
plt.xlabel('Importance')
plt.title('Feature Importance for Churn Prediction', fontsize=14, fontweight='bold')
plt.gca().invert_yaxis()
plt.tight_layout()
plt.show()

# Function to predict churn for new customer
def predict_churn(gender, age, tenure, monthly_charges, contract,
                  payment_method, tech_support, online_security):

    # Create dataframe
    new_customer = pd.DataFrame({
        'Gender': [label_encoders['Gender'].transform([gender])[0]],
        'Age': [age],
        'Tenure': [tenure],
        'MonthlyCharges': [monthly_charges],
        'TotalCharges': [tenure * monthly_charges],
        'Contract': [label_encoders['Contract'].transform([contract])[0]],
        'PaymentMethod': [label_encoders['PaymentMethod'].transform([payment_method])[0]],
        'TechSupport': [label_encoders['TechSupport'].transform([tech_support])[0]],
        'OnlineSecurity': [label_encoders['OnlineSecurity'].transform([online_security])[0]]
    })

    # Scale and predict
    new_scaled = scaler.transform(new_customer)
    prediction = rf_model.predict(new_scaled)[0]
    probability = rf_model.predict_proba(new_scaled)[0][1]

    return prediction, probability

# Test with sample customers
print("=== Predict New Customers ===")

# High risk customer
pred, prob = predict_churn('Female', 25, 3, 85, 'Month-to-month',
                           'Electronic Check', 'No', 'No')
print(f"Customer 1 (High Risk): Churn={pred}, Probability={prob:.1%}")

# Low risk customer
pred, prob = predict_churn('Male', 45, 48, 50, 'Two year',
                           'Credit Card', 'Yes', 'Yes')
print(f"Customer 2 (Low Risk): Churn={pred}, Probability={prob:.1%}")

import joblib

# Save the model
joblib.dump(rf_model, 'churn_model.pkl')
joblib.dump(scaler, 'churn_scaler.pkl')

# Save results
results = pd.DataFrame({
    'Actual': y_test,
    'Predicted': rf_pred
})
results.to_csv('churn_predictions.csv', index=False)

print("Model and results saved!")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# Create data
np.random.seed(42)
n_customers = 1000

data = {
    'CustomerID': range(1, n_customers + 1),
    'Gender': np.random.choice(['Male', 'Female'], n_customers),
    'Age': np.random.randint(18, 70, n_customers),
    'Tenure': np.random.randint(1, 72, n_customers),
    'MonthlyCharges': np.round(np.random.uniform(20, 100, n_customers), 2),
    'Contract': np.random.choice(['Month-to-month', 'One year', 'Two year'], n_customers, p=[0.5, 0.3, 0.2]),
    'PaymentMethod': np.random.choice(['Credit Card', 'Bank Transfer', 'Electronic Check', 'Mailed Check'], n_customers),
    'TechSupport': np.random.choice(['Yes', 'No'], n_customers),
    'OnlineSecurity': np.random.choice(['Yes', 'No'], n_customers),
}

df = pd.DataFrame(data)
df['TotalCharges'] = df['Tenure'] * df['MonthlyCharges']

# Create churn based on patterns
churn_prob = (
    (df['Contract'] == 'Month-to-month').astype(int) * 0.3 +
    (df['Tenure'] < 12).astype(int) * 0.2 +
    (df['MonthlyCharges'] > 70).astype(int) * 0.15 +
    (df['TechSupport'] == 'No').astype(int) * 0.1 +
    np.random.uniform(0, 0.25, n_customers)
)
df['Churn'] = (churn_prob > 0.5).astype(int)

# Prepare for ML
df_ml = df.drop(['CustomerID'], axis=1)
categorical_cols = ['Gender', 'Contract', 'PaymentMethod', 'TechSupport', 'OnlineSecurity']
for col in categorical_cols:
    df_ml[col] = LabelEncoder().fit_transform(df_ml[col])

# Split
X = df_ml.drop('Churn', axis=1)
y = df_ml['Churn']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# Scale
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train Random Forest
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train_scaled, y_train)

# Evaluate
y_pred = model.predict(X_test_scaled)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.1%}")
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

# Feature importance
importance = pd.DataFrame({
    'Feature': X.columns,
    'Importance': model.feature_importances_
}).sort_values('Importance', ascending=False)
print("\nFeature Importance:")
print(importance)

print("\nProject Complete!")