"""
UAT Script for PP-1201: Expired Token Warning - Datadog Integration
--------------------------------------------------------------------
This script continuously fetches an expired M2M token from AWS Secrets Manager
to trigger the warning log on line 132-135 of owsclient/m2m/base.py.

The warning logs are sent to Datadog for dashboard verification.

Environment Variables:
    SERVICE_NAME: Service name for M2M_JWT_ACCESS_TOKEN secret (default: lambda-machine-1)
    ENVIRONMENT: Environment name (default: qa)
    LOOP_INTERVAL_SECONDS: Time between iterations in seconds (default: 30)
    AWS_ACCESS_KEY_ID: AWS access key
    AWS_SECRET_ACCESS_KEY: AWS secret key
    AWS_SESSION_TOKEN: AWS session token (optional)
    AWS_REGION: AWS region (default: us-east-1)
"""
import logging
import os
import sys
import time

import boto3

import logging.config
from typing import Any, Dict, Optional

from fansifter_common.logging import LogFormat
from fansifter_common.logging.utils import update_logging_config

from owsclient.m2m.base import M2MTokenManager


class UatSecretsManager:
    """Secrets Manager wrapper for UAT."""

    def __init__(self) -> None:
        """Init AWS Secrets Manager client."""
        self.boto3_session = boto3.session.Session()
        self._client = self.boto3_session.client("secretsmanager")

    def get_secret(self, secret_name: str) -> str:
        """Get a secret from AWS Secrets Manager."""
        get_secret_value_response = self._client.get_secret_value(SecretId=secret_name)
        secret_string = get_secret_value_response["SecretString"]
        return secret_string


# def configure_logging() -> None:
#     """Configure logging to output to stdout for Datadog collection."""
#     # Configure root logger
#     logging.basicConfig(
#         level=logging.INFO,
#         format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
#         stream=sys.stdout,
#         force=True
#     )
#
#     # Set owsclient.m2m.base logger to WARNING level to capture the expired token warning
#     owsclient_logger = logging.getLogger('owsclient.m2m.base')
#     owsclient_logger.setLevel(logging.WARNING)




def configure_logging(
        logging_config: Dict[str, Any],
        environment: str,
        service_name: str,
        service_version: str,
        logger_name: Optional[str] = None,
        log_format: LogFormat = "json",
        debug: bool = True,
) -> None:
    """Configure logging."""
    config = update_logging_config(
        logging_config=logging_config,
        environment=environment,
        service_name=service_name,
        service_version=service_version,
        logger_name=logger_name,
        log_format=log_format,
        debug=debug,
    )
    config['stream'] = sys.stdout
    logging.config.dictConfig(
        config
    )

    owsclient_logger = logging.getLogger('owsclient.m2m.base')
    owsclient_logger.setLevel(logging.INFO)

def main() -> None:
    """Main function to continuously trigger expired token warnings."""
    # Get configuration from environment
    service_name = os.getenv("SERVICE_NAME", "lambda-machine-1")
    environment = os.getenv("ENVIRONMENT", "qa")
    loop_interval = int(os.getenv("LOOP_INTERVAL_SECONDS", "30"))

    # Configure logging
    configure_logging(
        logging_config={
            "version": 1,
            "disable_existing_loggers": False,
            "handlers": {
                "stream": {
                    "level": "INFO",
                    "class": "fansifter_common.logging.OwsStreamHandler",
                },
                "null": {
                    "level": "WARNING",
                    "class": "logging.NullHandler",
                },
            },
            "loggers": {
                __name__: {
                    "handlers": ["stream"],  # Set this to stream to show
                    "level": "ERROR",
                },
                "owsclient": {
                    "handlers": ["stream"],
                    "level": "INFO",
                },
            },
        },
        environment=environment,
        service_name="owsclient-uat",
        service_version="0.1",
        logger_name="owsclient-uat",
    )

    logger = logging.getLogger(__name__)


    logger.info("UAT Script: PP-1201 - Expired Token Warning to Datadog")
    logger.info(f"Service Name: {service_name}")
    logger.info(f"Environment: {environment}")
    logger.info(f"Loop Interval: {loop_interval} seconds")
    logger.info(f"Secret: {environment}/{service_name}/M2M_JWT_ACCESS_TOKEN")

    # Initialize Secrets Manager
    try:
        sm = UatSecretsManager()
        logger.info("✓ AWS Secrets Manager client initialized")
    except Exception as e:
        logger.error(f"✗ Failed to initialize AWS Secrets Manager: {e}")
        sys.exit(1)

    # Loop counter
    iteration = 0

    try:
        while True:
            iteration += 1
            logger.info(f"\n--- Iteration {iteration} ---")

            # Create M2MTokenManager with NO cache to ensure warning triggers every time
            token_manager = M2MTokenManager(
                secrets_manager=sm,
                environment=environment,
                service_name=service_name,
                cache={},  # Empty dict to bypass caching
            )

            # Fetch the token - this should trigger the warning if the token is expired
            logger.info("Fetching token from Secrets Manager...")
            try:
                token_string = token_manager.get_token_string()
                logger.info(f"✓ Successfully fetched token (length: {len(token_string)})")
            except Exception as e:
                logger.error(f"✗ Error fetching token: {e}")
                # Continue to next iteration instead of exiting
                logger.info(f"Waiting {loop_interval} seconds before next attempt...")
                time.sleep(loop_interval)
                continue

            logger.info(f"Waiting {loop_interval} seconds before next iteration...")
            time.sleep(loop_interval)

    except KeyboardInterrupt:
        logger.info("\n✓ Received keyboard interrupt, shutting down gracefully...")
        sys.exit(0)
    except Exception as e:
        logger.error(f"✗ Unexpected error: {e}", exc_info=True)
        sys.exit(1)


if __name__ == "__main__":
    main()