import json
from urllib import parse as urllib
from abc import ABC, abstractmethod
from lib.common import rest_client
from lib.services.servicemap.base_client import BaseClient


class ServiceResourceGroupClient(BaseClient):
    """Service client for ServiceMap ServiceResourceGroup API"""

    #def __init__(self, auth_provider, client, **kwargs):
    #    super().__init__(auth_provider=auth_provider, **kwargs)
    #    self.client = client

    def __init__(self, auth_provider, service, region, client=None, **kwargs):
        super(ServiceResourceGroupClient, self).__init__(auth_provider, service, region, **kwargs)
        self.client = client

    def _build_url(self):
        """Build URL for service resource group operations."""
        return self.client.get_service_resource_group_path(self.project_name)

    def _parse_response(self, resp, body, schema):
        """Parse and validate response."""
        # Handle empty response body
        if body:
            body = json.loads(body)
        else:
            body = {}
        self.validate_response(schema, resp, body)
        return rest_client.ResponseBody(resp, body)

    def list_service_resource_groups(self, id_pattern=None, pattern_type="glob", **params):
        """List service resource groups."""
        url = self._build_url()
        if params:
            url += f"?{urllib.urlencode(params)}"
        # ServiceMap API requires search criteria - use regex pattern for listing all
        pattern = id_pattern if id_pattern is not None else "*"
        get_body = json.dumps({"srvresgrp_id_pattern": {"pattern": pattern, "pattern_type": pattern_type}})
        resp, body = self.request('GET', url, body=get_body)
        return self._parse_response(
            resp, body, self.client.get_schema().list_service_resource_groups
        )

    def create_service_resource_group(self, **kwargs):
        """Create service resource group."""
        url = self._build_url()
        post_body = json.dumps(kwargs)
        resp, body = self.post(url, post_body)
        return self._parse_response(
            resp, body, self.client.get_schema().create_service_resource_group
        )

    def show_service_resource_group(self, resource_group_id):
        """Show service resource group details."""
        url = self._build_url()
        # ServiceMap API requires search criteria in body
        get_body = json.dumps({"srvresgrp_id_pattern": {"pattern": resource_group_id, "pattern_type": "exact"}})
        resp, body = self.request('GET', url, body=get_body)
        return self._parse_response(
            resp, body, self.client.get_schema().show_service_resource_group
        )

    def update_service_resource_group(self, resource_group_id, **kwargs):
        """Update service resource group."""
        url = self._build_url()
        update_body = {"id": resource_group_id, **kwargs}
        patch_body = json.dumps(update_body)
        resp, body = self.patch(url, patch_body)
        return self._parse_response(
            resp, body, self.client.get_schema().update_service_resource_group
        )

    def delete_service_resource_group(self, resource_group_id):
        """Delete service resource group."""
        url = self._build_url()
        delete_body = json.dumps({"id": resource_group_id})
        resp, body = self.delete(url, body=delete_body)
        return self._parse_response(
            resp, body, self.client.get_schema().delete_service_resource_group
        )


class ServiceResourceGroupClientInterface(ABC):
    """Interface for cloud-specific implementations."""

    @abstractmethod
    def get_schema(self):
        """Return response schemas module."""
        pass

    @abstractmethod
    def get_service_resource_group_path(self, project):
        """Return API endpoint path."""
        pass