src/processors/rv_processor.py

"""
RV (Full Remote Viewing) dataset processor.

Processes remote viewing test data with dimensional attribute scoring.
Format: 24-29 columns with user, timestamps, image info, 16 attribute scores,
accuracy/relevance/form metrics, total score, keywords, and trial info.

More complex than RVQ - uses continuous scoring (0-100) instead of binary hit/miss.
"""

from pathlib import Path
from typing import List, Dict, Any, Optional
from datetime import datetime
import pandas as pd
import re

from ..core.base_classes import BaseProcessor
from ..core.config import Config
from ..core.exceptions import ProcessorError
from ..cleaners.encoding_cleaner import EncodingCleaner
from ..cleaners.delimiter_cleaner import DelimiterCleaner
from ..cleaners.temporal_parser import TemporalParser


class RVProcessor(BaseProcessor):
    """
    Processes RV (Full Remote Viewing) data.

    Format: 24-29 columns
    - user_id, start_time, end_time, image_filename, image_number,
    - 16 attribute scores (sr[0] through sr[15]),
    - accuracy, relevance, form, total_score,
    - keywords, trial_number, method, num_keyword_matches

    Users view a target image and describe it using dimensional attributes
    (rounded/angular, linear, etc.). Scores based on how well description
    matches the actual image attributes.
    """

    # File discovery patterns
    FILE_PATTERNS = ['rv[0-9]*.dat']

    # Attribute score column names (16 attributes)
    ATTRIBUTE_COLUMNS = [f'attr_{i:02d}' for i in range(16)]

    # Column definitions
    COLUMNS_BASE = [
        'user_id', 'start_time', 'end_time', 'image_filename', 'image_number'
    ] + ATTRIBUTE_COLUMNS + [
        'accuracy', 'relevance', 'form', 'total_score',
        'keywords', 'trial_number', 'method', 'num_keyword_matches'
    ]

    COLUMNS_UNIFIED = [
        'user_id', 'start_time', 'end_time',
        'image_filename', 'image_number'
    ] + ATTRIBUTE_COLUMNS + [
        'accuracy', 'relevance', 'form', 'total_score',
        'keywords', 'trial_number', 'method', 'num_keyword_matches',
        'file_date', 'source_file', 'source_row_number'
    ]

    def __init__(self, config: Config):
        """
        Initialize RV processor.

        Args:
            config: Configuration object
        """
        super().__init__(config, 'rv')

        # Initialize cleaners
        self.encoding_cleaner = EncodingCleaner(config, self.errata_logger)
        self.delimiter_cleaner = DelimiterCleaner(config, self.errata_logger)
        self.temporal_parser = TemporalParser(config, self.errata_logger)

        # Statistics
        self.stats = {
            'files_processed': 0,
            'files_failed': 0,
            'rows_total': 0,
            'rows_valid': 0,
            'rows_invalid': 0,
            'method_original': 0,
            'method_match_judges': 0,
            'method_keywords': 0
        }

    def extract_file_date(self, file_path: Path) -> Optional[datetime]:
        """
        Extract date from filename (rvYYMMDD.dat).

        Args:
            file_path: Path to file

        Returns:
            datetime object or None
        """
        match = re.search(r'rv(\d{6})\.dat', file_path.name)
        if not match:
            return None

        date_str = match.group(1)
        return self.temporal_parser.extract_date_from_filename(file_path.name)

    def process_file(self, file_path: Path, pre_cleaned_text: Optional[str] = None) -> Optional[pd.DataFrame]:
        """
        Process a single RV file.

        Args:
            file_path: Path to file
            pre_cleaned_text: Pre-cleaned text from parallel batch cleaning.
                If None, cleans the file inline (backward compat).

        Returns:
            DataFrame or None if processing fails
        """
        try:
            # Use pre-cleaned text if available, otherwise clean inline
            if pre_cleaned_text is not None:
                text = pre_cleaned_text
            else:
                text = self.encoding_cleaner.clean(file_path)
                text = self.delimiter_cleaner.clean(text, file_path=str(file_path))

            # Parse as CSV using Python's csv module to handle variable columns
            from io import StringIO
            import csv

            reader = csv.reader(StringIO(text), skipinitialspace=True)
            rows = list(reader)

            if not rows:
                self.errata_logger.log_error(
                    'empty_file',
                    'File is empty after CSV parsing - entire file omitted',
                    file_path=str(file_path),
                    scope='file'
                )
                return None

            # Convert to DataFrame
            df = pd.DataFrame(rows)

            if df.empty:
                self.errata_logger.log_error(
                    'empty_file',
                    'File is empty or has no valid rows - entire file omitted',
                    file_path=str(file_path),
                    scope='file'
                )
                return None

            # Check minimum column count (24)
            column_counts = df.notna().sum(axis=1)
            insufficient_cols = column_counts < 24

            if insufficient_cols.all():
                self.errata_logger.log_error(
                    'insufficient_columns',
                    'All rows have < 24 columns - entire file omitted',
                    file_path=str(file_path),
                    scope='file'
                )
                return None

            # Filter rows with insufficient columns
            if insufficient_cols.any():
                self.errata_logger.log_error(
                    'insufficient_columns',
                    f'{insufficient_cols.sum()} rows with < 24 columns',
                    file_path=str(file_path),
                    scope='row'
                )
                df = df[~insufficient_cols]

            # Assign column names based on actual column count
            max_cols = len(df.columns)
            if max_cols >= 29:
                # Drop extra columns if more than 29 (early files have extra columns)
                if max_cols > 29:
                    # Log that we're dropping extra columns from early files
                    self.errata_logger.log_error(
                        'extra_columns_dropped',
                        f'File has {max_cols} columns, dropping {max_cols - 29} extra columns from early schema',
                        file_path=str(file_path),
                        scope='row'
                    )
                    df = df.iloc[:, :29]
                df.columns = self.COLUMNS_BASE[:29]
            elif max_cols >= 24:
                df.columns = self.COLUMNS_BASE[:max_cols]
            else:
                self.errata_logger.log_error(
                    'insufficient_columns',
                    f'Max columns {max_cols} < 24 - entire file omitted',
                    file_path=str(file_path),
                    scope='file'
                )
                return None

            # Add metadata
            file_date = self.extract_file_date(file_path)
            df['file_date'] = file_date

            # Add audit columns (source file and row numbers)
            df['source_file'] = file_path.name
            df['source_row_number'] = range(1, len(df) + 1)

            # Filter test users
            test_user_mask = df['user_id'].astype(str).str.contains('_test9', na=False)
            if test_user_mask.any():
                df = df[~test_user_mask]

            # Validate and clean
            df = self.validate_dataframe(df, file_path)

            if df.empty:
                return None

            # Ensure all unified columns exist AFTER validation
            for col in self.COLUMNS_UNIFIED:
                if col not in df.columns:
                    df[col] = None

            # Reorder to unified schema
            df = df[self.COLUMNS_UNIFIED]

            # Update stats
            self.stats['files_processed'] += 1
            self.stats['rows_valid'] += len(df)

            # Track method counts
            if 'method' in df.columns:
                method_counts = df['method'].value_counts()
                for method_val, count in method_counts.items():
                    if pd.notna(method_val):
                        method_val = int(method_val)
                        if method_val % 10 == 0:  # 0 or 10
                            self.stats['method_original'] += count
                        elif method_val % 10 == 3:  # 3 or 13
                            self.stats['method_match_judges'] += count
                        elif method_val == 9:
                            self.stats['method_keywords'] += count

            return df

        except Exception as e:
            import traceback
            self.errata_logger.log_error(
                'file_processing_failed',
                f'{type(e).__name__}: {e} - entire file omitted',
                file_path=str(file_path),
                scope='file',
                context={'traceback': traceback.format_exc()},
            )
            self.stats['files_failed'] += 1
            return None

    def validate_dataframe(self, df: pd.DataFrame, file_path: Path) -> pd.DataFrame:
        """
        Validate and clean DataFrame.

        Args:
            df: Input DataFrame
            file_path: Source file path

        Returns:
            Cleaned DataFrame
        """
        initial_count = len(df)
        valid_mask = pd.Series([True] * len(df), index=df.index)


        # Validate user_id length
        if 'user_id' in df.columns:
            long_users = df['user_id'].str.len() > 64
            if long_users.any():
                valid_mask &= ~long_users
                self.errata_logger.log_error(
                    'user_id_too_long',
                    f'{long_users.sum()} rows with user_id > 64 chars',
                    file_path=str(file_path),
                    scope='row'
                )

        # Validate and clamp total_score (0-100)
        if 'total_score' in df.columns:
            df['total_score'] = self.to_numeric_logged(df['total_score'], 'total_score', str(file_path))
            # Clamp scores to 0-100 as per Perl code
            df.loc[df['total_score'] < 0, 'total_score'] = 0
            df.loc[df['total_score'] > 100, 'total_score'] = 100

        # Validate num_keyword_matches (0-5)
        if 'num_keyword_matches' in df.columns:
            df['num_keyword_matches'] = self.to_numeric_logged(df['num_keyword_matches'], 'num_keyword_matches', str(file_path))
            invalid_nwm = (df['num_keyword_matches'] < 0) | (df['num_keyword_matches'] > 5)
            if invalid_nwm.any():
                # Log but don't filter - just clamp
                self.errata_logger.log_error(
                    'num_keyword_matches_out_of_range',
                    f'{invalid_nwm.sum()} rows with num_keyword_matches not in 0-5',
                    file_path=str(file_path),
                    scope='row'
                )
                df.loc[df['num_keyword_matches'] < 0, 'num_keyword_matches'] = 0
                df.loc[df['num_keyword_matches'] > 5, 'num_keyword_matches'] = 5

        # Parse timestamps
        if 'start_time' in df.columns:
            df['start_time'] = self.temporal_parser.parse_dates_vectorized(
                df['start_time'], file_path=str(file_path)
            )

        if 'end_time' in df.columns:
            df['end_time'] = self.temporal_parser.parse_dates_vectorized(
                df['end_time'], file_path=str(file_path)
            )

        # Convert numeric columns
        numeric_cols = [
            'image_number', 'accuracy', 'relevance', 'form', 'total_score',
            'trial_number', 'method', 'num_keyword_matches'
        ] + self.ATTRIBUTE_COLUMNS

        for col in numeric_cols:
            if col in df.columns:
                df[col] = self.to_numeric_logged(df[col], col, str(file_path))

        # Filter to valid rows
        df_valid = df[valid_mask].copy()

        invalid_count = initial_count - len(df_valid)
        if invalid_count > 0:
            self.errata_logger.log_file_summary(
                str(file_path),
                'partial',
                initial_count,
                len(df_valid),
                invalid_count
            )

        return df_valid

    def get_stats(self) -> Dict[str, Any]:
        """Get processing statistics."""
        return self.stats.copy()