from telemetry import *
import copy


class data:
    def __init__(self, d):
        self.__dict__ = d

    def get_raw_data(self):
        obj = copy.deepcopy(self)
        rawData = obj2dict(obj, data)
        return rawData

    def get_timestamp(self):
        return self.ts

    def get_host(self):
        return self.host

    def get_ip(self):
        return self.ip

    def get_app(self):
        return self.app

    def get_hardware(self):
        try:
            self.content.hardware
            hardwares = self.content.hardware
            for i in range(len(hardwares)):
                hardwares[i] = util.obj2dict(hardwares[i], data)
            return hardwares
        except AttributeError:
            return None

    def get_host_extra(self):
        try:
            self.content.hostExtra
            return util.obj2dict(self.content.hostExtra, data)
        except AttributeError:
            try:
                self.content.telemetry_host_extra
                return util.obj2dict(self.content.telemetry_host_extra, data)
            except AttributeError:
                return None

    def get_instances(self):
        try:
            self.content.instances
            return util.obj2dict(self.content.instances, data)
        except AttributeError:
            return None

    def get_feature_usage(self):
        try:
            self.content.featureUsage
            return util.obj2dict(self.content.featureUsage, data)
        except AttributeError:
            return None

    def get_cluster_index(self):
        try:
            self.content.featureUsage.clusterIndex
            cluster_index = util.obj2dict(self.content.featureUsage.clusterIndex, data)
            return cluster_index
        except AttributeError:
            return None

    def get_cluster_index_usage(self):
        items = self.get_cluster_index()
        if not items:
            return None
        cluster_index_usage_list = []
        for item_key in iter(items):
            if isinstance(items[item_key], dict):
                cluster_index_usage_list.append(
                    {item_key: items[item_key]["isClustered"]}
                )
            else:
                cluster_index_usage_list.append({item_key: items[item_key]})
        return cluster_index_usage_list

    def get_cluster_index_pk(self):
        items = self.get_cluster_index()
        if not items:
            return None
        cluster_index_pk_list = []
        for item_key in iter(items):
            if isinstance(items[item_key], dict):
                cluster_index_pk_list.append({item_key: items[item_key]["clusterPKType"]})
            else:
                cluster_index_pk_list.append({item_key: "Unknown"})
        return cluster_index_pk_list

    def get_cluster_index_cnt(self):
        cluster_index_usage_list = self.get_cluster_index_usage()
        if not cluster_index_usage_list:
            return None
        return len(cluster_index_usage_list)

    def get_cluster_index_true_cnt(self):
        cluster_index_true_cnt = 0
        cluster_index_usage_list = self.get_cluster_index_usage()
        if not cluster_index_usage_list:
            return None
        for item in cluster_index_usage_list:
            for k in iter(item):
                cluster_index_true_cnt += item[k] == True
        return cluster_index_true_cnt

    def get_cluster_index_false_cnt(self):
        cluster_index_false_cnt = 0
        cluster_index_usage_list = self.get_cluster_index_usage()
        if not cluster_index_usage_list:
            return None
        for item in cluster_index_usage_list:
            for k in iter(item):
                cluster_index_false_cnt += item[k] != True
        return cluster_index_false_cnt

    def get_async_commit_used(self):
        try:
            self.content.featureUsage.txn.asyncCommitUsed
        except AttributeError:
            return None
        else:
            util.type_check(self.content.featureUsage.txn.asyncCommitUsed, bool)
            return self.content.featureUsage.txn.asyncCommitUsed

    def get_onePC_used(self):
        try:
            self.content.featureUsage.txn.onePCUsed
        except AttributeError:
            return None
        else:
            util.type_check(self.content.featureUsage.txn.onePCUsed, bool)
            return self.content.featureUsage.txn.onePCUsed

    def get_txn_commit_counter(self):
        try:
            self.content.featureUsage.txn.txnCommitCounter
            txn_commit_counter = util.obj2dict(
                self.content.featureUsage.txn.txnCommitCounter, data
            )
            return txn_commit_counter
        except AttributeError:
            return None

    def get_async_commit_cnt(self):
        txn_commit_counter = self.get_txn_commit_counter()
        if txn_commit_counter:
            util.type_check(txn_commit_counter["asyncCommit"], int)
            return txn_commit_counter["asyncCommit"]
        else:
            return None

    def get_onePC_cnt(self):
        txn_commit_counter = self.get_txn_commit_counter()
        if txn_commit_counter:
            util.type_check(txn_commit_counter["onePC"], int)
            return txn_commit_counter["onePC"]
        else:
            return None

    def get_twoPC_cnt(self):
        txn_commit_counter = self.get_txn_commit_counter()
        if txn_commit_counter:
            util.type_check(txn_commit_counter["twoPC"], int)
            return txn_commit_counter["twoPC"]
        else:
            return None

    def get_slow_query_stats(self):
        try:
            self.content.slowQueryStats
            slow_query_stats = util.obj2dict(self.content.slowQueryStats, data)
            # if slow_query_stats == None:
            #     slow_query_stats = None
            return slow_query_stats
        except AttributeError:
            return None

    def get_report_timestamp(self):
        try:
            self.content.reportTimestamp
            return self.content.reportTimestamp
        except AttributeError:
            try:
                self.content.report_timestamp
                return self.content.report_timestamp
            except AttributeError:
                print("no reportTimeStamp !!!")
                return None

    def get_tracking_id(self):
        try:
            self.content.trackingId
            return self.content.trackingId
        except AttributeError:
            try:
                self.content.tracking_id
                return self.content.tracking_id
            except AttributeError:
                print("no id !!!")
                return None

    def get_windowed_stats(self):
        try:
            self.content.windowedStats
            windowed_stats = self.content.windowedStats
            windowed_stats = util.obj2dict(windowed_stats, data)
            return windowed_stats
        except AttributeError:
            return None

    def get_copr_cache_usage_list(self):
        windowed_stats = self.get_windowed_stats()
        if not windowed_stats:
            return None
        coprCacheUsage = []
        for window_item in windowed_stats:
            coprCacheUsage.append(window_item["coprCacheUsage"])
        return coprCacheUsage

    def get_copr_cache_usage(self):
        copr_cache_usage_list = self.get_copr_cache_usage_list()
        if not copr_cache_usage_list:
            return None
        copr_cache_usage = {
            "gte0": 0,
            "gte1": 0,
            "gte10": 0,
            "gte100": 0,
            "gte20": 0,
            "gte40": 0,
            "gte80": 0,
        }

        for item in copr_cache_usage_list:
            for k in iter(item):
                copr_cache_usage[k] += item[k]
        return copr_cache_usage

    def get_execute_count(self):
        windowed_stats = self.get_windowed_stats()
        if not windowed_stats:
            return None
        execute_count = []
        for window_item in windowed_stats:
            execute_count.append(window_item["executeCount"])
        return execute_count

    def get_execute_count_sum(self):
        execute_count = self.get_execute_count()
        if not execute_count:
            return None
        return sum(execute_count)

    def get_exchange_pushdown_list(self):
        windowed_stats = self.get_windowed_stats()
        if not windowed_stats:
            return None
        exchange_push_down = []
        for window_item in windowed_stats:
            exchange_push_down.append(window_item["tiFlashUsage"]["exchangePushDown"])
        return exchange_push_down

    def get_tiflash_exchange_pushdown(self):
        exchange_push_down = self.get_exchange_pushdown_list()
        if not exchange_push_down:
            return None
        util.type_check(exchange_push_down[0], int)
        exchange_push_down_cnt = 0
        for exchangePushDown_item in exchange_push_down:
            exchange_push_down_cnt += exchangePushDown_item
        return exchange_push_down_cnt
        # try:
        #     TiFlashExchangePushDown = exchangePushDown[-1]
        #     if TiFlashExchangePushDown > 0:
        #         return 1
        #     else:
        #         return 0
        # except IndexError:
        #     return -1

    def get_pushdown_list(self):
        windowed_stats = self.get_windowed_stats()
        if not windowed_stats:
            return None
        pushDown = []
        for window_item in windowed_stats:
            pushDown.append(window_item["tiFlashUsage"]["pushDown"])
        return pushDown

    def get_tiflash_pushdown(self):
        push_down = self.get_pushdown_list()
        if not push_down:
            return None
        util.type_check(push_down[0], int)
        push_down_cnt = 0
        for PushDown_item in push_down:
            push_down_cnt += PushDown_item
            # TiFlashPushDown = PushDown[-1]
        return push_down_cnt
        # if pushDownCnt > 0:
        #     return 1
        # else:
        #     return 0

    def get_sql_usage(self):
        windowed_stats = self.get_windowed_stats()
        if not windowed_stats:
            return None
        sql_usage = []
        for window_item in windowed_stats:
            try:
                sql_usage.append(window_item["SQLUsage"])
            except KeyError:
                return None
        return sql_usage

    def get_sql_usage_total(self):
        sql_usage_list = self.get_sql_usage()
        if not sql_usage_list:
            return None
        sql_usage_total = 0
        for sql_item in sql_usage_list:
            sql_usage_total += sql_item['total']
        return sql_usage_total