import pandas as pd
import numpy as np
from dateutil import parser as dateutil_parser

REGION_MAP = {
    "us": "US", "usa": "US", "united states": "US", "u.s.": "US",
    "uk": "GB", "united kingdom": "GB", "england": "GB",
    "ca": "CA", "canada": "CA",
    # extend as needed
}

def parse_amount(val):
    if pd.isna(val):
        return np.nan
    return float(str(val).replace("$", "").replace(",", "").strip())

def parse_flexible_date(val):
    if pd.isna(val):
        return pd.NaT
    try:
        return dateutil_parser.parse(str(val), dayfirst=False)
    except (ValueError, OverflowError):
        return pd.NaT

def clean_sales(df: pd.DataFrame) -> pd.DataFrame:
    return (
        df
        .assign(
            amount=lambda x: x["amount"].map(parse_amount),
            date=lambda x: x["date"].map(parse_flexible_date),
            region=lambda x: (
                x["region"]
                .str.strip()
                .str.lower()
                .map(REGION_MAP)
                .fillna(x["region"].str.upper())  # keep unknown as-is
            ),
        )
        .dropna(subset=["amount", "date"])
        .sort_values("date", ascending=False)
        .drop_duplicates(subset=["customer_id"], keep="first")
        .reset_index(drop=True)
        .astype({"amount": "float64"})
        .assign(date=lambda x: pd.to_datetime(x["date"]))
    )

def clean_sales(df):
    # normalize region names
    df['region'] = df['region'].str.upper().str.strip()

    # parse currency
    df['amount'] = df['amount'].str.replace('$', '').str.replace(',', '').astype(float)

    # parse dates
    df['date'] = pd.to_datetime(df['date'], infer_datetime_format=True, errors='coerce')

    # remove duplicates
    df = df.sort_values('date').drop_duplicates('customer_id', keep='last')

    return df

from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV
import numpy as np
import pandas as pd

class Log1pTransformer(BaseEstimator, TransformerMixin):
    """Applies log1p to columns with skewness above threshold."""

    def __init__(self, skew_threshold: float = 0.5):
        self.skew_threshold = skew_threshold
        self.skewed_cols_: list[int] = []

    def fit(self, X, y=None):
        if isinstance(X, pd.DataFrame):
            X = X.values
        skewness = pd.DataFrame(X).skew()
        self.skewed_cols_ = list(skewness[abs(skewness) > self.skew_threshold].index)
        return self

    def transform(self, X):
        X = np.array(X, dtype=float).copy()
        X[:, self.skewed_cols_] = np.log1p(X[:, self.skewed_cols_])
        return X


def build_pipeline(
    numeric_features: list[str],
    categorical_features: list[str],
) -> Pipeline:
    numeric_transformer = Pipeline([
        ("log1p", Log1pTransformer(skew_threshold=0.5)),
        ("scaler", StandardScaler()),
    ])

    categorical_transformer = OneHotEncoder(
        handle_unknown="ignore",
        sparse_output=False,
    )

    preprocessor = ColumnTransformer([
        ("num", numeric_transformer, numeric_features),
        ("cat", categorical_transformer, categorical_features),
    ])

    return Pipeline([
        ("preprocessor", preprocessor),
        ("classifier", LogisticRegression(max_iter=1000, random_state=42)),
    ])


# GridSearchCV-compatible parameter grid
param_grid = {
    "preprocessor__num__log1p__skew_threshold": [0.3, 0.5, 0.8],
    "classifier__C": [0.01, 0.1, 1.0, 10.0],
    "classifier__solver": ["lbfgs", "saga"],
}

pipeline = build_pipeline(
    numeric_features=["age", "income", "tenure_days"],
    categorical_features=["region", "plan_type"],
)

grid_search = GridSearchCV(
    pipeline, param_grid, cv=5, scoring="roc_auc", n_jobs=-1, verbose=1
)

# Type: # plot distribution of amount by region
# Copilot generates:
import matplotlib.pyplot as plt
import seaborn as sns

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Distribution plot
sns.histplot(data=df, x='amount', hue='region', bins=30, ax=axes[0])
axes[0].set_title('Amount Distribution by Region')
axes[0].set_xlabel('Amount ($)')

# Box plot for outlier visibility
sns.boxplot(data=df, x='region', y='amount', ax=axes[1])
axes[1].set_title('Amount by Region (Box Plot)')
axes[1].tick_params(axis='x', rotation=45)

plt.tight_layout()
plt.show()

import pandas as pd
import numpy as np


def engineer_time_features(
    df: pd.DataFrame,
    date_col: str = "date",
    target_col: str = "sales",
    group_col: str = "store_id",
) -> pd.DataFrame:
    """
    Add time-series features to a daily sales DataFrame.
    Applies lag and rolling features within each store group
    to avoid data leakage across stores.
    """
    df = df.copy()
    df[date_col] = pd.to_datetime(df[date_col])
    df = df.sort_values([group_col, date_col]).reset_index(drop=True)

    def add_features(group: pd.DataFrame) -> pd.DataFrame:
        g = group.copy()

        # Lag features — shift within the group
        for lag in [1, 7, 30]:
            g[f"{target_col}_lag_{lag}d"] = g[target_col].shift(lag)

        # Rolling statistics (requires lag to avoid leakage)
        g[f"{target_col}_roll7_mean"] = (
            g[target_col].shift(1).rolling(7, min_periods=4).mean()
        )
        g[f"{target_col}_roll7_std"] = (
            g[target_col].shift(1).rolling(7, min_periods=4).std()
        )

        return g

    df = df.groupby(group_col, group_keys=False).apply(add_features)

    # Calendar features (don't need grouping)
    df["day_of_week"] = df[date_col].dt.dayofweek       # 0=Monday
    df["month"] = df[date_col].dt.month
    df["is_weekend"] = df["day_of_week"].isin([5, 6]).astype(int)
    df["quarter"] = df[date_col].dt.quarter

    return df


# Usage
featured_df = engineer_time_features(raw_df)

# NaN summary — expected for early rows
print(featured_df.isna().sum())

# Drop rows where any lag feature is NaN before training
train_df = featured_df.dropna(subset=[
    "sales_lag_1d", "sales_lag_7d", "sales_lag_30d",
    "sales_roll7_mean", "sales_roll7_std",
])

# Root cause 1: Column has NaN, astype(int) fails
df["col"].astype(int)           # Fails if any NaN

# Fix 1: Fill NaN before casting
df["col"].fillna(0).astype(int)

# Fix 2: Use nullable integer type (pandas 1.0+)
df["col"].astype("Int64")       # Capital I — supports pd.NA

# Fix 3: Drop NaN rows first
df.dropna(subset=["col"])["col"].astype(int)

# Root cause 2: Column has inf values from division
df["rate"] = df["a"] / df["b"]  # inf when b==0

# Fix: Replace inf before casting
df["rate"] = df["rate"].replace([np.inf, -np.inf], np.nan)

# Check feature importance — might reveal leakage
from sklearn.inspection import permutation_importance
perm_importance = permutation_importance(model, X_val, y_val, n_repeats=10)

# Check for extreme feature values
print(X_train.describe())

# Verify no target leakage
print("Features correlated with target:")
print(X_train.corrwith(y_train).abs().sort_values(ascending=False).head(10))

# Add regularization
LogisticRegression(C=0.01, max_iter=1000)

# Step 1: Use Copilot to generate boilerplate
# Type: "import pandas" → Copilot fills in common imports
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

# Step 2: Load data with Copilot
df = pd.read_csv('data.csv')
X = df.drop('target', axis=1)
y = df['target']

# Step 3: Use Claude for strategy
# "I have 50k samples, 30 features, binary classification.
# Training is slow. What features should I engineer?"
# → Claude generates domain-specific feature ideas

# Step 4: Back to Copilot for implementation
# Type comment: "# normalize numerical features"
# → Copilot suggests StandardScaler

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Step 5: Claude for debugging
# Paste error: "ValueError: y_true and y_pred have different shapes"
# → Claude explains and provides fix

# Step 6: Copilot for testing boilerplate
# Type: "# test model performance"
from sklearn.metrics import classification_report, confusion_matrix
print(classification_report(y_test, model.predict(X_test_scaled)))