class GetCredentialIfAvailableResolver:
    @hook_impl
    def after_context_created(self, context) -> None:
        # This method is called after the Kedro context is created, before catalog creation

        def custom_resolver(context, credential_name):
            # return the credential if it exists, else unset the credential by returning None
            try:
                return context.config_loader["credentials"][credential_name]
            except KeyError:
                return None
        # registering the resolver
        OmegaConf.register_new_resolver("get_credential_if_available", lambda x: custom_resolver(context, x))

class AzureBlobDefaultAzureCredentialsBlobPathsParametersCredentialsGenerator:
    # This class automatically detects STRING values parameters which contains a blob url and annd credentials for them, with the same name than the parameter but appended with _credentials
    # it uses Azure Default Credentials, wrapped to async for fsspec

    @hook_impl

    def after_context_created(self, context) -> None:

        class AsyncDefaultAzureCredentialWrapper(AsyncTokenCredential):
            """
            This class wraps the synchronous DefaultAzureCredential to provide an asynchronous interface.
            It allows the use of DefaultAzureCredential with fsspec, which requires asynchronous credentials.
            The close method is overridden to be a no-op to prevent issues when fsspec tries to close the credential.
            Note from Francis Viallet: I posted the answer to the fsspec's git issue related to this: https://github.com/fsspec/adlfs/issues/431
            """

            def __init__(self, **kwargs):
                # Initialize the synchronous DefaultAzureCredential
                self._credential = DefaultAzureCredential(**kwargs)

            async def get_token(self, *scopes, **kwargs):
                #Asynchronously get a token for the specified scopes: this method runs the synchronous get_token method in an executor to avoid blocking.
                loop = asyncio.get_event_loop()
                token = await loop.run_in_executor(None, self._credential.get_token, *scopes, **kwargs)
                return AccessToken(token.token, token.expires_on)

            async def close(self):
                #No-op close method to prevent issues when fsspec tries to close the credential.
                pass

        # Create the async credential from the sync one, with the no-op close
        credential = AsyncDefaultAzureCredentialWrapper(exclude_interactive_browser_credential=False)

        # This method is called after the Kedro context is created, before catalog creation (which we need as we will use the credentials in the catalogs): https://docs.kedro.org/en/latest/hooks/introduction.html
        
        # Filter parametetrs to get ones with azure datalake/blob fsspec's compliant path values only (pandas datasets uses fsspec derrière)
        blob_paths_parameters = {
            k: v for k, v in context.params.items() 
            if isinstance(v, str) 
            and (v.startswith('abfs://') or v.startswith('az://') or v.startswith('adl://')) 
            and ('.blob.core.windows.net/' in v or '.dfs.core.windows.net/' in v)
        }

        if len(blob_paths_parameters) > 0:
            # Initialize the DefaultAzureCredential if needed (so if parameters containing blob path were found)
            # We disable the exclude_interactive_browser_credential so when this class will ask user to authenticate in last resort if none of the previous methods works: useful when running the code on developer's Computer 
            #from azure.identity import DefaultAzureCredential # import it there because fsspec needs to uses the aio (async) version where others uses the regular one (https://github.com/fsspec/adlfs/issues/431)
            #credential = DefaultAzureCredential(exclude_interactive_browser_credential=False)

            # Iterate found parameters 
            for key, blob_path in blob_paths_parameters.items():
            
                # extract account name from blob path
                if '@' in blob_path:
                    account_name = blob_path.split('@')[-1].split('.')[0]
                else:
                    url_parsed = urlparse(blob_path)
                    account_name = url_parsed.netloc.split('.')[0]

                # Adding the credentials to the Kedro context configuration (will be added to setting.py to made them available to all the catalog/pipelines : from vmx_preprocessing.hooks import AzureSQLDefaultAzureCredentials, AzureSharepointDefaultAzureCredentials ; HOOKS = (AzureSQLDefaultAzureCredentials(), AzureSharepointDefaultAzureCredentials(),))
                context.config_loader["credentials"] = {
                    **context.config_loader["credentials"],# Keep existing credentials in the context to not lose them when overwriting the credentials object

                    f'{key}_credentials' : {
                        'account_name': account_name,
                        'credential': credential,
                        'anon': False
                    }
                }