# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

import enum
from typing import Any, Literal, Self, TypedDict, cast, overload
from collections.abc import Generator

from keystoneauth1 import adapter

from openstack import exceptions
from openstack import resource
from openstack import utils


class Level(enum.Enum):
    ERROR = 'ERROR'
    WARNING = 'WARNING'
    INFO = 'INFO'
    DEBUG = 'DEBUG'


class Binary(enum.Enum):
    ANY = '*'
    API = 'cinder-api'
    VOLUME = 'cinder-volume'
    SCHEDULER = 'cinder-scheduler'
    BACKUP = 'cinder-backup'


class LogLevel(resource.Resource):
    # Properties
    #: The binary name of the service.
    binary = resource.Body('binary')
    # TODO(stephenfin): Do we need these? They are request-only.
    # #: The name of the host.
    # server = resource.Body('server')
    # #: he prefix for the log path we are querying, for example ``cinder.`` or
    # #: ``sqlalchemy.engine.`` When not present or the empty string is passed
    # #: all log levels will be retrieved.
    # prefix = resource.Body('prefix')
    #: The name of the host.
    host = resource.Body('host')
    #: The current log level that queried.
    levels = resource.Body('levels', type=dict)


class WorkerCleanupServiceResponse(TypedDict):
    id: str
    host: str
    binary: str
    cluster_name: str | None


class WorkerCleanupResponse(TypedDict):
    cleaning: list[WorkerCleanupServiceResponse]
    unavailable: list[WorkerCleanupServiceResponse]


class Service(resource.Resource):
    resources_key = 'services'
    base_path = '/os-services'

    # capabilities
    allow_list = True

    _query_mapping = resource.QueryParameters(
        'binary',
        'host',
    )

    # Properties
    #: The ID of active storage backend (cinder-volume services only)
    active_backend_id = resource.Body('active_backend_id')
    #: The availability zone of service
    availability_zone = resource.Body('zone')
    #: The state of storage backend (cinder-volume services only) (since 3.49)
    backend_state = resource.Body('backend_state')
    #: Binary name of service
    binary = resource.Body('binary')
    #: The cluster name (since 3.7)
    cluster = resource.Body('cluster')
    #: Disabled reason of service
    disabled_reason = resource.Body('disabled_reason')
    #: The name of the host where service runs
    host = resource.Body('host')
    # Whether the host is frozen or not (cinder-volume services only)
    is_frozen = resource.Body('frozen')
    #: Service name
    name = resource.Body('name', alias='binary')
    #: The volume service replication status (cinder-volume services only)
    replication_status = resource.Body('replication_status')
    #: State of service
    state = resource.Body('state')
    #: Status of service
    status = resource.Body('status')
    #: The date and time when the resource was updated
    updated_at = resource.Body('updated_at')

    # 3.32 introduced the 'set-log' action
    _max_microversion = '3.32'

    @overload
    @classmethod
    def find(
        cls,
        session: adapter.Adapter,
        name_or_id: str,
        ignore_missing: Literal[False],
        list_base_path: str | None = None,
        *,
        microversion: str | None = None,
        all_projects: bool | None = None,
        **params: Any,
    ) -> Self: ...

    @overload
    @classmethod
    def find(
        cls,
        session: adapter.Adapter,
        name_or_id: str,
        ignore_missing: bool = True,
        list_base_path: str | None = None,
        *,
        microversion: str | None = None,
        all_projects: bool | None = None,
        **params: Any,
    ) -> Self | None: ...

    @classmethod
    def find(
        cls,
        session: adapter.Adapter,
        name_or_id: str,
        ignore_missing: bool = True,
        list_base_path: str | None = None,
        *,
        microversion: str | None = None,
        all_projects: bool | None = None,
        **params: Any,
    ) -> Self | None:
        # No direct request possible, thus go directly to list
        if list_base_path:
            params['base_path'] = list_base_path

        # all_projects is a special case that is used by multiple services. We
        # handle it here since it doesn't make sense to pass it to the .fetch
        # call above
        if all_projects is not None:
            params['all_projects'] = all_projects

        data = cls.list(session, **params)

        result = None
        for maybe_result in data:
            # Since ID might be both int and str force cast
            id_value = str(cls._get_id(maybe_result))
            name_value = maybe_result.name

            if str(name_or_id) in (id_value, name_value):
                if 'host' in params and maybe_result['host'] != params['host']:
                    continue
                # Only allow one resource to be found. If we already
                # found a match, raise an exception to show it.
                if result is None:
                    result = maybe_result
                else:
                    msg = "More than one %s exists with the name '%s'."
                    msg = msg % (cls.__name__, name_or_id)
                    raise exceptions.DuplicateResource(msg)

        if result is not None:
            return result

        if ignore_missing:
            return None
        raise exceptions.NotFoundException(
            f"No {cls.__name__} found for {name_or_id}"
        )

    def commit(
        self,
        session: adapter.Adapter,
        prepend_key: bool = False,
        *args: Any,
        **kwargs: Any,
    ) -> Self:
        # we need to set prepend_key to false
        return super().commit(
            session,
            prepend_key,
            *args,
            **kwargs,
        )

    def _action(
        self,
        session: adapter.Adapter,
        action: str,
        body: dict[str, Any],
        microversion: str | None = None,
    ) -> Self:
        if not microversion:
            microversion = session.default_microversion
        url = utils.urljoin(Service.base_path, action)
        response = session.put(url, json=body, microversion=microversion)
        self._translate_response(response)
        return self

    def enable(self, session: adapter.Adapter) -> Self:
        """Enable service."""
        body = {'binary': self.binary, 'host': self.host}
        return self._action(session, 'enable', body)

    def disable(
        self, session: adapter.Adapter, *, reason: str | None = None
    ) -> Self:
        """Disable service."""
        body = {'binary': self.binary, 'host': self.host}

        if not reason:
            action = 'disable'
        else:
            action = 'disable-log-reason'
            body['disabled_reason'] = reason

        return self._action(session, action, body)

    def thaw(self, session: adapter.Adapter) -> Self:
        body = {'host': self.host}
        return self._action(session, 'thaw', body)

    def freeze(self, session: adapter.Adapter) -> Self:
        body = {'host': self.host}
        return self._action(session, 'freeze', body)

    @classmethod
    def set_log_levels(
        cls,
        session: adapter.Adapter,
        *,
        level: Level,
        binary: Binary | None = None,
        server: str | None = None,
        prefix: str | None = None,
    ) -> None:
        """Set log level for services.

        :param session: The session to use for making this request.
        :param level: The log level to set, case insensitive, accepted values
            are ``INFO``, ``WARNING``, ``ERROR`` and ``DEBUG``.
        :param binary: The binary name of the service.
        :param server: The name of the host.
        :param prefix: The prefix for the log path we are querying, for example
            ``cinder.`` or ``sqlalchemy.engine.`` When not present or the empty
            string is passed all log levels will be retrieved.
        :returns: None.
        """
        microversion = cls._assert_microversion_for(
            session, '3.32', error_message="Cannot use set-log action"
        )
        body = {
            'level': level,
            'binary': binary or '',  # cinder insists on strings
            'server': server,
            'prefix': prefix,
        }
        url = utils.urljoin(cls.base_path, 'set-log')
        response = session.put(url, json=body, microversion=microversion)
        exceptions.raise_from_response(response)

    @classmethod
    def get_log_levels(
        cls,
        session: adapter.Adapter,
        *,
        binary: Binary | None = None,
        server: str | None = None,
        prefix: str | None = None,
    ) -> Generator[LogLevel, None, None]:
        """Get log level for services.

        :param session: The session to use for making this request.
        :param binary: The binary name of the service.
        :param server: The name of the host.
        :param prefix: The prefix for the log path we are querying, for example
            ``cinder.`` or ``sqlalchemy.engine.`` When not present or the empty
            string is passed all log levels will be retrieved.
        :returns: A generator of
            :class:`~openstack.block_storage.v3.service.LogLevel` objects.
        """
        microversion = cls._assert_microversion_for(
            session, '3.32', error_message="Cannot use get-log action"
        )
        body = {
            'binary': binary or '',  # cinder insists on strings
            'server': server,
            'prefix': prefix,
        }
        url = utils.urljoin(cls.base_path, 'get-log')
        response = session.put(url, json=body, microversion=microversion)
        exceptions.raise_from_response(response)

        for entry in response.json()['log_levels']:
            yield LogLevel(
                binary=entry['binary'],
                host=entry['host'],
                levels=entry['levels'],
            )

    def failover(
        self,
        session: adapter.Adapter,
        *,
        cluster: str | None = None,
        backend_id: str | None = None,
    ) -> Self:
        """Failover a service

        Only applies to replicating cinder-volume services.
        """
        body = {'host': self.host}
        if cluster:
            body['cluster'] = cluster
        if backend_id:
            body['backend_id'] = backend_id

        action = 'failover_host'
        if utils.supports_microversion(session, '3.26'):
            action = 'failover'

        return self._action(session, action, body)

    @classmethod
    def cleanup_workers(
        cls,
        session: adapter.Adapter,
        *,
        binary: Literal['cinder-volume', 'cinder-scheduler'] | None,
        host: str | None,
        cluster_name: str | None,
        disabled: bool | None = None,
        is_up: bool | None = False,
        resource_id: str | None = None,
        resource_type: str | None = None,
        service_id: int | None = None,
    ) -> WorkerCleanupResponse:
        """Trigger cleanup of stuck operations on Cinder resources

        All filters are optional. Calling with no filters means "clean
        everything on all services that are down".

        :param session: The session to use for making this request.
        :param binary: Limit to cinder-volume or cinder-scheduler
        :param host: Target services on a specific host
        :param cluster_name: Target services in a specific cluster
        :param disabled: Filter by whether the service is admin-disabled
        :param is_up: Filter by whether the service is up. Defaults to False,
            meaning only clean up after crashed/stopped services)
        :param resource_id:
        :param resource_type: Only clean a specific type (Volume, Snapshot,
            etc.)
        :param service_id: Target a single specific service
        :returns:
        """
        microversion = cls._assert_microversion_for(
            session, '3.24', error_message="Cannot use workers API"
        )
        url = '/workers/cleanup'
        body = {
            'binary': binary,
            'cluster_name': cluster_name,
            'disabled': disabled,
            'host': host,
            'is_up': is_up,
            'resource_id': resource_id,
            'resource_type': resource_type,
            'service_id': service_id,
        }

        response = session.put(url, json=body, microversion=microversion)
        exceptions.raise_from_response(response)
        return cast(WorkerCleanupResponse, response.json())
