from datetime import datetime
import logging

import dataclasses
from analyst.resource_leak import model
from analyst.libs import consts

logger = logging.getLogger("recycler.cloud_resource_recycle")


@dataclasses.dataclass
class CleanResult:
    asset: model.CloudAsset = None
    result: consts.CleanResult = consts.CleanResult.Unknown
    reason: str = ''

    def build_db_record4save(self, now: datetime, batch_id: str) -> dict:
        return {
            'asset_id': self.asset.id,
            'batch_id': batch_id,
            'result': self.result,
            'reason': self.reason,
            'created_at': now,
        }


class CloudResourceCleaner(object):
    # whether to use API dry run call to instead of do dry run manually
    USE_API_DRY_RUN = False

    def __init__(self, dryrun: bool = False, require_delete_metadata: bool = False):
        self.dryrun = dryrun
        self.require_delete_metadata = require_delete_metadata
        # self.infra_api_k8s_cli = get_infra_api_cli()
        # self.cr_api = client.CustomObjectsApi(api_client=self.infra_api_k8s_cli)

    def skip(self, r: model.CloudAsset) -> (bool, str):
        if r.status != consts.ResourceUseState.Leaked:
            return True, f'Skip. Resource status is {r.status}'
        return False, ''

    def _clean_metadata_from_k8s(self, r: model.CloudAsset):
        pass

    def _clean_cloud_resource(self, r: model.CloudAsset) -> CleanResult:
        pass

    def clean(self, r: model.CloudAsset) -> CleanResult:
        if self.dryrun:
            if self.USE_API_DRY_RUN:
                logger.info('use API dry run mode')
            else:
                return CleanResult(result=consts.CleanResult.DryRun, reason=f'Dryrun: Would clean {r.uniq_key()}', )

        if self.require_delete_metadata:
            self._clean_metadata_from_k8s(r)
        result = self._clean_cloud_resource(r)
        logger.info(f'clean {r.uniq_key()}, result={result}')
        return result