"""
App Registration Service

Handles operations related to Azure AD app registrations.
"""

from msgraph import GraphServiceClient
from typing import List, Dict


class AppRegistrationService:
    """Service for managing app registrations via Microsoft Graph."""

    def __init__(self, graph_client: GraphServiceClient):
        """
        Initialize the app registration service.

        Args:
            graph_client: Authenticated Graph service client
        """
        self.graph_client = graph_client

    async def list_applications(self) -> List[Dict[str, str]]:
        """
        Get all app registrations from Azure AD.

        Returns:
            List[Dict]: List of app registrations with id, app_id, and display_name

        Raises:
            Exception: If the API call fails
        """
        try:
            apps = []

            # Get all applications
            result = await self.graph_client.applications.get()

            if result and result.value:
                for app in result.value:
                    apps.append({
                        'id': app.id,  # Object ID
                        'app_id': app.app_id,  # Application (client) ID
                        'display_name': app.display_name
                    })

            # Handle pagination if there are more than 100 apps
            while result and result.odata_next_link:
                # Continue fetching next page
                from kiota_abstractions.base_request_configuration import RequestConfiguration
                request_config = RequestConfiguration()
                request_config.url = result.odata_next_link

                result = await self.graph_client.applications.get(request_configuration=request_config)

                if result and result.value:
                    for app in result.value:
                        apps.append({
                            'id': app.id,
                            'app_id': app.app_id,
                            'display_name': app.display_name
                        })

            # Sort alphabetically by display name
            apps.sort(key=lambda x: x['display_name'].lower())

            return apps

        except Exception as e:
            raise Exception(f"Failed to list applications: {str(e)}")

    async def get_application(self, app_object_id: str) -> Dict[str, any]:
        """
        Get a specific app registration by its object ID.

        Args:
            app_object_id: The object ID of the app registration

        Returns:
            Dict: App registration details

        Raises:
            Exception: If the API call fails
        """
        try:
            app = await self.graph_client.applications.by_application_id(app_object_id).get()

            if app:
                return {
                    'id': app.id,
                    'app_id': app.app_id,
                    'display_name': app.display_name,
                    'password_credentials': app.password_credentials
                }

            return None

        except Exception as e:
            raise Exception(f"Failed to get application: {str(e)}")