# from . import DataHandler #此时是导入文件
from .DataStream import DataReadStream, day_stamp, open_hdf5
from .DataStream import EChPosmap as pos_map
import numpy as np
import re
from collections import defaultdict
import time as time


__all__ = ['ChannelReader']

import logging

logger = logging.getLogger('reader')


class ChannelReader(DataReadStream):
    def __init__(self):
        file = '/var/www/html/data/stdata/channel.hdf5'
        hfive = open_hdf5(file, False)
        super(ChannelReader, self).__init__(hfive)

    def __del__(self):
        self.close()
        super(ChannelReader, self).__del__()
        pass

    def tuple_path(self, day: int, chnames: set = None, card_types: set = None, spec: int = None):
        def parse(path):
            items = re.split(r'/', path)
            (_prifix, _version, today, chnam, card_type, spec) = items
            return chnam, int(card_type), int(spec)

        tuples = defaultdict(list)
        pathes = self.datasets(day)
        for path in pathes:
            _chnam, _card_type, _spec = parse(path)
            tuples[_chnam].append((_card_type, _spec))

        def name_filter(tuples, chnames):
            all = True if chnames is None or len(chnames) == 0 else False
            if all:
                return tuples
            else:
                result = defaultdict(list)
                for chame, tup in tuples.items():
                    if chame in chnames:
                        result[chame] = tup
                return result

        tuples = name_filter(tuples, chnames)

        def typespec_filter(tuples, card_types, spec):
            result = defaultdict(list)
            for name, ls in tuples.items():
                for tup in ls:
                    _card_type, _spec = tup
                    if _card_type in card_types:
                        if spec is None or _spec == spec:
                            result[name].append((_card_type, _spec))

            return result
        tuples = typespec_filter(tuples,card_types,spec)
        return tuples

    def many_tuple_path(self, days: list, chnames: set = None, card_types: set = None, spec: int = None):
        def merge(l,r):
            for name,ls in l.items():
                if name in r:
                    ls.extend(r[name])
                    r[name] = list(set(ls))
                else:
                    r[name] = ls
            return r

        all = defaultdict(set)
        for day in days:
            tuples = self.tuple_path(day, chnames, card_types, spec)
            all = merge(tuples,all)
        return all

    def init_data(self, days):
        dim = pos_map.dim()
        return np.zeros((dim, 86400 * days))

    def read(self, day_stamp, chname, card_type, spec):
        path = f'/{self._version}/{day_stamp}/{chname}/{card_type}/{spec}'

        hfive = self.file
        if path in hfive:
            return hfive[path]
        else:
            return None
    pass