from typing import Dict, List, Optional

from apollo_utils.job.clients.base.client import BaseApiClient

from src.clients.base_config import ApiConfig
from src.config import config
from src.constants import APP_HEADER, Service
from src.utils.api import check_delete_dict_is_empty, request_in_chunks, request_with_limit, sum_delete_dicts, sum_lists


class UserDataClientConfig(ApiConfig):
    service = Service.USER_DATA


class UserDataClient(UserDataClientConfig, BaseApiClient):
    @request_in_chunks(config.USER_DATA_CHECK_LIMIT, "user_id_list", sum_lists)
    def get_accounts(self, is_active: bool = True, user_id_list: Optional[List[str]] = None) -> List[str]:
        result = self.send_request(
            "private/accounts/",
            method="GET",
            headers=APP_HEADER,
            get_json=True,
            is_active=is_active,
            include="user_id",
            user_id=user_id_list,
        )
        return result["items"]

    @request_in_chunks(config.DEACTIVATE_ACCOUNTS_LIMIT, "user_id_list", sum_delete_dicts)
    def deactivate_accounts(self, user_id_list: List[dict]) -> List[int]:
        if not user_id_list:
            return []
        result = self.send_request(
            "private/accounts/",
            method="DELETE",
            headers=APP_HEADER,
            get_json=True,
            user_id=user_id_list,
            **({"include": config.DEACTIVATE_ACCOUNTS_INCLUDE} if config.DEACTIVATE_ACCOUNTS_INCLUDE else {}),
        )
        return result["items"]

    @request_with_limit(config.DELETE_INACTIVE_ACCOUNTS_LIMIT, sum_delete_dicts, check_delete_dict_is_empty)
    def delete_inactive_accounts(self) -> List[dict]:
        result = self.send_request(
            "private/accounts/inactive/",
            method="DELETE",
            headers=APP_HEADER,
            get_json=True,
            days=config.STORED_PERIOD,
            include=config.DELETE_INACTIVE_ACCOUNTS_INCLUDE,
            **({"limit": config.DELETE_INACTIVE_ACCOUNTS_LIMIT} if config.DELETE_INACTIVE_ACCOUNTS_LIMIT else {}),
        )
        return result["items"]

    @request_with_limit(config.DELETE_EVENTS_LIMIT, sum_delete_dicts, check_delete_dict_is_empty)
    def delete_old_events(self) -> List[int]:
        result = self.send_request(
            "private/events/",
            method="DELETE",
            headers=APP_HEADER,
            get_json=True,
            days=config.STORED_PERIOD,
            **({"limit": config.DELETE_EVENTS_LIMIT} if config.DELETE_EVENTS_LIMIT else {}),
        )
        return result["items"]

    @request_with_limit(config.DELETE_MESSAGES_LIMIT, sum_delete_dicts, check_delete_dict_is_empty)
    def delete_old_messages(self) -> Dict[str, List[int]]:
        if not config.DELETE_MESSAGES_TYPES:
            return {}
        result = self.send_request(
            "private/messages/",
            method="DELETE",
            headers=APP_HEADER,
            get_json=True,
            days=config.STORED_PERIOD,
            type=config.DELETE_MESSAGES_TYPES,
            **({"limit": config.DELETE_MESSAGES_LIMIT} if config.DELETE_MESSAGES_LIMIT else {}),
        )
        return result["items"]