"""
Process full RV (Full Remote Viewing) dataset and export to Parquet.

Processes all RV files and exports cleaned data.
"""

import sys
import argparse
from pathlib import Path
from datetime import datetime

sys.path.insert(0, str(Path(__file__).parent.parent))

from src.core.config import Config
from src.core.output_lock import seal_output, unlock_for_write
from src.processors.rv_processor import RVProcessor


def main():
    parser = argparse.ArgumentParser(description='Process RV dataset')
    parser.add_argument('--audit', action='store_true',
                       help='Include source_file and source_row_number columns in output')
    parser.add_argument('--data-dir',
                       help='Override raw data directory (default: data/)')
    args = parser.parse_args()

    print("="*70)
    print("RV (Full Remote Viewing) Full Dataset Processing")
    print("="*70)
    print()

    start_time = datetime.now()

    # Load config
    config = Config('config/cleaning_config.yaml')

    # Override audit mode if --audit flag is provided
    if args.audit:
        config.set('processing.audit_mode', True)
        print("Audit mode: ENABLED (including source_file and source_row_number columns)")
        print()

    # Override data directory if --data-dir flag is provided
    if args.data_dir:
        config.set('directories.raw_data', args.data_dir)


    # Create output directory
    output_dir = config.output_dir / 'parquet'
    output_dir.mkdir(parents=True, exist_ok=True)

    output_file = output_dir / 'rv_cleaned.parquet'

    print(f"Output file: {output_file}")
    print()

    # Create processor
    processor = RVProcessor(config)

    # Get file count
    try:
        all_files = processor.get_file_list()
        print(f"Total files to process: {len(all_files)}")
        print()
    except Exception as e:
        print(f"✗ Error getting file list: {e}")
        print()
        print("Expected directory: data/rv/")
        print("Make sure the raw data is in the correct location.")
        sys.exit(1)

    # Process all files
    print("Processing all RV files...")
    print("This may take some time - large dataset with ~11,708 files...")
    print()

    try:
        df = processor.process()

        elapsed = datetime.now() - start_time

        print()
        print("="*70)
        print("✓ Processing Complete!")
        print("="*70)
        print()

        # Show stats
        stats = processor.get_stats()
        print("Processing Statistics:")
        print(f"  Files processed: {stats['files_processed']:,}")
        print(f"  Files failed: {stats['files_failed']:,}")
        print(f"  Success rate: {stats['files_processed'] / len(all_files) * 100:.1f}%")
        print()
        print(f"  Total rows: {len(df):,}")
        print(f"  Valid rows: {stats['rows_valid']:,}")
        print()

        # Method distribution
        print("Scoring Method Distribution:")
        print(f"  Original (method 0/10): {stats['method_original']:,}")
        print(f"  Match judges (method 3/13): {stats['method_match_judges']:,}")
        print(f"  Keywords only (method 9): {stats['method_keywords']:,}")
        print()

        # Data quality metrics
        print("Data Quality:")
        completeness = df.notna().sum() / len(df)
        print(f"  Completeness (avg): {completeness.mean():.1%}")
        print(f"  Missing start_time: {df['start_time'].isna().sum():,} ({df['start_time'].isna().sum() / len(df) * 100:.1f}%)")
        print(f"  Missing end_time: {df['end_time'].isna().sum():,} ({df['end_time'].isna().sum() / len(df) * 100:.1f}%)")
        print()

        # Date range
        if 'start_time' in df.columns:
            valid_ts = df['start_time'].dropna()
            if not valid_ts.empty:
                print(f"Date range: {valid_ts.min()} to {valid_ts.max()}")
                print(f"Span: {(valid_ts.max() - valid_ts.min()).days} days")
                print()

        # User statistics
        print("User Statistics:")
        n_users = df['user_id'].nunique()
        print(f"  Unique users: {n_users:,}")
        if n_users > 0:
            print(f"  Trials per user (mean): {len(df) / n_users:.0f}")
        print()

        # Score distribution
        if 'total_score' in df.columns:
            print("Score Distribution:")
            score_stats = df['total_score'].describe()
            print(f"  Mean: {score_stats['mean']:.2f}")
            print(f"  Median: {score_stats['50%']:.2f}")
            print(f"  Std Dev: {score_stats['std']:.2f}")
            print(f"  Min: {score_stats['min']:.2f}")
            print(f"  Max: {score_stats['max']:.2f}")
            print()

        # Performance stats
        print(f"Processing time: {elapsed}")
        print(f"Speed: {len(df) / elapsed.total_seconds():.0f} rows/second")
        print()

        # Export to Parquet
        print("Exporting to Parquet...")
        unlock_for_write(output_file)
        df.to_parquet(
            output_file,
            engine='pyarrow',
            compression='snappy',
            index=False
        )
        seal_output(output_file)

        file_size_mb = output_file.stat().st_size / (1024 * 1024)
        print(f"✓ Exported to: {output_file}")
        print(f"  File size: {file_size_mb:.1f} MB")
        print()

        # Compression ratio
        raw_size_estimate = len(df) * 300  # Rough estimate of ~300 bytes/row in CSV (more columns)
        compression_ratio = raw_size_estimate / output_file.stat().st_size
        print(f"  Compression ratio: {compression_ratio:.1f}x")
        print()

        # Show errata summary
        errata_summary = processor.errata_logger.get_summary()
        print("Error Summary:")
        print(f"  Total errors: {errata_summary['total_errors']:,}")
        print(f"  Files with errors: {errata_summary['files_with_errors']:,}")
        if errata_summary['error_types']:
            print(f"  Error types:")
            for error_type, count in errata_summary['error_types'].items():
                print(f"    - {error_type}: {count:,}")
        print(f"  Errata log: {errata_summary['log_file']}")
        print()

        print("="*70)
        print("✓ RV Dataset Processing Complete!")
        print("="*70)

    except KeyboardInterrupt:
        print("\n\n✗ Processing interrupted by user")
        sys.exit(1)
    except Exception as e:
        print(f"\n✗ Processing failed: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == '__main__':
    main()