import os
import json
import time
import boto3
import logging
from botocore.exceptions import ClientError
from lambda_function import lambda_handler



def read_sqs_messages():
    """Read messages from SQS queue"""
    # Get queue URL from environment variable or use a default for testing
    queue_url = os.environ.get('SQS_QUEUE_URL')
    
    try:
        # Create SQS client
        sqs = boto3.client('sqs')
        
        while True:
            try:
                # Receive message from SQS queue
                response = sqs.receive_message(
                    QueueUrl=queue_url,
                    AttributeNames=['All'],
                    MaxNumberOfMessages=1,
                    MessageAttributeNames=['All'],
                    VisibilityTimeout=30,
                    WaitTimeSeconds=20
                )
                
                if 'Messages' in response:
                    messages = response['Messages']
                    print(f"Received {len(messages)} messages")
                    
                    for message in messages:
                        
                        receipt_handle = message['ReceiptHandle']
                        message_body = message['Body']

                        print("Message Body")
                        print(message_body)

                        try:
                            # Process the message with error handling
                            lambda_handler(message_body)

                            # Delete the message from the queue only if processing succeeded
                            sqs.delete_message(
                                QueueUrl=queue_url,
                                ReceiptHandle=receipt_handle
                            )
                            print(f"Successfully processed and deleted message: {receipt_handle}")

                        except (KeyError, json.JSONDecodeError, TypeError) as e:
                            # Log the error and skip this record
                            print(f"ERROR: Failed to process message due to data/parsing error: {e}")
                            print(f"Skipping problematic message: {message_body[:500]}")  # Log first 500 chars

                            # Delete the problematic message to prevent infinite retries
                            sqs.delete_message(
                                QueueUrl=queue_url,
                                ReceiptHandle=receipt_handle
                            )
                            print(f"Deleted problematic message from queue to prevent pod restart")

                        except Exception as e:
                            # For other errors, log but don't delete - let SQS retry later
                            print(f"ERROR: Unexpected error processing message: {e}")
                            print(f"Message will be retried after visibility timeout")
                            # Don't delete the message, let it become visible again for retry
                else:
                    print("No messages available in the queue")
                    
            except ClientError as e:
                print(f"Error processing SQS messages: {e}")
                time.sleep(5)  # Wait before retrying
                
    except Exception as e:
        print(f"Fatal error: {e}")
        raise

if __name__ == "__main__":
    print("SQS message reader starting")
    try:
        read_sqs_messages()
    except KeyboardInterrupt:
        print("SQS message reader stopped by user")
    except Exception as e:
        print(f"SQS reader failed with error: {e}")