import os
import typing as T
from distutils.version import LooseVersion

import numpy as np  # type: ignore
import xarray as xr

from . import dataset

if LooseVersion(xr.__version__) <= "0.17.0":
    raise ImportError("xarray_plugin module needs xarray version >= 0.18+")

from xarray.backends.common import (
    BACKEND_ENTRYPOINTS,
    AbstractDataStore,
    BackendArray,
    BackendEntrypoint,
)

# FIXME: Add a dedicated lock, even if ecCodes is supposed to be thread-safe
#   in most circumstances. See:
#       https://confluence.ecmwf.int/display/ECC/Frequently+Asked+Questions
ECCODES_LOCK = xr.backends.locks.SerializableLock()  # type: ignore


class CfGribDataStore(AbstractDataStore):
    """
    Implements the ``xr.AbstractDataStore`` read-only API for a GRIB file.
    """

    def __init__(
        self,
        filename: str,
        lock: T.Union[T.ContextManager[T.Any], None] = None,
        **backend_kwargs: T.Any,
    ):
        if lock is None:
            lock = ECCODES_LOCK
        self.lock = xr.backends.locks.ensure_lock(lock)  # type: ignore
        self.ds = dataset.open_file(filename, **backend_kwargs)

    def open_store_variable(self, var: dataset.Variable,) -> xr.Variable:
        if isinstance(var.data, np.ndarray):
            data = var.data
        else:
            wrapped_array = CfGribArrayWrapper(self, var.data)
            data = xr.core.indexing.LazilyIndexedArray(wrapped_array)  # type: ignore
        encoding = self.ds.encoding.copy()
        encoding["original_shape"] = var.data.shape

        return xr.Variable(var.dimensions, data, var.attributes, encoding)  # type: ignore

    def get_variables(self) -> xr.core.utils.Frozen[T.Any, T.Any]:
        return xr.core.utils.FrozenDict(
            (k, self.open_store_variable(v)) for k, v in self.ds.variables.items()
        )

    def get_attrs(self) -> xr.core.utils.Frozen[T.Any, T.Any]:
        return xr.core.utils.Frozen(self.ds.attributes)

    def get_dimensions(self) -> xr.core.utils.Frozen[T.Any, T.Any]:
        return xr.core.utils.Frozen(self.ds.dimensions)

    def get_encoding(self) -> T.Dict[str, T.Set[str]]:
        dims = self.get_dimensions()
        encoding = {"unlimited_dims": {k for k, v in dims.items() if v is None}}
        return encoding


class CfGribBackend(BackendEntrypoint):
    def guess_can_open(self, store_spec: str,) -> bool:
        try:
            _, ext = os.path.splitext(store_spec)
        except TypeError:
            return False
        return ext in {".grib", ".grib2", ".grb", ".grb2"}

    def open_dataset(
        self,
        filename_or_obj: str,
        *,
        mask_and_scale: bool = True,
        decode_times: bool = True,
        concat_characters: bool = True,
        decode_coords: bool = True,
        drop_variables: T.Union[T.Iterable[str], None] = None,
        use_cftime: T.Union[bool, None] = None,
        decode_timedelta: T.Union[bool, None] = None,
        lock: T.Union[T.ContextManager[T.Any], None] = None,
        indexpath: str = "{path}.{short_hash}.idx",
        filter_by_keys: T.Dict[str, T.Any] = {},
        read_keys: T.Iterable[str] = (),
        encode_cf: T.Sequence[str] = ("parameter", "time", "geography", "vertical"),
        squeeze: bool = True,
        time_dims: T.Iterable[str] = ("time", "step"),
        errors: str = "warn",
        extra_coords: T.Dict[str, T.Union[str, T.Tuple[str, ...]]] = {},
    ) -> xr.Dataset:

        store = CfGribDataStore(
            filename_or_obj,
            indexpath=indexpath,
            filter_by_keys=filter_by_keys,
            read_keys=read_keys,
            encode_cf=encode_cf,
            squeeze=squeeze,
            time_dims=time_dims,
            lock=lock,
            errors=errors,
            extra_coords=extra_coords,
        )
        with xr.core.utils.close_on_error(store):
            vars, attrs = store.load()  # type: ignore
            encoding = store.get_encoding()
            vars, attrs, coord_names = xr.conventions.decode_cf_variables(
                vars,
                attrs,
                mask_and_scale=mask_and_scale,
                decode_times=decode_times,
                concat_characters=concat_characters,
                decode_coords=decode_coords,
                drop_variables=drop_variables,
                use_cftime=use_cftime,
                decode_timedelta=decode_timedelta,
            )  # type: ignore

            ds = xr.Dataset(vars, attrs=attrs)
            ds = ds.set_coords(coord_names.intersection(vars))
            ds.set_close(store.close)
            ds.encoding = encoding
        return ds


class CfGribArrayWrapper(BackendArray):
    def __init__(
        self, datastore: CfGribDataStore, array: T.Union[dataset.OnDiskArray, np.ndarray]
    ):
        self.datastore = datastore
        self.shape = array.shape
        self.dtype = array.dtype
        self.array = array

    def __getitem__(self, key: xr.core.indexing.ExplicitIndexer,) -> np.ndarray:
        return xr.core.indexing.explicit_indexing_adapter(
            key, self.shape, xr.core.indexing.IndexingSupport.BASIC, self._getitem
        )

    def _getitem(self, key: T.Tuple[T.Any, ...],) -> np.ndarray:
        with self.datastore.lock:
            return self.array[key]

@@ -3380,39 +3380,11 @@
 tr, 
-T.Union%5Bstr, T.Tuple%5Bstr, ...%5D%5D
+str
 %5D = 

fix mypy