import pandas as pd
import numpy as np
import warnings
warnings.filterwarnings('ignore')

# Set the random seed for reproducibility
np.random.seed(42)

# Generate synthetic banking transactions data
n_transactions = 1000
n_customers = 200
df = pd.DataFrame({
    'transaction_id': range(1, n_transactions + 1),
    'customer_id': np.random.choice([f'CUST_{i:04d}' for i in range(1, n_customers + 1)], n_transactions),
    'amount': np.round(np.random.normal(150, 60, n_transactions), 2),
    'transaction_type': np.random.choice(['Debit', 'Credit'], n_transactions),
    'channel': np.random.choice(['ATM', 'Online', 'Branch', 'POS'], n_transactions),
    'date': pd.date_range(start='2024-01-01', periods=n_transactions, freq='h')
})
print(df.shape)
print(df.head(3))

# Remove negative transaction amounts for realism
df = df[df['amount'] > 0]
print(df.shape)
print(df['amount'].describe())

import matplotlib.pyplot as plt
plt.hist(df['amount'], bins=30, color='skyblue', edgecolor='black')
plt.xlabel('Transaction Amount')
plt.ylabel('Frequency')
plt.title('Distribution of Transaction Amounts')
plt.grid(True)
plt.show()

# Find the highest 5 transaction amounts
print(df[['transaction_id','amount']].sort_values('amount', ascending=False).head(5))

# Calculate the mean and standard deviation of transaction amounts
mean_amt = df['amount'].mean()
std_amt = df['amount'].std()
print('Mean Amount:', mean_amt)
print('Std Deviation:', std_amt)

# Simple threshold: Flag anything above $300
flagged = df[df['amount'] > 300]
print('Flagged transactions:', flagged.shape[0])
print(flagged[['transaction_id','amount']].head(3))

# Beginner Example 1: Fixed threshold alert
df['is_alert'] = df['amount'] > 300
print(df['is_alert'].value_counts())

# Beginner Example 2: Flag highest 5 percent of transactions
upper_5pct = df['amount'].quantile(0.95)
df['is_alert_5pct'] = df['amount'] > upper_5pct
print('Threshold (95th percentile):', upper_5pct)
print(df['is_alert_5pct'].value_counts())

# Beginner Example 3: Flag all ATM withdrawals above $200
atm_flags = (df['channel'] == 'ATM') & (df['amount'] > 200)
print('Number of flagged ATM transactions:', atm_flags.sum())

# Intermediate Example 1: Calculate mean amount per customer
customer_means = df.groupby('customer_id')['amount'].mean()
print(customer_means.head())

# Intermediate Example 2: Flag transactions 2 std deviations above customer mean
customer_stats = df.groupby('customer_id')['amount'].agg(['mean','std']).reset_index()
df = pd.merge(df, customer_stats, on='customer_id', how='left')
df['alert_dynamic'] = df['amount'] > (df['mean'] + 2 * df['std'])
print(df['alert_dynamic'].value_counts())

# Intermediate Example 3: Compare dynamic and fixed rules
print('Fixed alerts:', df['is_alert'].sum())
print('Dynamic alerts:', df['alert_dynamic'].sum())

# Intermediate Example 4: Time-of-day rule
late_night = (df['date'].dt.hour >= 23) | (df['date'].dt.hour <= 5)
suspicious_night = df['amount'][late_night & (df['amount'] > 150)]
print('Late night suspicious transactions:', suspicious_night.count())

# Intermediate Example 5: Multiple rules combined
df['alert_combo'] = (df['alert_dynamic'] | df['is_alert_5pct']) & late_night
print(df['alert_combo'].value_counts())

from sklearn.metrics import confusion_matrix, classification_report

# Suppose 'fraud' is any transaction above $350 (simulate for practice)
df['is_fraud'] = df['amount'] > 350
y_true = df['is_fraud'].astype(int)
y_pred = df['is_alert'].astype(int)
cm = confusion_matrix(y_true, y_pred)
print('Confusion Matrix:')
print(cm)
print(classification_report(y_true, y_pred))

# Advanced Example 1: ROC curve analysis for threshold selection
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt

fpr, tpr, thresholds = roc_curve(y_true, df['amount'])
roc_auc = auc(fpr, tpr)
plt.figure()
plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic')
plt.legend(loc='lower right')
plt.show()

# Advanced Example 2: Automated threshold optimizer
best_f1 = 0
best_thresh = 0
from sklearn.metrics import f1_score
for thresh in np.arange(150, 400, 10):
    preds = (df['amount'] > thresh).astype(int)
    f1 = f1_score(y_true, preds)
    if f1 > best_f1:
        best_f1 = f1
        best_thresh = thresh
print('Best threshold by F1 score:', best_thresh)
print('Best F1 score:', best_f1)

# Check for missing values
missing = df.isnull().sum()
print('Missing values per column:')
print(missing)

# Check for duplicate transaction_id
duplicates = df['transaction_id'].duplicated().sum()
print('Number of duplicate transaction IDs:', duplicates)

# Defensive coding: What if there are negative or invalid values again?
if (df['amount'] < 0).any():
    print('Warning: Negative transaction values found!')
else:
    print('All transaction amounts are valid positive numbers.')

# Create a log of alert counts by day for monitoring
df['date_day'] = df['date'].dt.date
alert_logs = df.groupby('date_day')['is_alert'].sum()
print(alert_logs.tail())

# Tiny End-to-End Example: From raw data to threshold, alert, and visualization
raw = df[['transaction_id','amount','date','customer_id']].copy()
alert_thresh = 320
raw['alert'] = raw['amount'] > alert_thresh
alerts = raw[raw['alert']]
print(f'Out of {raw.shape[0]} transactions, {alerts.shape[0]} were flagged.')

# Visualize flagged vs. normal
plt.hist(raw[~raw['alert']]['amount'], bins=30, alpha=0.6, label='Normal')
plt.hist(raw[raw['alert']]['amount'], bins=15, alpha=0.7, label='Flagged')
plt.xlabel('Amount')
plt.ylabel('Frequency')
plt.title('Alert Threshold Segmentation')
plt.legend()
plt.show()