import logging
import sys
from dataclasses import dataclass
from pathlib import Path

from src.connectors.auth0_mng import auth0_client
from src.file_processor.base import BaseAsyncFileProcessor
from src.file_processor.reader import CsvDictReader, CsvDictReaderT
from src.file_processor.writer import CsvDictWriter, CsvDictWriterT
from src.result import BaseResult, StatusEnum
from src.utils import user_confirm

logger = logging.getLogger('users_cleanup')


@dataclass(kw_only=True)
class DeleteAuth0UsersResult(BaseResult):
    auth0_id: str


class DeleteAuth0Users(BaseAsyncFileProcessor[CsvDictReaderT, CsvDictWriterT]):
    def __init__(self, *, skip_confirmation: bool, fi: Path, fo: Path, concurrency: int):
        self.skip_confirmation = skip_confirmation
        super().__init__(fi=fi, fo=fo, concurrency=concurrency)

    def get_reader(self) -> CsvDictReader:
        def _filter(row: CsvDictReaderT) -> bool:
            return row['status'] == StatusEnum.SUCCESS.value

        return CsvDictReader(path=self.fi, row_filter=_filter, ensure_keys=('auth0_id', 'status'))

    def get_writer(self) -> CsvDictWriter:
        return CsvDictWriter(path=self.fo, queue=self.result_queue, header_keys=DeleteAuth0UsersResult.get_fields())

    async def process_row(self, _index: int, row: CsvDictReaderT) -> CsvDictWriterT:
        auth0_id = row['auth0_id']
        result = DeleteAuth0UsersResult(auth0_id=auth0_id, status=StatusEnum.SUCCESS)

        try:
            await auth0_client.delete_user(auth0_id)
        except Exception as e:
            logger.exception('Unhandled exception')
            result.status = StatusEnum.ERROR
            result.message = str(e)

        return result.to_dict()

    async def process(self) -> None:
        if self.skip_confirmation or user_confirm(f'Are you sure you want to delete auth0 users from {self.fi}?'):
            return await super().process()

        sys.exit(1)