"""Lambda test module."""

import sys
from datetime import datetime, timedelta, timezone
from unittest.mock import MagicMock, patch

# Mock config module before importing app to avoid AWS credential issues
mock_config = MagicMock()
mock_config.DD_API_KEY = "test-api-key"
mock_config.DD_APP_KEY = "test-app-key"
mock_config.AWS_REGION = "us-east-1"
mock_config.RESOURCE_EXPLORER_VIEW_ARN = "arn:aws:resource-explorer-2:test"
sys.modules["config"] = mock_config

from src import app as index  # noqa: E402


def test_find_missing_services():
    """Test finding services missing from Datadog catalog."""
    datadog_services = {"service-a": {}, "service-b": {}}
    aws_resources = [
        {"service": "service-a", "arn": "arn:1"},
        {"service": "service-c", "arn": "arn:2"},
    ]

    with patch("src.app.format_missing_service") as mock_format:
        mock_format.return_value = {
            "service": "service-c",
            "environments": [],
            "resource_types": [],
            "application_families": [],
            "arns": ["arn:2"],
            "terraformed": False,
            "earliest_reported_date": None,
        }

        result = index.find_missing_services(datadog_services, aws_resources)

        assert len(result) == 1
        assert result[0]["service"] == "service-c"
        mock_format.assert_called_once()


@patch("src.app.boto3.client")
def test_search_aws_resources(mock_boto_client):
    """Test searching AWS resources using Resource Explorer."""
    mock_aws_client = MagicMock()
    mock_boto_client.return_value = mock_aws_client

    old_date = datetime.now(timezone.utc) - timedelta(weeks=3)

    mock_aws_client.list_resources.return_value = {
        "Resources": [
            {
                "Arn": "arn:aws:lambda:us-east-1:123:function:my-service",
                "OwningAccountId": "123",
                "ResourceType": "lambda:function",
                "Region": "us-east-1",
                "Properties": [
                    {
                        "Name": "tags",
                        "Data": [
                            {"Key": "service_name", "Value": "my-service"},
                            {"Key": "environment", "Value": "prod"},
                        ],
                        "LastReportedAt": old_date,
                    }
                ],
                "LastReportedAt": old_date,
            }
        ],
        "NextToken": None,
    }

    result = index.search_aws_resources("resourcetype:lambda:function")

    assert len(result) == 1
    assert result[0]["service"] == "my-service"
    assert result[0]["environment"] == "prod"
    assert result[0]["resource_type"] == "lambda:function"


@patch("src.app.ApiClient")
def test_get_datadog_services(mock_api_client):
    """Test fetching services from Datadog Software Catalog."""
    mock_datadog_client = MagicMock()
    mock_api_client.return_value.__enter__.return_value = mock_datadog_client

    mock_datadog_api = MagicMock()
    mock_datadog_client.return_value = mock_datadog_api

    # Mock response
    mock_response = MagicMock()
    mock_response.included = [
        MagicMock(
            to_dict=lambda: {
                "attributes": {
                    "schema": {
                        "metadata": {"name": "test-service"},
                        "extensions": {"sonymusic-pde.com/metadata-source": {}},
                    }
                }
            }
        )
    ]
    mock_response.data = [MagicMock()]

    with patch("src.app.SoftwareCatalogApi") as mock_catalog_api:
        mock_catalog_api.return_value.list_catalog_entity.return_value = (
            mock_response
        )

        result = index.get_datadog_services()

        assert "test-service" in result
        assert isinstance(result, dict)