code/data/generate_synthetic.py

"""
Generate synthetic Smart Grid transformer data for development/testing.

This produces the same CSV schemas that the real Kaggle datasets will be
processed into.  Real data replaces these once the pipeline runs against
the downloaded Kaggle files.

Run:
    python3 data/generate_synthetic.py

Outputs (all in data/processed/):
    asset_metadata.csv    — 20 transformers, static attributes
    sensor_readings.csv   — hourly readings for 30 days per transformer
    failure_modes.csv     — catalogue of DGA-based fault types
    dga_records.csv       — one DGA sample per transformer (some faulty)
    rul_labels.csv        — daily RUL estimates per transformer
    fault_records.csv     — maintenance / work-order history

Synthetic transformer_id key: T-001 … T-020
  T-001 to T-010  →  healthy / approaching end-of-life
  T-011 to T-015  →  minor faults (partial discharge, thermal < 300°C)
  T-016 to T-020  →  serious faults (arcing, thermal > 700°C)
"""

from __future__ import annotations

import random
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd

try:
    from data.constants import HI_FULL_HEALTH_DAYS
except ModuleNotFoundError:
    from constants import HI_FULL_HEALTH_DAYS

SEED = 42
rng = np.random.default_rng(SEED)
random.seed(SEED)

OUT = Path(__file__).parent / "processed"
OUT.mkdir(parents=True, exist_ok=True)

N_TRANSFORMERS = 20
IDS = [f"T-{i:03d}" for i in range(1, N_TRANSFORMERS + 1)]

START = datetime(2024, 1, 1)
END = datetime(2024, 1, 31)
PROFILE_TO_FDD_CATEGORY = {"healthy": 1, "degraded": 2, "critical": 4}
# Category 3 only appears in the Kaggle-backed build_processed path.
PROFILE_TO_RUL_BASE = {"healthy": 3650, "degraded": 730, "critical": 90}


# ---------------------------------------------------------------------------
# 1. asset_metadata.csv
# ---------------------------------------------------------------------------
# Why: IoT server needs static attributes to answer "what is transformer T-007?"
# Columns mirror what AssetOpsBench IoT tools return for other domains.


def make_asset_metadata() -> pd.DataFrame:
    manufacturers = ["ABB", "Siemens", "GE", "Eaton", "Schneider Electric"]
    locations = [
        "Substation Alpha",
        "Substation Beta",
        "Substation Gamma",
        "Distribution Center 1",
        "Distribution Center 2",
        "Industrial Park A",
        "Industrial Park B",
    ]
    voltage_classes = ["11kV/0.4kV", "33kV/11kV", "132kV/33kV"]
    ratings_kva = [500, 1000, 1500, 2000, 2500, 5000]

    rows = []
    for i, tid in enumerate(IDS):
        profile_key = "healthy" if i < 10 else ("degraded" if i < 15 else "critical")
        install_year = rng.integers(2005, 2020)
        rows.append(
            {
                "transformer_id": tid,
                "name": f"Power Transformer {tid}",
                "manufacturer": random.choice(manufacturers),
                "location": random.choice(locations),
                "voltage_class": random.choice(voltage_classes),
                "rating_kva": random.choice(ratings_kva),
                "install_date": f"{install_year}-{rng.integers(1,13):02d}-{rng.integers(1,28):02d}",
                "age_years": 2024 - install_year,
                # health_status: healthy (0), degraded (1), critical (2)
                "health_status": 0 if i < 10 else (1 if i < 15 else 2),
                "fdd_category": PROFILE_TO_FDD_CATEGORY[profile_key],
                "rul_days": int(
                    max(
                        30,
                        rng.normal(
                            PROFILE_TO_RUL_BASE[profile_key],
                            PROFILE_TO_RUL_BASE[profile_key] * 0.12,
                        ),
                    )
                ),
                "in_service": True,
            }
        )

    df = pd.DataFrame(rows)
    path = OUT / "asset_metadata.csv"
    df.to_csv(path, index=False)
    print(f"  wrote {path}  ({len(df)} rows)")
    return df


# ---------------------------------------------------------------------------
# 2. sensor_readings.csv
# ---------------------------------------------------------------------------
# Why: IoT server's get_sensor_readings() returns this.
# Sensors: winding_temp, oil_temp, load_current, voltage_hv, voltage_lv.
# Faulty transformers have elevated temperature / voltage anomalies.

SENSORS = {
    "winding_temp_top_c": {
        "healthy": (50, 10),
        "degraded": (80, 15),
        "critical": (105, 20),
        "unit": "°C",
    },
    "oil_temp_c": {
        "healthy": (45, 8),
        "degraded": (70, 12),
        "critical": (90, 18),
        "unit": "°C",
    },
    "load_current_a": {
        "healthy": (200, 40),
        "degraded": (220, 45),
        "critical": (240, 50),
        "unit": "A",
    },
    "voltage_hv_kv": {
        "healthy": (33, 0.5),
        "degraded": (33, 1.0),
        "critical": (32, 2.0),
        "unit": "kV",
    },
    "voltage_lv_kv": {
        "healthy": (11, 0.2),
        "degraded": (11, 0.4),
        "critical": (10.5, 1.0),
        "unit": "kV",
    },
    "power_factor": {
        "healthy": (0.95, 0.02),
        "degraded": (0.90, 0.04),
        "critical": (0.82, 0.06),
        "unit": "",
    },
}


def make_sensor_readings(metadata: pd.DataFrame) -> pd.DataFrame:
    hours = int((END - START).total_seconds() / 3600)
    timestamps = [START + timedelta(hours=h) for h in range(hours)]

    rows = []
    status_map = dict(zip(metadata["transformer_id"], metadata["health_status"]))

    for tid in IDS:
        status_key = ["healthy", "degraded", "critical"][status_map[tid]]
        for sensor_id, params in SENSORS.items():
            mu, sigma = params[status_key]
            values = rng.normal(mu, sigma, len(timestamps))
            # Inject a spike anomaly into critical transformers
            if status_map[tid] == 2 and "temp" in sensor_id:
                spike_idx = rng.integers(100, len(timestamps) - 50)
                values[spike_idx : spike_idx + 12] += rng.uniform(15, 30)
            for ts, val in zip(timestamps, values):
                rows.append(
                    {
                        "transformer_id": tid,
                        "timestamp": ts.isoformat(),
                        "sensor_id": sensor_id,
                        "value": round(float(val), 3),
                        "unit": params["unit"],
                        "source": "synthetic",
                    }
                )

    df = pd.DataFrame(rows)
    path = OUT / "sensor_readings.csv"
    df.to_csv(path, index=False)
    print(f"  wrote {path}  ({len(df):,} rows)")
    return df


# ---------------------------------------------------------------------------
# 3. failure_modes.csv
# ---------------------------------------------------------------------------
# Why: FMSR server's search_failure_modes() and get_sensor_correlation()
#      return entries from this table.
# Based on IEC 60599 DGA interpretation standard and Duval triangle method.


def make_failure_modes() -> pd.DataFrame:
    rows = [
        {
            "failure_mode_id": "FM-001",
            "name": "Partial Discharge",
            "dga_label": "Partial discharge",
            "description": "Low-energy electrical discharge within insulation voids. "
            "Indicated by elevated H2 and CH4 with trace C2H2.",
            "severity": "low",
            "iec_code": "PD",
            "key_gases": "H2,CH4",
            "recommended_action": "Monitor closely; schedule inspection within 90 days",
        },
        {
            "failure_mode_id": "FM-002",
            "name": "Low-Temperature Overheating (< 300°C)",
            "dga_label": "Low-temperature overheating",
            "description": "Low-temperature thermal fault, typically in core laminations "
            "or due to overload. Elevated CH4 and C2H4.",
            "severity": "medium",
            "iec_code": "T1",
            "key_gases": "CH4,C2H4",
            "recommended_action": "Reduce load; inspect within 30 days",
        },
        {
            "failure_mode_id": "FM-003",
            "name": "Thermal Fault 300-700°C",
            "dga_label": "Middle-temperature overheating",
            "description": "Medium-temperature thermal fault in conductors or connections. "
            "High C2H4 relative to C2H6.",
            "severity": "high",
            "iec_code": "T2",
            "key_gases": "C2H4,C2H6",
            "recommended_action": "De-energize and inspect within 48 hours",
        },
        {
            "failure_mode_id": "FM-004",
            "name": "High-Temperature Overheating (> 700°C)",
            "dga_label": "High-temperature overheating",
            "description": "Severe winding conductor overheating. "
            "Very high C2H4 and C2H6.",
            "severity": "critical",
            "iec_code": "T3",
            "key_gases": "C2H4,C2H6,H2",
            "recommended_action": "Immediate de-energization required",
        },
        {
            "failure_mode_id": "FM-005",
            "name": "Spark Discharge",
            "dga_label": "Spark discharge",
            "description": "Low-energy electrical sparking in oil. "
            "Elevated C2H2 and H2.",
            "severity": "high",
            "iec_code": "D1",
            "key_gases": "C2H2,H2",
            "recommended_action": "De-energize and inspect within 48 hours",
        },
        {
            "failure_mode_id": "FM-006",
            "name": "Arc Discharge",
            "dga_label": "Arc discharge",
            "description": "High-energy arcing causing severe oil decomposition. "
            "Very high C2H2 and H2.",
            "severity": "critical",
            "iec_code": "D2",
            "key_gases": "C2H2,H2,C2H4",
            "recommended_action": "Immediate de-energization and emergency inspection",
        },
    ]

    df = pd.DataFrame(rows)
    path = OUT / "failure_modes.csv"
    df.to_csv(path, index=False)
    print(f"  wrote {path}  ({len(df)} rows)")
    return df


# ---------------------------------------------------------------------------
# 4. dga_records.csv
# ---------------------------------------------------------------------------
# Why: FMSR server's analyze_dga() interprets these gas concentrations.
# Gas values in ppm (parts per million), typical IEC 60599 ranges.
# Each transformer gets one DGA sample; fault profile matches health_status.

DGA_PROFILES = {
    # (h2, ch4, c2h2, c2h4, c2h6, co, co2) mean ± sigma
    "healthy": [(10, 3), (5, 2), (0.1, 0.05), (2, 1), (2, 0.8), (200, 40), (1500, 200)],
    "degraded": [(50, 15), (30, 10), (2, 1), (25, 8), (10, 3), (300, 60), (2000, 300)],
    "critical": [
        (200, 50),
        (80, 20),
        (20, 8),
        (100, 25),
        (40, 10),
        (500, 80),
        (3500, 400),
    ],
}
DGA_COLS = [
    "dissolved_h2_ppm",
    "dissolved_ch4_ppm",
    "dissolved_c2h2_ppm",
    "dissolved_c2h4_ppm",
    "dissolved_c2h6_ppm",
    "dissolved_co_ppm",
    "dissolved_co2_ppm",
]

FAULT_LABEL_MAP = {
    "healthy": "Normal",
    "degraded": "Low-temperature overheating",
    "critical": "Arc discharge",
}


def make_dga_records(metadata: pd.DataFrame) -> pd.DataFrame:
    status_map = dict(zip(metadata["transformer_id"], metadata["health_status"]))
    rows = []
    for tid in IDS:
        profile_key = ["healthy", "degraded", "critical"][status_map[tid]]
        profile = DGA_PROFILES[profile_key]
        gas_vals = {
            col: round(max(0.0, float(rng.normal(mu, sigma))), 2)
            for col, (mu, sigma) in zip(DGA_COLS, profile)
        }
        rows.append(
            {
                "transformer_id": tid,
                "sample_date": (
                    START + timedelta(days=int(rng.integers(0, 30)))
                ).strftime("%Y-%m-%d"),
                **gas_vals,
                "fault_label": FAULT_LABEL_MAP[profile_key],
                "source_dataset": "synthetic",
            }
        )

    df = pd.DataFrame(rows)
    path = OUT / "dga_records.csv"
    df.to_csv(path, index=False)
    print(f"  wrote {path}  ({len(df)} rows)")
    return df


# ---------------------------------------------------------------------------
# 5. rul_labels.csv
# ---------------------------------------------------------------------------
# Why: TSFM server's forecast_rul() returns predictions against these labels.
# RUL decreases each day; critical transformers have low starting RUL.

RUL_START = {
    "healthy": (3650, 500),  # ~10 years remaining
    "degraded": (730, 200),  # ~2 years
    "critical": (90, 30),  # ~3 months
}


def make_rul_labels(metadata: pd.DataFrame) -> pd.DataFrame:
    status_map = dict(zip(metadata["transformer_id"], metadata["health_status"]))
    rows = []
    for tid in IDS:
        profile_key = ["healthy", "degraded", "critical"][status_map[tid]]
        mu, sigma = RUL_START[profile_key]
        base_rul = max(10, int(rng.normal(mu, sigma)))
        # ~1 RUL-day consumed per calendar day, with small transformer-to-transformer variation.
        daily_deg = float(rng.uniform(0.9, 1.1))
        days = (END - START).days
        for d in range(days + 1):
            day = START + timedelta(days=d)
            rul = max(0, base_rul - int(round(d * daily_deg)))
            health_index = min(1.0, max(0.0, rul / HI_FULL_HEALTH_DAYS))
            rows.append(
                {
                    "transformer_id": tid,
                    "timestamp": day.strftime("%Y-%m-%d"),
                    "rul_days": rul,
                    "health_index": round(float(health_index), 4),
                    "fdd_category": PROFILE_TO_FDD_CATEGORY[profile_key],
                }
            )

    df = pd.DataFrame(rows)
    path = OUT / "rul_labels.csv"
    df.to_csv(path, index=False)
    print(f"  wrote {path}  ({len(df)} rows)")
    return df


def sync_asset_metadata_rul_days(
    metadata: pd.DataFrame, rul_labels: pd.DataFrame
) -> pd.DataFrame:
    """Align asset_metadata.rul_days to the latest RUL label for each transformer."""
    latest_rul = (
        rul_labels.sort_values("timestamp")
        .groupby("transformer_id", sort=False)
        .last()["rul_days"]
        .astype(int)
    )
    synced = metadata.copy()
    synced["rul_days"] = (
        synced["transformer_id"].map(latest_rul).fillna(synced["rul_days"]).astype(int)
    )
    path = OUT / "asset_metadata.csv"
    synced.to_csv(path, index=False)
    print(f"  rewrote {path} with latest RUL labels")
    return synced


# ---------------------------------------------------------------------------
# 6. fault_records.csv
# ---------------------------------------------------------------------------
# Why: WO server's list_work_orders() and create_work_order() reference these.
# Each critical/degraded transformer has at least one historical fault event.

FAULT_TYPES = [
    "Transformer Failure",
    "Line Breakage",
    "Overload Trip",
    "Cooling System Failure",
    "Tap Changer Malfunction",
    "Insulation Degradation",
]
MAINTENANCE_STATUSES = ["Scheduled", "Pending", "Completed"]
WEATHER_CONDITIONS = ["Clear", "Rainy", "Windy", "Stormy"]
COMPONENT_HEALTH = {0: "Normal", 1: "Warning", 2: "Faulty"}
DOWNTIME_BY_HEALTH = {
    0: (2, 6),
    1: (8, 24),
    2: (24, 72),
}


def make_fault_records(metadata: pd.DataFrame) -> pd.DataFrame:
    status_map = dict(zip(metadata["transformer_id"], metadata["health_status"]))
    rows = []
    fault_counter = 1

    for tid in IDS:
        health = status_map[tid]
        # Healthy: 0-1 records, degraded: 1-3, critical: 2-5
        n_faults = {
            0: rng.integers(0, 2),
            1: rng.integers(1, 4),
            2: rng.integers(2, 6),
        }[health]
        for _ in range(n_faults):
            min_downtime, max_downtime = DOWNTIME_BY_HEALTH[health]
            downtime = int(rng.integers(min_downtime, max_downtime + 1))
            rows.append(
                {
                    "transformer_id": tid,
                    "fault_id": f"F{fault_counter:03d}",
                    "fault_type": random.choice(FAULT_TYPES),
                    "location": f"Substation {random.choice(['Alpha', 'Beta', 'Gamma', 'Delta'])}",
                    "voltage_v": int(rng.choice([11000, 33000, 132000])),
                    "current_a": int(max(0, rng.normal(220, 40))),
                    "power_load_mw": round(max(0.0, float(rng.normal(45, 8))), 2),
                    "temperature_c": round(float(rng.normal(28 + health * 8, 4)), 1),
                    "wind_speed_kmh": round(max(0.0, float(rng.normal(15, 6))), 1),
                    "weather_condition": random.choice(WEATHER_CONDITIONS),
                    "maintenance_status": random.choice(MAINTENANCE_STATUSES),
                    "component_health": COMPONENT_HEALTH[health],
                    "duration_hrs": round(
                        float(max(0.5, rng.normal(2 + health * 3, 1.2))), 1
                    ),
                    "downtime_hrs": max(1, downtime + int(rng.integers(-2, 4))),
                }
            )
            fault_counter += 1

    df = (
        pd.DataFrame(rows)
        .sort_values(["transformer_id", "fault_id"])
        .reset_index(drop=True)
    )
    path = OUT / "fault_records.csv"
    df.to_csv(path, index=False)
    print(f"  wrote {path}  ({len(df)} rows)")
    return df


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

if __name__ == "__main__":
    print(f"Generating synthetic Smart Grid data → {OUT}\n")
    meta = make_asset_metadata()
    make_sensor_readings(meta)
    make_failure_modes()
    make_dga_records(meta)
    rul = make_rul_labels(meta)
    meta = sync_asset_metadata_rul_days(meta, rul)
    make_fault_records(meta)
    print("\nDone. All files written to data/processed/")
    print(
        "These are SYNTHETIC — replace with real Kaggle data once API access is granted."
    )