#!/usr/bin/env python3

import json
import os
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build

# Setup authentication
def authenticate():
    SCOPES = ['https://www.googleapis.com/auth/presentations']
    creds = None
    
    token_path = '/root/.openclaw/workspace/google-auth/token.json'
    creds_path = '/root/.openclaw/workspace/google-auth/credentials.json'
    
    # Load token data
    with open(token_path, 'r') as f:
        token_data = json.load(f)
    
    # Load credentials data  
    with open(creds_path, 'r') as f:
        creds_data = json.load(f)['installed']
    
    # Combine token and credential info
    combined_info = {
        'client_id': creds_data['client_id'],
        'client_secret': creds_data['client_secret'],
        'refresh_token': token_data['refresh_token'],
        'type': 'authorized_user'
    }
    
    if 'access_token' in token_data:
        combined_info['token'] = token_data['access_token']
    
    creds = Credentials.from_authorized_user_info(combined_info, SCOPES)
    print(f"Credentials created: {creds is not None}")
    print(f"Credentials valid: {creds.valid if creds else 'N/A'}")
    print(f"Credentials expired: {creds.expired if creds else 'N/A'}")
    print(f"Has refresh token: {bool(creds.refresh_token) if creds else 'N/A'}")
    
    if not creds or not creds.valid:
        if creds and creds.refresh_token:
            print("Refreshing credentials...")
            creds.refresh(Request())
            print(f"After refresh - valid: {creds.valid}")
        else:
            print(f"Cannot refresh: creds={creds is not None}, refresh_token={bool(creds.refresh_token) if creds else 'N/A'}")
            raise Exception("No valid credentials found")
    
    return build('slides', 'v1', credentials=creds)

def get_text_elements_with_position(slide):
    """Extract all text elements with their Y positions"""
    text_elements = []
    
    for element in slide.get('pageElements', []):
        if 'shape' in element and element['shape'].get('shapeType') == 'TEXT_BOX':
            shape = element['shape']
            text_content = shape.get('text', {})
            
            # Get Y position from transform
            transform = element.get('transform', {})
            translate_y = transform.get('translateY', 0)
            
            # Extract text content
            text_runs = []
            for text_element in text_content.get('textElements', []):
                if 'textRun' in text_element:
                    text_runs.append(text_element['textRun']['content'])
            
            full_text = ''.join(text_runs).strip()
            
            if full_text:  # Only include non-empty text elements
                text_elements.append({
                    'objectId': element['objectId'],
                    'y_position': translate_y,
                    'text': full_text,
                    'element': element
                })
    
    # Sort by Y position (top to bottom)
    text_elements.sort(key=lambda x: x['y_position'])
    return text_elements

def create_text_style_request(object_id, font_size, font_family, bold, color_r, color_g, color_b):
    """Create text style update request"""
    return {
        'updateTextStyle': {
            'objectId': object_id,
            'style': {
                'fontSize': {
                    'magnitude': font_size,
                    'unit': 'PT'
                },
                'fontFamily': font_family,
                'bold': bold,
                'foregroundColor': {
                    'opaqueColor': {
                        'rgbColor': {
                            'red': color_r,
                            'green': color_g,
                            'blue': color_b
                        }
                    }
                }
            },
            'fields': 'fontSize,fontFamily,bold,foregroundColor'
        }
    }

def create_shape_resize_request(object_id, width_emu, height_emu):
    """Create shape resize request"""
    return {
        'updateShapeProperties': {
            'objectId': object_id,
            'shapeProperties': {
                'shapeBackgroundFill': {
                    'solidFill': {
                        'color': {
                            'rgbColor': {
                                'red': 1.0,
                                'green': 1.0,
                                'blue': 1.0
                            }
                        },
                        'alpha': 0.0
                    }
                },
                'contentAlignment': 'TOP'
            },
            'fields': 'contentAlignment,shapeBackgroundFill'
        }
    }

def create_size_request(object_id, width_emu, height_emu):
    """Create size update request"""
    return {
        'updatePageElementTransform': {
            'objectId': object_id,
            'transform': {
                'scaleX': 1.0,
                'scaleY': 1.0,
                'unit': 'EMU'
            },
            'applyMode': 'ABSOLUTE'
        }
    }

def main():
    PRESENTATION_ID = '1H0gtkiFYcWKWMMbSpYeW2QuMlxSccmW_qYfeYNiNb2E'
    
    # Authenticate and get service
    service = authenticate()
    
    # Get presentation
    presentation = service.presentations().get(presentationId=PRESENTATION_ID).execute()
    slides = presentation.get('slides', [])
    
    print(f"Found {len(slides)} slides")
    
    # Process each slide
    all_requests = []
    results = []
    
    for i, slide in enumerate(slides, 1):
        slide_id = slide['objectId']
        print(f"\nProcessing slide {i} (ID: {slide_id})")
        
        # Get text elements sorted by Y position
        text_elements = get_text_elements_with_position(slide)
        print(f"  Found {len(text_elements)} text elements")
        
        # Log the text elements for verification
        slide_info = {
            'slide_number': i,
            'slide_id': slide_id,
            'text_elements': []
        }
        
        for j, elem in enumerate(text_elements):
            role = "Unknown"
            if j == 0:
                role = "Context Label (TOPMOST)"
            elif j == 1:
                role = "Title (SECOND)"
            elif j == 2:
                role = "Body (THIRD)"
            
            slide_info['text_elements'].append({
                'position': j + 1,
                'role': role,
                'object_id': elem['objectId'],
                'y_position': elem['y_position'],
                'text': elem['text'][:100] + ('...' if len(elem['text']) > 100 else '')
            })
            
            print(f"    {j+1}. {role}: {elem['objectId']} - Y:{elem['y_position']} - '{elem['text'][:50]}'")
        
        results.append(slide_info)
        
        # Apply formatting based on position
        for j, elem in enumerate(text_elements):
            object_id = elem['objectId']
            
            if j == 0:  # TOPMOST - Context label
                # Red 10pt Montserrat bold
                all_requests.append(create_text_style_request(
                    object_id, 10, 'Montserrat', True, 0.8, 0.0, 0.0
                ))
                # Resize text box
                all_requests.append(create_shape_resize_request(object_id, 1828800, 274320))
                
            elif j == 1:  # SECOND - Title
                # Black 28pt Montserrat bold
                all_requests.append(create_text_style_request(
                    object_id, 28, 'Montserrat', True, 0.0, 0.0, 0.0
                ))
                
            elif j == 2:  # THIRD - Body
                # Dark gray 14pt Noto Sans regular
                all_requests.append(create_text_style_request(
                    object_id, 14, 'Noto Sans', False, 0.2, 0.2, 0.2
                ))
    
    # Execute all requests in batches
    print(f"\nExecuting {len(all_requests)} requests...")
    
    # Split into batches of 25 (API limit)
    batch_size = 25
    for i in range(0, len(all_requests), batch_size):
        batch = all_requests[i:i + batch_size]
        print(f"Executing batch {i//batch_size + 1} with {len(batch)} requests")
        
        try:
            result = service.presentations().batchUpdate(
                presentationId=PRESENTATION_ID,
                body={'requests': batch}
            ).execute()
            print(f"  Success: {len(result.get('replies', []))} replies")
        except Exception as e:
            print(f"  Error: {e}")
    
    # Write results report
    report_content = "# Presentation Fix Report - Version 3\n\n"
    report_content += f"Processed {len(slides)} slides with {len(all_requests)} total formatting requests.\n\n"
    
    # Show first 3 slides for verification
    for slide_info in results[:3]:
        report_content += f"## Slide {slide_info['slide_number']} (ID: {slide_info['slide_id']})\n\n"
        for elem in slide_info['text_elements']:
            report_content += f"- **{elem['role']}** (Position {elem['position']})\n"
            report_content += f"  - Object ID: `{elem['object_id']}`\n"
            report_content += f"  - Y Position: {elem['y_position']}\n"
            report_content += f"  - Text: \"{elem['text']}\"\n\n"
    
    report_content += "## Formatting Applied\n\n"
    report_content += "- **Context Label (TOPMOST)**: 10pt Montserrat Bold Red (0.8,0,0), resized text box\n"
    report_content += "- **Title (SECOND)**: 28pt Montserrat Bold Black (0,0,0)\n"
    report_content += "- **Body (THIRD)**: 14pt Noto Sans Regular Dark Gray (0.2,0.2,0.2)\n\n"
    
    # Write report
    with open('/root/.openclaw/workspace/thibault-fix3-report.md', 'w') as f:
        f.write(report_content)
    
    print(f"\nCompleted! Report written to thibault-fix3-report.md")
    print("\nFirst 3 slides element mapping:")
    for slide_info in results[:3]:
        print(f"\nSlide {slide_info['slide_number']}:")
        for elem in slide_info['text_elements']:
            print(f"  {elem['role']}: {elem['object_id']} - '{elem['text'][:80]}'")

if __name__ == '__main__':
    main()