import pandas as pd
import argparse
import sys
import numpy as np

def load_data(filepath):
    try:
        # Read CSV
        df = pd.read_csv(filepath)
        # Clean up column names: remove whitespace
        df.columns = df.columns.str.strip()
        
        # Parse time if possible
        if 'time' in df.columns:
            df['time'] = pd.to_datetime(df['time'])
            df.set_index('time', inplace=True)
            
        return df
    except Exception as e:
        print(f"Error loading {filepath}: {e}")
        sys.exit(1)

def find_matching_column(db_col, all_columns):
    """Finds the non-DB column that corresponds to a DB_ column."""
    # Manual mappings based on your Pine Script variable names
    manual_map = {
        'DB_Stoch': ['stoch_value'],
        'DB_MACD_Pred': ['macd_prediction'],
        'DB_OSC': ['osc_1D', 'osc'],
        'DB_M3_Mom': ['m3_momentum'],
        'DB_M2_Diff': ['m2_diff_abs_tinyOffset_to_future'],
        'DB_RSID': ['rsid_osc'],
        'DB_Stoch_Div': ['stoch_div_osc'],
        'DB_VWAP_Div': ['vwap_div_osc'],
        'DB_M3_Div': ['m3_div_osc'],
        'DB_Bearish': ['bearish_engulfing_score'],
        'DB_Score': ['activation_score_poc'],
        # These might not exist in the main export if not plotted explicitly
        'DB_M2_Div_Tiny': ['m2_div_osc_tiny', 'm2_div_osc'], 
        'DB_M2_Div_NoOff': ['m2_div_osc_noOffset'] 
    }
    
    if db_col in manual_map:
        candidates = manual_map[db_col]
        for cand in candidates:
            # Check for exact match or mangled duplicate (e.g. 'stoch_value.1')
            for col in all_columns:
                if col == cand or col.startswith(cand + "."):
                    # Ensure we don't match the DB column itself
                    if col != db_col:
                        return col
    return None

def analyze_export(filepath):
    df = load_data(filepath)
    
    print(f"\n--- Analyzing {filepath} ---")
    print(f"Rows: {len(df)}")
    
    db_columns = [c for c in df.columns if c.startswith("DB_")]
    
    if not db_columns:
        print("No columns starting with 'DB_' found.")
        return

    print(f"\n{'DB Column':<20} | {'Original Column':<30} | {'Corr':<8} | {'Max Diff':<10} | {'Status'}")
    print("-" * 90)

    for db_col in db_columns:
        match_col = find_matching_column(db_col, df.columns)
        
        if match_col:
            # Drop NaNs for comparison
            valid_data = df[[db_col, match_col]].dropna()
            
            if len(valid_data) == 0:
                 print(f"{db_col:<20} | {match_col:<30} | {'N/A':<8} | {'N/A':<10} | No Data")
                 continue

            s1 = valid_data[db_col]
            s2 = valid_data[match_col]
            
            diff = s1 - s2
            max_diff = diff.abs().max()
            correlation = s1.corr(s2)
            
            status = "MATCH" if max_diff < 0.001 else "DIFF"
            
            print(f"{db_col:<20} | {match_col:<30} | {correlation:.6f} | {max_diff:.6f}   | {status}")
            
            if status == "DIFF":
                # Print first mismatch details
                mismatch = diff[diff.abs() > 0.001].head(1)
                if not mismatch.empty:
                    idx = mismatch.index[0]
                    print(f"   >> Mismatch at {idx}: DB={s1[idx]:.4f}, Orig={s2[idx]:.4f}, Diff={diff[idx]:.4f}")
        else:
            print(f"{db_col:<20} | {'(No Match Found)':<30} | {'-':<8} | {'-':<10} | SKIPPED")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Analyze TradingView Export for discrepancies")
    parser.add_argument("file", help="Path to TV_Export.csv")
    args = parser.parse_args()
    
    analyze_export(args.file)