from unittest.mock import patch

import pytest
from datadog_api_client.v1.model.dashboard_summary import DashboardSummary
from datadog_api_client.v1.model.dashboard_summary_definition import DashboardSummaryDefinition
from datadog_api_client.v2.model.entity_attributes import EntityAttributes
from datadog_api_client.v2.model.entity_data import EntityData
from datadog_api_client.v2.model.entity_response_included_schema_attributes import (
    EntityResponseIncludedSchemaAttributes,
)
from datadog_api_client.v2.model.entity_v3 import EntityV3
from datadog_api_client.v2.model.list_entity_catalog_response import ListEntityCatalogResponse
from datadog_api_client.v2.model.list_entity_catalog_response_included_item import ListEntityCatalogResponseIncludedItem
from datadog_api_client.v2.model.team import Team
from datadog_api_client.v2.model.team_attributes import TeamAttributes
from datadog_api_client.v2.model.team_type import TeamType

from datadog_tools.connectors.datadog import Datadog
from datadog_tools.models.software_catalog import KindEnum


@pytest.fixture()
def mock_teams_api():
    with patch("datadog_tools.connectors.datadog.TeamsApi") as teams_api:
        yield teams_api.return_value


@pytest.fixture()
def mock_dashboards_api():
    with patch("datadog_tools.connectors.datadog.DashboardsApi") as dashboards_api:
        yield dashboards_api.return_value


@pytest.fixture()
def mock_software_catalog_api():
    with patch("datadog_tools.connectors.datadog.SoftwareCatalogApi") as software_catalog_api:
        yield software_catalog_api.return_value


@pytest.fixture()
def mock_teams(mock_teams_api):
    mock_teams_api.list_teams_with_pagination.return_value = (
        Team(
            id="team-1",
            type=TeamType.TEAM,
            attributes=TeamAttributes(name="Team 1", handle="team1"),
        ),
        Team(
            id="team-2",
            type=TeamType.TEAM,
            attributes=TeamAttributes(name="Team 2", handle="team2"),
        ),
    )


@pytest.fixture()
def mock_dashboards(mock_dashboards_api):
    mock_dashboards_api.list_dashboards.return_value = DashboardSummary(
        dashboards=[
            DashboardSummaryDefinition(id="dashboard-1", title="Dashboard 1"),
            DashboardSummaryDefinition(id="dashboard-2", title="Dashboard 2"),
        ]
    )


@pytest.fixture()
def mock_software_catalog_entity():
    return {
        "apiVersion": "v3",
        "kind": "service",
        "metadata": {
            "name": "test-service",
        },
    }


@pytest.fixture()
def mock_system(mock_software_catalog_api):
    mock_software_catalog_api.list_catalog_entity.return_value = ListEntityCatalogResponse(
        data=[
            EntityData(
                attributes=EntityAttributes(
                    name="test-system",
                    kind="system",
                    owner="team1",
                )
            ),
            EntityData(
                attributes=EntityAttributes(
                    name="test-system-2",
                    kind="system",
                    owner="team2",
                )
            ),
        ]
    )


@pytest.fixture()
def mock_entity_paginator(mock_software_catalog_api):
    page1 = EntityData(
        attributes=EntityAttributes(
            name="test-service",
            kind="service",
            owner="team1",
        )
    )

    def _generator(*args, **kwargs):
        yield page1

    mock_software_catalog_api.list_catalog_entity_with_pagination.return_value = _generator()


@pytest.fixture()
def mock_empty_entity_paginator(mock_software_catalog_api):
    def _generator(*args, **kwargs):
        if False:
            yield

    mock_software_catalog_api.list_catalog_entity_with_pagination.return_value = _generator()


@pytest.fixture()
def mock_entity_schema(mock_software_catalog_api):
    mock_software_catalog_api.list_catalog_entity.return_value = ListEntityCatalogResponse(
        data=[
            EntityData(
                attributes=EntityAttributes(
                    name="test-service",
                    kind="service",
                    owner="team1",
                )
            )
        ],
        included=[
            ListEntityCatalogResponseIncludedItem(
                attributes=EntityResponseIncludedSchemaAttributes(
                    schema=EntityV3(
                        name="test-service",
                        kind="service",
                        owner="team1",
                        extensions={
                            "sonymusic-pde.com/metadata-source": {
                                "revision": "somerevision",
                            }
                        },
                    )
                )
            )
        ],
    )


def test_get_teams(mock_teams):
    with Datadog(api_key="api_key", app_key="app_key") as datadog:
        teams = datadog.get_teams()

    assert teams == ["team1", "team2"]


def test_get_dashboards(mock_dashboards):
    with Datadog(api_key="api_key", app_key="app_key") as datadog:
        dashboards = datadog.get_dashboards()

    assert dashboards == [
        DashboardSummaryDefinition(id="dashboard-1", title="Dashboard 1"),
        DashboardSummaryDefinition(id="dashboard-2", title="Dashboard 2"),
    ]


def test_upsert_catalog_entity(mock_software_catalog_api, mock_software_catalog_entity):
    with Datadog(api_key="api_key", app_key="app_key") as datadog:
        datadog.upsert_catalog_entity(mock_software_catalog_entity)

    mock_software_catalog_api.upsert_catalog_entity.assert_called_once_with(body=mock_software_catalog_entity)


def test_get_system(mock_system):
    with Datadog(api_key="api_key", app_key="app_key") as datadog:
        system = datadog.get_system("test-system")

    assert system == EntityData(
        attributes=EntityAttributes(
            name="test-system",
            kind="system",
            owner="team1",
        )
    )


def test_get_system_not_found(mock_software_catalog_api):
    with Datadog(api_key="api_key", app_key="app_key") as datadog:
        system = datadog.get_system("test-system")

    assert system is None


def test_get_entity_schema(mock_entity_schema):
    with Datadog(api_key="api_key", app_key="app_key") as datadog:
        schema = datadog.get_entity_schema(name="test-service", kind=KindEnum.service)

    assert (
        schema
        == EntityV3(
            name="test-service",
            kind="service",
            owner="team1",
            extensions={
                "sonymusic-pde.com/metadata-source": {
                    "revision": "somerevision",
                }
            },
        ).to_dict()
    )


def test_get_entity_schema_not_found(mock_software_catalog_api):
    with Datadog(api_key="api_key", app_key="app_key") as datadog:
        schema = datadog.get_entity_schema(name="test-service", kind=KindEnum.service)

    assert schema is None


def test_list_entities(mock_entity_schema, mock_entity_paginator):
    with Datadog(api_key="api_key", app_key="app_key") as datadog:
        entities = datadog.list_entities(kind=KindEnum.service)

    assert entities == [
        EntityV3(
            name="test-service",
            kind="service",
            owner="team1",
            extensions={
                "sonymusic-pde.com/metadata-source": {
                    "revision": "somerevision",
                }
            },
        ).to_dict()
    ]


def test_empty_list_entities(mock_empty_entity_paginator):
    with Datadog(api_key="api_key", app_key="app_key") as datadog:
        entities = datadog.list_entities(kind=KindEnum.service)

    assert entities == []