"""
ULTRA SIMPLE - Just read the raw data, no parsing, no filters
"""
from flask import Flask, jsonify, session
from flask_login import LoginManager, login_required, current_user
import gspread
from google.oauth2.credentials import Credentials
import pandas as pd
import sys

# Import auth from app_clean
sys.path.insert(0, '.')
from app_clean import app, get_google_credentials, login_manager, User

@app.route('/raw-data')
@login_required
def raw_data():
    """Show completely raw data - no parsing, no filtering."""
    print("\n" + "="*80)
    print("[RAW] Loading COMPLETELY RAW data from sheet...")
    print("="*80)
    
    creds = get_google_credentials()
    if not creds:
        return jsonify({'error': 'No credentials'}), 401
    
    SPREADSHEET_ID = session.get('spreadsheet_id')
    if not SPREADSHEET_ID:
        return jsonify({'error': 'No spreadsheet ID'}), 400
    
    try:
        gc = gspread.authorize(creds)
        spreadsheet = gc.open_by_key(SPREADSHEET_ID)
        
        # Get sheet BASE (index 1)
        worksheet = spreadsheet.worksheets()[1]
        print(f"[RAW] Sheet name: {worksheet.title}")
        print(f"[RAW] Sheet size: {worksheet.row_count} rows x {worksheet.col_count} cols")
        
        # Get ALL values
        all_values = worksheet.get_all_values()
        print(f"[RAW] get_all_values() returned {len(all_values)} rows")
        
        headers = all_values[0]
        print(f"\n[RAW] Column headers ({len(headers)} cols):")
        for i, h in enumerate(headers):
            print(f"[RAW]   [{i}] '{h}'")
        
        # Find Faturaçao column
        fat_col_idx = None
        fat_col_name = None
        for i, h in enumerate(headers):
            if 'fatura' in h.lower():
                fat_col_idx = i
                fat_col_name = h
                break
        
        if fat_col_idx is None:
            print("[RAW] ERROR: Faturaçao column NOT FOUND!")
            return jsonify({'error': 'Faturaçao column not found', 'columns': headers}), 400
        
        print(f"\n[RAW] Found Faturaçao at column [{fat_col_idx}]: '{fat_col_name}'")
        
        # Get all data rows (skip header)
        data_rows = all_values[1:]
        print(f"[RAW] Total data rows: {len(data_rows)}")
        
        # Create DataFrame WITHOUT any parsing
        df = pd.DataFrame(data_rows, columns=headers)
        print(f"[RAW] DataFrame shape: {df.shape}")
        
        # Show raw Faturaçao values
        print(f"\n[RAW] First 20 RAW Faturaçao values (NO PARSING):")
        for i, val in enumerate(df[fat_col_name].head(20)):
            print(f"[RAW]   [{i}] {repr(val)} (type: {type(val).__name__})")
        
        # Try to convert to numeric (pandas auto-convert)
        print(f"\n[RAW] Attempting pandas numeric conversion...")
        fat_numeric = pd.to_numeric(df[fat_col_name], errors='coerce')
        
        print(f"[RAW] Converted values:")
        print(f"[RAW]   Non-null count: {fat_numeric.notna().sum()}")
        print(f"[RAW]   Null/NaN count: {fat_numeric.isna().sum()}")
        print(f"[RAW]   Sum: {fat_numeric.sum():,.2f}")
        print(f"[RAW]   First 20 converted values: {fat_numeric.head(20).tolist()}")
        
        # Show sample of problematic values
        print(f"\n[RAW] Sample of values that couldn't be converted:")
        problem_vals = df[fat_col_name][fat_numeric.isna()].head(10)
        for i, val in enumerate(problem_vals):
            print(f"[RAW]   {repr(val)}")
        
        result = {
            'total_rows': len(data_rows),
            'total_columns': len(headers),
            'column_names': headers,
            'faturaçao_column': fat_col_name,
            'faturaçao_column_index': fat_col_idx,
            'raw_faturaçao_samples': df[fat_col_name].head(20).tolist(),
            'numeric_sum': float(fat_numeric.sum()),
            'converted_non_null': int(fat_numeric.notna().sum()),
            'converted_null': int(fat_numeric.isna().sum()),
            'expected_from_looker_studio': 34467590.51
        }
        
        print(f"\n[RAW] RESULT: {result}")
        
        return jsonify(result)
        
    except Exception as e:
        print(f"[RAW] ERROR: {e}")
        import traceback
        traceback.print_exc()
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    print("Go to: /raw-data")
    app.run(debug=True, port=5000)