"""
Delete a Datadog Software Catalog service.

Supports two delete modes:
1) Software Catalog entity delete:
   DELETE /api/v2/catalog/entity/{entity_id}
   - entity_id can be a UUID or an Entity Ref like "service:myservice"
   Docs: Software Catalog -> Delete a single entity  :contentReference[oaicite:2]{index=2}

2) Service Definition delete:
   DELETE /api/v2/services/definitions/{service_name}
   Docs: Service Definition -> Delete a single service definition :contentReference[oaicite:3]{index=3}

Auth:
- Set env vars: DD_API_KEY, DD_APP_KEY, and DD_SITE (e.g. datadoghq.eu, datadoghq.com, us3.datadoghq.com, ...)
"""

from __future__ import annotations

import argparse
import sys
from typing import Optional

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.software_catalog_api import SoftwareCatalogApi
from datadog_api_client.v2.api.service_definition_api import ServiceDefinitionApi


def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description="Delete a service from Datadog Software Catalog.")
    p.add_argument(
        "--mode",
        choices=["entity", "service_definition"],
        default="entity",
        help=(
            "What to delete. "
            "'entity' deletes a Software Catalog entity (entity ref like service:myservice). "
            "'service_definition' deletes a service definition by service_name."
        ),
    )

    # For entity mode
    p.add_argument(
        "--service-name",
        help="Service name. In --mode entity, this will be converted to entity ref 'service:<name>' unless --entity-id is provided.",
    )
    p.add_argument(
        "--entity-id",
        help="Entity UUID or Entity Ref (e.g. 'service:myservice'). Only used in --mode entity.",
    )

    # For service_definition mode
    p.add_argument(
        "--definition-service-name",
        help="Service name for deleting a service definition. Only used in --mode service_definition.",
    )

    return p.parse_args()


def build_entity_id(service_name: Optional[str], entity_id: Optional[str]) -> str:
    if entity_id:
        return entity_id
    if service_name:
        return f"service:{service_name}"
    raise SystemExit("ERROR: For --mode entity, you must provide --entity-id or --service-name.")


def main() -> int:
    args = parse_args()

    print(f"INFO: Running in --mode {args.mode}")

    # datadog_api_client reads DD_API_KEY / DD_APP_KEY / DD_SITE from the environment by default.
    configuration = Configuration()

    with ApiClient(configuration) as api_client:
        if args.mode == "entity":
            entity_id = build_entity_id(args.service_name, args.entity_id)
            api = SoftwareCatalogApi(api_client)

            try:
                api.delete_catalog_entity(entity_id=entity_id)
                print(f"OK: Deleted catalog entity: {entity_id}")
                return 0
            except Exception as e:
                print(f"ERROR: Failed to delete catalog entity '{entity_id}': {e}", file=sys.stderr)
                return 2

        if args.mode == "service_definition":
            service_name = args.definition_service_name
            if not service_name:
                print("ERROR: For --mode service_definition, you must provide --definition-service-name.", file=sys.stderr)
                return 2

            api = ServiceDefinitionApi(api_client)
            try:
                api.delete_service_definition(service_name=service_name)
                print(f"OK: Deleted service definition: {service_name}")
                return 0
            except Exception as e:
                print(f"ERROR: Failed to delete service definition '{service_name}': {e}", file=sys.stderr)
                return 2

    return 0


if __name__ == "__main__":
    raise SystemExit(main())