src/temporal_data.py

"""
src/temporal_data.py
Phase 1: Data Ingestion and Standardization
"""
import pandas as pd
import numpy as np
import os
from sklearn.preprocessing import MultiLabelBinarizer
import pyarrow.parquet as pq
import argparse
import torch
import duckdb
import gc
try:
    from torch_geometric.data import TemporalData
except ImportError:
    print("[WARNING] torch_geometric not found. Phase 4 will fail without PyG installed.")

# --- CONFIGURATION PANEL ---
CONFIG = {
    # 1. Base Directories
    "DATA_DIR": "data",
    "PROCESSED_DIR": "data/processed",
    "EDGE_OUT_DIR": "data/processed/master_edges_parquet",
    "PYG_OUT_DIR": "data/processed/pyg_graph",

    # 2. Input File Paths (Relative to DATA_DIR)
    "FILES": {
        "trades": "cropped/ml_dataset_continuous.csv",
        "lobbying": "processed/events_lobbying.csv",
        "camp_fin": "processed/events_campaign_finance.csv",
        "geo": "processed/events_geographical_industry.csv",
        "company_sic": "cropped/company_sic_data.csv",
        "committee": "cropped/committee_assignments.csv",
        "sec_financials": "cropped/sec_quarterly_financials.csv"
    },

    # 3. Graph Assembly Toggles
    "INCLUDE_EDGES": {
        "trades": False,      
        "lobbying": True,
        "camp_fin": True,
        "geo": True
    },
    
    "START_DATE": "2021-01-01"
}
# ---------------------------

# --- Helper for Strict Schema Validation ---
def validate_columns(df: pd.DataFrame, required_columns: list, dataset_name: str):
    """Raises a clear ValueError if expected columns are missing."""
    missing = [col for col in required_columns if col not in df.columns]
    if missing:
        raise ValueError(f"[{dataset_name}] Missing required columns: {missing}\n"
                         f"Available columns: {list(df.columns)}")

def load_and_standardize_events(data_dir="data"):
    """
    PHASE 1: Load the four primary data sources and map them to a unified schema.
    Returns standardized pandas DataFrames for each event type.
    """
    print("==================================================")
    print("PHASE 1: DATA INGESTION & STANDARDIZATION")
    print("==================================================")

    # ---------------------------------------------------------
    # 1.1 TARGET EDGES (Trades)
    # ---------------------------------------------------------
    path_trades = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["trades"])
    print(f"Loading Trades from: {path_trades}")
    df_trades = pd.read_csv(path_trades)
    
    # 17 market features + 3 trade mechanics
    market_features = [
        'vol_20d', 'vol_60d', 'vol_120d', 'vol_252d', 'vol_of_vol_60d', 'vol_trend', 'idio_vol_60d',
        'mom_60d', 'mom_252d', 'reversal_21d',
        'beta_20d', 'beta_60d', 'downside_beta', 'excess_vol', 'max_dd_60d', 'skew_60d', 'sharpe_60d'
    ]
    trade_features = ['Trade_Size_USD', 'Filing_Gap', 'Transaction'] # Transaction = Buy/Sell Ratio or is_buy
    
    req_trade_cols = ['BioGuideID', 'Matched_Ticker', 'Filed'] + trade_features + market_features
    validate_columns(df_trades, req_trade_cols, "Trades")

    df_trades = df_trades.rename(columns={
        'BioGuideID': 'src',
        'Matched_Ticker': 'dst',
        'Filed': 'time'
    })
    df_trades['event_type'] = 0
    
    # Calculate Label: e.g., Top 25% 6M Excess Return = 1. 
    if 'Excess_Return_6M' in df_trades.columns:
        threshold = df_trades['Excess_Return_6M'].quantile(0.75)
        df_trades['y'] = (df_trades['Excess_Return_6M'] >= threshold).astype(int)
    else:
        print("[WARNING] 'Excess_Return_6M' not found. Setting dummy target 'y' = 0")
        df_trades['y'] = 0

    print(f" -> Trades loaded successfully. Shape: {df_trades.shape}")

    # ---------------------------------------------------------
    # 1.2 LOBBYING EVENTS
    # ---------------------------------------------------------
    if CONFIG["INCLUDE_EDGES"].get("lobbying", True):
        path_lobbying = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["lobbying"])
        df_lobbying = pd.read_csv(path_lobbying)

        path_lobbying = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["lobbying"])
        print(f"Loading Lobbying from: {path_lobbying}")
        df_lobbying = pd.read_csv(path_lobbying)
        
        # Depending on how it was saved, the time column might be 'estimated_filing_date' or 'date'
        time_col_lobby = 'estimated_filing_date' if 'estimated_filing_date' in df_lobbying.columns else 'date'
        
        validate_columns(df_lobbying, ['bioguide_id', 'ticker', time_col_lobby, 'event_type'], "Lobbying")

        df_lobbying = df_lobbying.rename(columns={
            'bioguide_id': 'src',
            'ticker': 'dst',
            time_col_lobby: 'time'
        })
        
        # Extract structural flags
        df_lobbying['is_sponsorship'] = (df_lobbying['event_type'] == 'LOBBY_STRONG').astype(float)
        df_lobbying['voted_yea'] = (df_lobbying['event_type'] == 'LOBBY_WEAK').astype(float)
        df_lobbying['event_type'] = 1 # Override with integer event code
        
        print(f" -> Lobbying loaded successfully. Shape: {df_lobbying.shape}")
    
    else:
        print(" -> [CONFIG] Skipping Lobbying edges...")
        df_lobbying = pd.DataFrame()

    # ---------------------------------------------------------
    # 1.3 CAMPAIGN FINANCE EVENTS
    # ---------------------------------------------------------
    # ---------------------------------------------------------
    if CONFIG["INCLUDE_EDGES"].get("camp_fin", True):
        path_camp_fin = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["camp_fin"])
        df_camp_fin = pd.read_csv(path_camp_fin)
    
        time_col_cf = 'estimated_filing_date' if 'estimated_filing_date' in df_camp_fin.columns else 'date'
        validate_columns(df_camp_fin, ['bioguide_id', 'industry_code', time_col_cf, 'weight'], "Campaign Finance")

        df_camp_fin = df_camp_fin.rename(columns={
            'bioguide_id': 'src',
            'industry_code': 'dst_temp', # Needs broadcasting
            time_col_cf: 'time',
            'weight': 'Fin_Amt' # Assuming donation amount
        })
        df_camp_fin['event_type'] = 2

        print(f" -> Campaign Finance loaded successfully. Shape: {df_camp_fin.shape}")
    
    else:
        print(" -> [CONFIG] Skipping Campaign Finance edges...")
        df_camp_fin = pd.DataFrame()

    # 1.4 GEO-INDUSTRIAL EDGES
    # ---------------------------------------------------------
    if CONFIG["INCLUDE_EDGES"].get("geo", True):
        path_geo = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["geo"])
        df_geo = pd.read_csv(path_geo)
    
        validate_columns(df_geo, ['bioguide_id', 'sic_code', 'release_date', 'establishments', 'employment', 'annual_payroll'], "Geo-Industrial")

        df_geo = df_geo.rename(columns={
            'bioguide_id': 'src',
            'sic_code': 'dst_temp', # Needs broadcasting
            'release_date': 'time'
        })
        
        # Normalizing economic weight (log-scaling as per Appendix B.2.3)
        df_geo['Geo_Weight'] = np.log1p(df_geo['employment'].fillna(0))
        df_geo['event_type'] = 3

        print(f" -> Geo-Industrial loaded successfully. Shape: {df_geo.shape}")

    else:
        print(" -> [CONFIG] Skipping Geo-Industrial edges...")
        df_geo = pd.DataFrame()

    # ---------------------------------------------------------
    # 1.5 LOAD DICTIONARIES FOR BROADCASTING (Phase 2 Prep)
    # ---------------------------------------------------------
    print("Loading Crosswalk Dictionaries...")
    path_cw_2012 = os.path.join(data_dir, "cropped", "industry_codes_NAICS", "2012-NAICS-to-SIC-crosswalk.csv")
    path_cw_2017 = os.path.join(data_dir, "cropped", "industry_codes_NAICS", "2017-NAICS-to-SIC-crosswalk.csv")
    path_cw_cat = os.path.join(data_dir, "cropped", "industry_codes_NAICS", "2013-CAT_to_SIC_to_NAICS_mappings.csv")
    
    cw_2012 = pd.read_csv(path_cw_2012)
    cw_2017 = pd.read_csv(path_cw_2017)
    cw_cat = pd.read_csv(path_cw_cat)
    
    validate_columns(cw_cat, ['OpenSecretsCatcode', 'SICcode'], "CAT to SIC Crosswalk")
    print(" -> All Data and Crosswalks successfully ingested.")
    print("==================================================\n")

    return df_trades, df_lobbying, df_camp_fin, df_geo, cw_2012, cw_2017, cw_cat

def broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat, data_dir="data"):
    """
    PHASE 2: Memory-Optimized Sector Broadcasting & Tensor Alignment
    """
    print("==================================================")
    print("PHASE 2: OPTIMIZED BROADCASTING & ALIGNMENT")
    print("==================================================")

    # 1. Load and Clean Company SIC Master List
    path_company_sic = os.path.join(data_dir, "cropped", "company_sic_data.csv")
    df_comp_sic = pd.read_csv(path_company_sic)
    df_comp_sic = df_comp_sic.drop_duplicates(subset=['ticker', 'sic'])
    df_comp_sic['sic'] = df_comp_sic['sic'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip().str.zfill(4)

    # 2. Fix Campaign Finance Mapping (Clean CAT/SIC strings)
    df_camp_fin['dst_temp'] = df_camp_fin['dst_temp'].astype(str).str.strip().str.upper()
    cw_cat['OpenSecretsCatcode'] = cw_cat['OpenSecretsCatcode'].astype(str).str.strip().str.upper()
    cw_cat['SICcode'] = cw_cat['SICcode'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip().str.zfill(4)

    # ---------------------------------------------------------
    # 2.1 THE "BROADCAST" MECHANISM
    # ---------------------------------------------------------
    print("Broadcasting Geo-Industrial edges...")
    df_geo['dst_temp'] = df_geo['dst_temp'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip().str.zfill(4)
    df_geo = df_geo.merge(df_comp_sic[['sic', 'ticker']], left_on='dst_temp', right_on='sic', how='inner')
    df_geo = df_geo.rename(columns={'ticker': 'dst'}).drop(columns=['dst_temp', 'sic'])

    print("Broadcasting Campaign Finance edges...")
    df_camp_fin = df_camp_fin.merge(cw_cat[['OpenSecretsCatcode', 'SICcode']], 
                                   left_on='dst_temp', right_on='OpenSecretsCatcode', how='inner')
    df_camp_fin = df_camp_fin.merge(df_comp_sic[['sic', 'ticker']], 
                                   left_on='SICcode', right_on='sic', how='inner')
    df_camp_fin = df_camp_fin.rename(columns={'ticker': 'dst'}).drop(columns=['dst_temp', 'OpenSecretsCatcode', 'SICcode', 'sic'])

    print(f" -> Geo edges: {len(df_geo)} | Fin edges: {len(df_camp_fin)}")

    # ---------------------------------------------------------
    # 2.2 UNIFIED EDGE ATTRIBUTE TENSOR (msg)
    # ---------------------------------------------------------
    # RESTORED: Map categorical Trade variables to numeric BEFORE downcasting
    print("Mapping categorical Trade variables to numeric...")
    if df_trades['Transaction'].dtype == object:
        df_trades['Transaction'] = df_trades['Transaction'].astype(str).str.lower().apply(
            lambda x: 1.0 if 'purchase' in x or 'buy' in x else 0.0
        )

    size_map = {
        '$1,001 - $15,000': 1.0,
        '$15,001 - $50,000': 2.0,
        '$50,001 - $100,000': 3.0,
        '$100,001 - $250,000': 4.0,
        '$250,001 - $500,000': 5.0,
        '$500,001 - $1,000,000': 6.0,
        '$1,000,001 - $5,000,000': 7.0,
        '$5,000,001 - $25,000,000': 8.0,
        '$25,000,001 - $50,000,000': 9.0,
        'Over $50,000,000': 10.0
    }
    if df_trades['Trade_Size_USD'].dtype == object:
        df_trades['Trade_Size_USD'] = df_trades['Trade_Size_USD'].map(size_map).fillna(0.0)

    market_features = [
        'vol_20d', 'vol_60d', 'vol_120d', 'vol_252d', 'vol_of_vol_60d', 'vol_trend', 'idio_vol_60d',
        'mom_60d', 'mom_252d', 'reversal_21d',
        'beta_20d', 'beta_60d', 'downside_beta', 'excess_vol', 'max_dd_60d', 'skew_60d', 'sharpe_60d'
    ]
    all_msg_cols = ['Trade_Size_USD', 'Filing_Gap', 'Transaction', 'is_sponsorship', 'voted_yea', 'Fin_Amt', 'Geo_Weight'] + market_features
    
    def align_schema(df):
        # Broadcast scalar directly to bypass pandas array-copying overhead
        for col in all_msg_cols:
            if col not in df.columns:
                df[col] = np.float32(0.0)
            elif df[col].dtype != 'float32':
                # Convert existing columns to float32
                df[col] = df[col].astype('float32')
        return df
    
    print("Aligning D=24 schemas and downcasting to float32...")
    df_trades = align_schema(df_trades)

    # 2. Fix the missing target label ('y') for structural edges
    df_lobbying['y'] = -1
    df_camp_fin['y'] = -1
    df_geo['y'] = -1
    if 'y' not in df_trades.columns: 
        df_trades['y'] = -1

    df_lobbying['y'] = -1
    df_camp_fin['y'] = -1
    df_geo['y'] = -1
    if 'y' not in df_trades.columns: 
        df_trades['y'] = -1

    # ---------------------------------------------------------
    # 3. OUT-OF-CORE ALIGNMENT & PARQUET WRITING
    # ---------------------------------------------------------
    import gc
    import pyarrow as pa
    import pyarrow.parquet as pq

    output_dir = CONFIG["EDGE_OUT_DIR"]
    os.makedirs(output_dir, exist_ok=True)
    print(f"Writing chunks directly to Parquet at: {output_dir}")

    base_cols = ['src', 'dst', 'time', 'event_type', 'y']

    # Load unpadded, "skinny" dataframes into the queue
    datasets = [
        ("trades", df_trades),
        ("lobbying", df_lobbying),
        ("camp_fin", df_camp_fin),
        ("geo", df_geo)
    ]

    # Destroy the loose global references immediately 
    del df_trades, df_lobbying, df_camp_fin, df_geo
    gc.collect()

    # Process 5 million rows at a time (~480 MB per chunk, extremely safe for RAM)
    chunk_size = 5_000_000 

    for i in range(len(datasets)):
        name, df_full = datasets[i]
        
        out_path = os.path.join(output_dir, f"edges_{name}.parquet")
        writer = None
        
        # 1. Slice, format, pad, and append in chunks
        for start in range(0, len(df_full), chunk_size):
            end = min(start + chunk_size, len(df_full))
            df_chunk = df_full.iloc[start:end].copy()
            
            # --- MOVED INSIDE THE CHUNK LOOP ---
            # Convert to datetime and sort LOCALLY in this 5M row chunk
            df_chunk['time'] = pd.to_datetime(df_chunk['time'])
            df_chunk = df_chunk.sort_values(by='time').reset_index(drop=True)
            # -----------------------------------
            
            # Apply schema alignment locally to this small chunk
            for col in all_msg_cols:
                if col not in df_chunk.columns:
                    df_chunk[col] = np.float32(0.0)
                else:
                    df_chunk[col] = df_chunk[col].astype('float32')
            
            # Filter down to base + msg cols
            df_chunk = df_chunk[base_cols + all_msg_cols]
            
            # Append to Parquet file
            table = pa.Table.from_pandas(df_chunk)
            if writer is None:
                # Initialize the writer with the schema of the first padded chunk
                writer = pq.ParquetWriter(out_path, table.schema)
            writer.write_table(table)
            
            # Destroy the padded chunk to free RAM
            del df_chunk
            gc.collect()
            
        if writer:
            writer.close()
            
        print(f" -> Saved {name} ({len(df_full)} rows) to {out_path}")
        
        # 2. Destroy the reference to the full dataset before loading the next one
        datasets[i] = None 
        del df_full
        gc.collect()

    print(" -> Master Edge Parquet chunks successfully written.")
    print("==================================================\n")
    
    return output_dir, all_msg_cols

# ==========================================
# PHASE 3: NODE FEATURE EXTRACTION
# ==========================================

SEC_FACTS = [
    "NetIncomeLoss", "StockholdersEquity", "EarningsPerShareBasic", 
    "EarningsPerShareDiluted", "IncomeTaxExpenseBenefit", 
    "CashAndCashEquivalentsAtCarryingValue", "WeightedAverageNumberOfSharesOutstandingBasic", 
    "OperatingIncomeLoss", "WeightedAverageNumberOfDilutedSharesOutstanding", 
    "Assets", "LiabilitiesAndStockholdersEquity", "InterestExpense", 
    "RetainedEarningsAccumulatedDeficit", "NetCashProvidedByUsedInOperatingActivities", 
    "NetCashProvidedByUsedInFinancingActivities", "NetCashProvidedByUsedInInvestingActivities", 
    "Liabilities", "CommonStockValue", "AccumulatedOtherComprehensiveIncomeLossNetOfTax", 
    "PropertyPlantAndEquipmentNet", "Revenues", "AssetsCurrent", 
    "LiabilitiesCurrent", "OperatingExpenses", "GrossProfit", 
    "PaymentsToAcquirePropertyPlantAndEquipment", "Goodwill", 
    "AmortizationOfIntangibleAssets", "SellingGeneralAndAdministrativeExpense", 
    "AccountsPayableCurrent", "CommonStockDividendsPerShareDeclared", 
    "NonoperatingIncomeExpense", "OtherAssetsNoncurrent", 
    "AdditionalPaidInCapital", "AccountsReceivableNetCurrent", 
    "ResearchAndDevelopmentExpense"
]

def map_sic_to_division(sic_code):
    """Maps a 4-digit SIC code to its 10 parent divisions (0-9)."""
    try:
        sic = int(sic_code)
        if sic < 1000: return 0   # Agriculture
        elif sic < 1500: return 1  # Mining
        elif sic < 1800: return 2  # Construction
        elif sic < 4000: return 3  # Manufacturing
        elif sic < 5000: return 4  # Transportation/Utilities
        elif sic < 5200: return 5  # Wholesale Trade
        elif sic < 6000: return 6  # Retail Trade
        elif sic < 6800: return 7  # Finance, Insurance, RE
        elif sic < 9000: return 8  # Services
        else: return 9             # Public Admin
    except:
        return 9 

def process_node_features(data_dir="data/", processed_dir="data/processed/"):
    """
    Phase 3: Generate and save temporally aligned node features for politicians and companies.
    """
    pol_parquet_path = os.path.join(processed_dir, "politician_features.parquet")
    comp_parquet_path = os.path.join(processed_dir, "company_features.parquet")

    if os.path.exists(pol_parquet_path) and os.path.exists(comp_parquet_path):
        print(" -> Found existing node feature parquets. Skipping Phase 3 generation...")
        return pol_parquet_path, comp_parquet_path

    print("==================================================")
    print("PHASE 3: NODE FEATURE EXTRACTION")
    print("==================================================")

    # --- Politician Snapshots (x_src) ---
    print(" -> Processing Politician Features...")
    df_com = pd.read_csv(os.path.join(data_dir, "cropped/committee_assignments.csv"))
    df_com['Committees'] = df_com['Committees'].fillna('').astype(str).str.split(r';\s*')
    
    mlb = MultiLabelBinarizer()
    encoded_com = mlb.fit_transform(df_com['Committees'])
    df_com_encoded = pd.DataFrame(encoded_com, columns=[f"Com_{c}" for c in mlb.classes_])
    df_pol = pd.concat([df_com.drop('Committees', axis=1), df_com_encoded], axis=1)

    # --- Company Snapshots (x_dst) ---
    print(" -> Processing Company Features (SEC & SIC)...")
    df_sec = pd.read_csv(os.path.join(data_dir, "cropped/sec_quarterly_financials.csv"))
    df_sec['FiledDate'] = pd.to_datetime(df_sec['FiledDate'])
    
    df_sec = df_sec[df_sec['Fact'].isin(SEC_FACTS)]
    df_sec = df_sec.drop_duplicates(subset=['Ticker', 'FiledDate', 'Fact'], keep='last')
    
    df_comp = df_sec.pivot(index=['Ticker', 'FiledDate'], columns='Fact', values='Value').reset_index()
    for fact in SEC_FACTS:
        if fact not in df_comp.columns:
            df_comp[fact] = np.nan
            
    df_comp = df_comp[['Ticker', 'FiledDate'] + SEC_FACTS].sort_values(['Ticker', 'FiledDate'])
    df_comp = df_comp.groupby('Ticker').ffill().fillna(0.0)
    
    for col in SEC_FACTS:
        df_comp[col] = np.sign(df_comp[col]) * np.log1p(np.abs(df_comp[col]))

    df_sic = pd.read_csv(os.path.join(data_dir, "cropped/company_sic_data.csv"))
    df_sic['sic_division'] = df_sic['sic'].apply(map_sic_to_division)
    sic_dummies = pd.get_dummies(df_sic['sic_division'], prefix='SIC_Div')
    
    for i in range(10):
        if f'SIC_Div_{i}' not in sic_dummies.columns:
            sic_dummies[f'SIC_Div_{i}'] = 0
            
    df_sic = pd.concat([df_sic[['ticker']], sic_dummies[[f'SIC_Div_{i}' for i in range(10)]].astype(np.float32)], axis=1)
    df_sic = df_sic.rename(columns={'ticker': 'Ticker'})
    
    df_comp = df_comp.merge(df_sic, on='Ticker', how='left')
    sic_cols = [f'SIC_Div_{i}' for i in range(10)]
    df_comp[sic_cols] = df_comp[sic_cols].fillna(0.0)

    print(" -> Saving Phase 3 Parquets...")
    df_pol.to_parquet(pol_parquet_path)
    df_comp.to_parquet(comp_parquet_path)
    
    return pol_parquet_path, comp_parquet_path

# ==========================================
# PHASE 3: NODE FEATURE EXTRACTION
# ==========================================

SEC_FACTS = [
    "NetIncomeLoss", "StockholdersEquity", "EarningsPerShareBasic", 
    "EarningsPerShareDiluted", "IncomeTaxExpenseBenefit", 
    "CashAndCashEquivalentsAtCarryingValue", "WeightedAverageNumberOfSharesOutstandingBasic", 
    "OperatingIncomeLoss", "WeightedAverageNumberOfDilutedSharesOutstanding", 
    "Assets", "LiabilitiesAndStockholdersEquity", "InterestExpense", 
    "RetainedEarningsAccumulatedDeficit", "NetCashProvidedByUsedInOperatingActivities", 
    "NetCashProvidedByUsedInFinancingActivities", "NetCashProvidedByUsedInInvestingActivities", 
    "Liabilities", "CommonStockValue", "AccumulatedOtherComprehensiveIncomeLossNetOfTax", 
    "PropertyPlantAndEquipmentNet", "Revenues", "AssetsCurrent", 
    "LiabilitiesCurrent", "OperatingExpenses", "GrossProfit", 
    "PaymentsToAcquirePropertyPlantAndEquipment", "Goodwill", 
    "AmortizationOfIntangibleAssets", "SellingGeneralAndAdministrativeExpense", 
    "AccountsPayableCurrent", "CommonStockDividendsPerShareDeclared", 
    "NonoperatingIncomeExpense", "OtherAssetsNoncurrent", 
    "AdditionalPaidInCapital", "AccountsReceivableNetCurrent", 
    "ResearchAndDevelopmentExpense"
]

def map_sic_to_division(sic_code):
    """Maps a 4-digit SIC code to its 10 parent divisions (0-9)."""
    try:
        sic = int(sic_code)
        if sic < 1000: return 0   # Agriculture
        elif sic < 1500: return 1  # Mining
        elif sic < 1800: return 2  # Construction
        elif sic < 4000: return 3  # Manufacturing
        elif sic < 5000: return 4  # Transportation/Utilities
        elif sic < 5200: return 5  # Wholesale Trade
        elif sic < 6000: return 6  # Retail Trade
        elif sic < 6800: return 7  # Finance, Insurance, RE
        elif sic < 9000: return 8  # Services
        else: return 9             # Public Admin
    except:
        return 9 

# --- Constants & Configurations ---
CBP_RELEASE_DATES = {
    2023: "2025-06-26", 2022: "2024-06-27", 2021: "2023-04-20", 
    2020: "2022-04-28", 2019: "2021-04-22", 2018: "2020-06-25", 
    2017: "2019-11-21", 2016: "2018-04-19", 2015: "2017-04-20", 
    2014: "2016-04-24", 2013: "2015-04-23", 2012: "2014-05-29", 
    2011: "2013-04-30", 2010: "2012-06-26"
}

STATE_ABBREV = {
    'Alabama': 'AL', 'Alaska': 'AK', 'Arizona': 'AZ', 'Arkansas': 'AR', 'California': 'CA',
    'Colorado': 'CO', 'Connecticut': 'CT', 'Delaware': 'DE', 'Florida': 'FL', 'Georgia': 'GA',
    'Hawaii': 'HI', 'Idaho': 'ID', 'Illinois': 'IL', 'Indiana': 'IN', 'Iowa': 'IA',
    'Kansas': 'KS', 'Kentucky': 'KY', 'Louisiana': 'LA', 'Maine': 'ME', 'Maryland': 'MD',
    'Massachusetts': 'MA', 'Michigan': 'MI', 'Minnesota': 'MN', 'Mississippi': 'MS',
    'Missouri': 'MO', 'Montana': 'MT', 'Nebraska': 'NE', 'Nevada': 'NV', 'New Hampshire': 'NH',
    'New Jersey': 'NJ', 'New Mexico': 'NM', 'New York': 'NY', 'North Carolina': 'NC',
    'North Dakota': 'ND', 'Ohio': 'OH', 'Oklahoma': 'OK', 'Oregon': 'OR', 'Pennsylvania': 'PA',
    'Rhode Island': 'RI', 'South Carolina': 'SC', 'South Dakota': 'SD', 'Tennessee': 'TN',
    'Texas': 'TX', 'Utah': 'UT', 'Vermont': 'VT', 'Virginia': 'VA', 'Washington': 'WA',
    'West Virginia': 'WV', 'Wisconsin': 'WI', 'Wyoming': 'WY', 'District of Columbia': 'DC'
}

# (Keep SEC_FACTS list and map_sic_to_division helper exactly as you had them)

def process_node_features(data_dir="data/", processed_dir="data/processed/"):
    """Phase 3: Generate and save standardized node features."""
    import re
    pol_path = os.path.join(processed_dir, "politician_features.parquet")
    comp_path = os.path.join(processed_dir, "company_features.parquet")
    cbp_out_path = os.path.join(processed_dir, "district_economics_cbp.parquet")

    if all(os.path.exists(p) for p in [pol_path, comp_path, cbp_out_path]):
        print(" -> Found all node feature parquets. Skipping Phase 3...")
        return pol_path, comp_path

    print("==================================================")
    print("PHASE 3: NODE FEATURE EXTRACTION")
    print("==================================================")

    # --- 1. POLITICIAN STATIC (Committees & Party) ---
    print(" -> Processing Politician Static Features...")
    df_com = pd.read_csv(os.path.join(data_dir, "cropped/committee_assignments.csv"))
    df_com['Committees'] = df_com['Committees'].fillna('').astype(str).str.split(r';\s*')
    mlb = MultiLabelBinarizer()
    encoded_com = mlb.fit_transform(df_com['Committees'])
    df_pol_static = pd.concat([df_com.drop('Committees', axis=1), 
                               pd.DataFrame(encoded_com, columns=[f"Com_{c}" for c in mlb.classes_])], axis=1)
    df_pol_static['District_Num'] = df_pol_static['District'].astype(str).str.extract(r'(\d+)').fillna('0')

    # --- 2. DISTRICT ECONOMICS (NAICS Schema-Agnostic) ---
    print(" -> Processing CBP District Economics (Handling 2012/2017 NAICS Schema)...")
    cbp_dir = os.path.join(data_dir, "cropped/district_industries")
    cbp_dfs = []
    
    # Nested helper to parse "Congressional District 1 (119th Congress), Alabama"
    def _parse_geo(name):
        try:
            match = re.search(r'(?:District\s|at Large)(\d+)?.*?,\s*(.*)', str(name))
            if match:
                dist = match.group(1) if match.group(1) else '0'
                state = STATE_ABBREV.get(match.group(2).strip(), 'XX')
                return state, str(int(dist))
        except: pass
        return "XX", "-1"

    for year, release_date in CBP_RELEASE_DATES.items():
        file_name = f"{year}_CB_estimates.csv" if year <= 2012 else f"{year}_CB_esurvey.csv"
        file_path = os.path.join(cbp_dir, file_name)
        if not os.path.exists(file_path): continue
            
        df_year = pd.read_csv(file_path, low_memory=False)
        df_year.columns = [c.split('(')[-1].replace(')', '').strip() if '(' in c else c for c in df_year.columns]
        
        # Dynamically grabs NAICS2012 or NAICS2017
        naics_col = next((c for c in df_year.columns if 'NAICS' in c), None)
        if not naics_col: continue
            
        df_year = df_year[['NAME', naics_col, 'EMP']].copy()
        df_year.rename(columns={naics_col: 'Sector_Raw'}, inplace=True)
        df_year['EMP'] = pd.to_numeric(df_year['EMP'], errors='coerce').fillna(0)
        df_year['ReleaseDate'] = pd.to_datetime(release_date)
        
        # Explicitly call the nested _parse_geo function
        df_year[['State', 'District']] = pd.DataFrame(df_year['NAME'].apply(_parse_geo).tolist(), index=df_year.index)
        df_year['Sector'] = df_year['Sector_Raw'].astype(str).str[:2]
        cbp_dfs.append(df_year)

    if cbp_dfs:
        df_cbp = pd.concat(cbp_dfs, ignore_index=True)
        df_cbp_pivot = df_cbp.pivot_table(index=['State', 'District', 'ReleaseDate'], 
                                          columns='Sector', values='EMP', aggfunc='sum').reset_index()
        
        # Forward fill 24-dim economics vector
        df_cbp_pivot = df_cbp_pivot.sort_values(['State', 'District', 'ReleaseDate'])
        sector_cols = [c for c in df_cbp_pivot.columns if c not in ['State', 'District', 'ReleaseDate']]
        
        # Prefix the NAICS columns for clarity
        df_cbp_pivot.rename(columns={c: f"NAICS_EMP_{c}" for c in sector_cols}, inplace=True)
        naics_prefixed = [f"NAICS_EMP_{c}" for c in sector_cols]
        
        df_cbp_pivot[naics_prefixed] = df_cbp_pivot.groupby(['State', 'District'])[naics_prefixed].ffill().fillna(0.0)
        
        df_cbp_pivot.to_parquet(cbp_out_path)
        print(f"   -> Saved District Economics (Dims: {len(naics_prefixed)})")

    # --- 3. COMPANY SNAPSHOTS (SEC & SIC) ---
    print(" -> Processing Company Features (SEC & SIC)...")
    df_sec = pd.read_csv(os.path.join(data_dir, "cropped/sec_quarterly_financials.csv"))
    df_sec['FiledDate'] = pd.to_datetime(df_sec['FiledDate'])
    df_sec = df_sec[df_sec['Fact'].isin(SEC_FACTS)].drop_duplicates(subset=['Ticker', 'FiledDate', 'Fact'], keep='last')
    
    df_comp = df_sec.pivot(index=['Ticker', 'FiledDate'], columns='Fact', values='Value').reset_index()
    for fact in SEC_FACTS:
        if fact not in df_comp.columns: df_comp[fact] = np.nan
    df_comp = df_comp[['Ticker', 'FiledDate'] + SEC_FACTS].sort_values(['Ticker', 'FiledDate'])
    
    df_comp[SEC_FACTS] = df_comp.groupby('Ticker')[SEC_FACTS].ffill().fillna(0.0)
    for col in SEC_FACTS:
        df_comp[col] = np.sign(df_comp[col]) * np.log1p(np.abs(df_comp[col]))

    df_sic = pd.read_csv(os.path.join(data_dir, "cropped/company_sic_data.csv"))
    df_sic['sic_division'] = df_sic['sic'].apply(map_sic_to_division)
    sic_dummies = pd.get_dummies(df_sic['sic_division'], prefix='SIC_Div')
    for i in range(10):
        if f'SIC_Div_{i}' not in sic_dummies.columns: sic_dummies[f'SIC_Div_{i}'] = 0
    df_sic_proc = pd.concat([df_sic[['ticker']], sic_dummies[[f'SIC_Div_{i}' for i in range(10)]]], axis=1).rename(columns={'ticker': 'Ticker'})
    df_comp = df_comp.merge(df_sic_proc, on='Ticker', how='left').fillna(0.0)

    # SAVE ALL
    print(" -> Saving Phase 3 Parquets...")
    df_pol_static.to_parquet(pol_path)
    df_comp.to_parquet(comp_path)
    
    return pol_path, comp_path

# ==========================================
# PHASE 4: ASSEMBLY & PYG VALIDATION
# ==========================================

# ==========================================
# PHASE 4: ASSEMBLY & PYG VALIDATION (OUT-OF-CORE)
# ==========================================

# ==========================================
# PHASE 4: OUT-OF-CORE TEMPORAL SHARDING
# ==========================================

def generate_hillstreet_dataset(edge_dir="data/processed/master_edges_parquet", start_date="2012-07-01", include_structural_edges=True):
    """
    PHASE 4: Sharded conversion to PyTorch Geometric TemporalData.
    Anchored to the true STOCK Act start date: July 2012.
    """
    print("==================================================")
    print("PHASE 4: OUT-OF-CORE TEMPORAL SHARDING")
    print("==================================================")

    # 4.1 VALIDATE FILES
    edge_files = [
        "edges_trades.parquet",
        "edges_lobbying.parquet", 
        "edges_camp_fin.parquet", 
        "edges_geo.parquet"
    ]

    valid_files = []
    # Map filenames to their config keys
    edge_map = {
        "edges_trades.parquet": "trades",
        "edges_lobbying.parquet": "lobbying",
        "edges_camp_fin.parquet": "camp_fin",
        "edges_geo.parquet": "geo"
    }

    for file in edge_files:
        config_key = edge_map[file]
        
        # Check the toggle in CONFIG
        if not CONFIG["INCLUDE_EDGES"].get(config_key, True):
            print(f" -> Skipping '{config_key}' edge file per config.")
            continue
            
        file_path = os.path.join(edge_dir, file)
        if not os.path.exists(file_path):
            print(f" -> [WARNING] Expected edge chunk not found: {file}")
            continue
            
        valid_files.append(file_path)

    files_sql = "[" + ", ".join([f"'{f}'" for f in valid_files]) + "]"

    # 4.2 BUILD GLOBAL NODE ID DICTIONARIES
    print(f"Extracting global distinct Node IDs for events >= {start_date}...")
    out_dir = "data/processed/pyg_graph"
    os.makedirs(out_dir, exist_ok=True)

    # Use .df() for DuckDB to avoid the AttributeError
    df_src = duckdb.query(f"""
        SELECT DISTINCT src FROM read_parquet({files_sql}) 
        WHERE src IS NOT NULL AND time >= '{start_date}'
    """).df()
    unique_src = df_src['src'].values
    src_map = {val: i for i, val in enumerate(unique_src)}
    
    df_dst = duckdb.query(f"""
        SELECT DISTINCT dst FROM read_parquet({files_sql}) 
        WHERE dst IS NOT NULL AND time >= '{start_date}'
    """).df()
    unique_dst = df_dst['dst'].values
    dst_start_idx = len(unique_src)
    dst_map = {val: i + dst_start_idx for i, val in enumerate(unique_dst)}

    # Save mapping for inference/analysis
    np.save(os.path.join(out_dir, "src_id_map.npy"), src_map)
    np.save(os.path.join(out_dir, "dst_id_map.npy"), dst_map)
    print(f" -> Global mapping established: {len(src_map)} Politicians | {len(dst_map)} Companies")
    
    del df_src, df_dst
    gc.collect()

    # 4.3 DETERMINE ACTIVE YEARS
    print("Identifying active years...")
    years_df = duckdb.query(f"""
        SELECT DISTINCT extract(year from time) as yr 
        FROM read_parquet({files_sql}) 
        WHERE time >= '{start_date}'
        ORDER BY yr
    """).df()
    active_years = years_df['yr'].dropna().astype(int).tolist()
    
    saved_shards = []

    # 4.4 GENERATE YEARLY SHARDS
    for year in active_years:
        print(f"\n--- Processing Shard: {year} ---")
        
        # Filter for the year, but respect the July 2012 start month for that specific year
        query = f"""
            SELECT * FROM read_parquet({files_sql})
            WHERE extract(year from time) = {year}
            AND time >= '{start_date}'
            ORDER BY time ASC
        """
        
        master_table = duckdb.query(query).arrow()
        if hasattr(master_table, 'read_all'):
            master_table = master_table.read_all()
            
        num_rows = master_table.num_rows
        if num_rows == 0:
            print(f" -> No valid events found for {year} after {start_date}. Skipping.")
            continue
            
        print(f" -> Mapping {num_rows:,} events...")
        df_ids = master_table.select(['src', 'dst']).to_pandas()
        src_idx_array = df_ids['src'].map(src_map).values
        dst_idx_array = df_ids['dst'].map(dst_map).values
        del df_ids

        # Base Tensors (Using long/int64 for standard PyG compatibility)
        src_tensor = torch.from_numpy(src_idx_array).to(torch.long)
        dst_tensor = torch.from_numpy(dst_idx_array).to(torch.long)
        y_tensor = torch.from_numpy(master_table['y'].to_numpy()).to(torch.long)
        event_type_tensor = torch.from_numpy(master_table['event_type'].to_numpy()).to(torch.long)
        
        time_array = master_table['time'].to_numpy().astype('datetime64[s]').astype(np.int64)
        t_tensor = torch.from_numpy(time_array).to(torch.long)

        # Message Attribute Tensor (D=24)
        base_cols = ['src', 'dst', 'time', 'y', 'event_type']
        msg_cols = [c for c in master_table.column_names if c not in base_cols]
        
        msg_tensor = torch.empty((num_rows, len(msg_cols)), dtype=torch.float)
        for i, col in enumerate(msg_cols):
            arr = master_table[col].combine_chunks().to_numpy(zero_copy_only=False)
            msg_tensor[:, i] = torch.from_numpy(arr)
            del arr 

        # Assemble Object
        data = TemporalData(
            src=src_tensor,
            dst=dst_tensor,
            t=t_tensor,
            msg=msg_tensor,
            y=y_tensor
        )
        data.event_type = event_type_tensor
        
        # Audit
        is_sorted = torch.all(t_tensor[1:] >= t_tensor[:-1]).item()
        assert is_sorted, f"[{year}] Temporal leak detected: Events are not strictly chronological!"

        # Save Shard
        shard_path = os.path.join(out_dir, f"hillstreet_temporal_graph_{year}.pt")
        torch.save(data, shard_path)
        saved_shards.append(shard_path)
        print(f" -> Shard saved successfully: {shard_path}")

        # Memory Cleanup
        del master_table, src_tensor, dst_tensor, y_tensor, event_type_tensor, t_tensor, msg_tensor, data
        gc.collect()

    print("\n==================================================")
    print(f"PHASE 4 COMPLETE: Generated {len(saved_shards)} annual shards.")
    print("==================================================\n")
    
    return saved_shards
# ==========================================
# MAIN ORCHESTRATION & CLI
# ==========================================

if __name__ == "__main__":
    # 1. Setup Directories from CONFIG
    EDGE_DIR = CONFIG["EDGE_OUT_DIR"]
    os.makedirs(EDGE_DIR, exist_ok=True)
    
    # Check which edges are required based on the toggle panel
    REQUIRED_EDGES = []
    if CONFIG["INCLUDE_EDGES"].get("trades", True): REQUIRED_EDGES.append("edges_trades.parquet")
    if CONFIG["INCLUDE_EDGES"].get("lobbying", True): REQUIRED_EDGES.append("edges_lobbying.parquet")
    if CONFIG["INCLUDE_EDGES"].get("camp_fin", True): REQUIRED_EDGES.append("edges_camp_fin.parquet")
    if CONFIG["INCLUDE_EDGES"].get("geo", True): REQUIRED_EDGES.append("edges_geo.parquet")
    
    # 2. Check for Phase 1 & 2 Persistence
    phase2_done = all(os.path.exists(os.path.join(EDGE_DIR, f)) for f in REQUIRED_EDGES) and len(REQUIRED_EDGES) > 0
    
    if phase2_done:
        print(f" -> Found existing edge parquets in {EDGE_DIR}. Skipping Phases 1 & 2.")
        schema = pq.read_schema(os.path.join(EDGE_DIR, REQUIRED_EDGES[0]))
        base_cols = ['src', 'dst', 'time', 'y', 'event_type']
        all_msg_cols = [c for c in schema.names if c not in base_cols]
    else:
        df_trades, df_lobbying, df_camp_fin, df_geo, cw_2012, cw_2017, cw_cat = load_and_standardize_events()
        EDGE_DIR, all_msg_cols = broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat)

    # 3. Process Node Features
    pol_feat_path, comp_feat_path = process_node_features()
    
    # 4. Generate Final PyG Dataset using the START_DATE from CONFIG
    shards_generated = generate_hillstreet_dataset(
        start_date=CONFIG["START_DATE"], 
    )
    
    print(f"Successfully generated the following shards:\n{shards_generated}")