##############################################################################
# Copyright (c) 2015 Huawei Technologies Co.,Ltd and others.
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
##############################################################################

from vstf.controller.database.dbinterface import DbManage
import vstf.common.constants as cst


class DataProvider(object):
    def __init__(self, taskid, dbase):
        self._dbase = dbase
        self._taskid = taskid


class CommonData(DataProvider):
    def get_taskname(self):
        return self._dbase.query_taskname(self._taskid)

    def get_systeminfo(self):
        systable = [
            ['Host', 'Server', 'CPU', 'MEM', 'NIC', 'OS'],
        ]
        query = self._dbase.query_task_host_list(self._taskid)
        query = map(lambda x: list(x), query)
        #    rows = len(query)
        #    cols = len(zip(*query))
        #    for i in range(rows):
        #        for j in range(cols):
        #            query[i][j] = query[i][j].replace('\",','\"\n')
        systable += query
        systable = map(lambda x: list(x), zip(*systable))
        return systable

    def get_introduct_tabledata(self):
        result = [
            ["Type", "Case", "Name", "Direction", "Configure"]
        ]
        query = self._dbase.query_caseinfo()
        result += map(lambda x: list(x), query)
        return result

    def get_scenariolist(self):
        query = self._dbase.query_scenariolist(self._taskid)
        result = map(lambda x: list(x), zip(*query))
        if result:
            return result[0]
        else:
            return result

    def is_scenario_start(self):
        scenarioList = self.get_scenariolist()
        print "scenarioList: ", scenarioList
        if scenarioList:
            return True
        return False

    def get_casename(self, case):
        return self._dbase.query_casename(case)

    def get_casefigure(self, case, tools):
        return self._dbase.query_casefigure(case, tools)


class ScenarioData(DataProvider):
    def __init__(self, taskid, dbase, scenario):
        print "ScenarioData in"
        DataProvider.__init__(self, taskid, dbase)
        self._scenario = scenario

    def get_test_tools(self, case):
        query = self._dbase.query_casetools(self._taskid, case)
        result = map(lambda x: list(x), query)
        if result:
            return result[0][0]
        else:
            return result

    def get_caselist(self):
        query = self._dbase.query_caselist(self._taskid, self._scenario)
        result = map(lambda x: list(x), zip(*query))
        if result:
            return result[0]
        else:
            return result

    def get_testlist(self):
        query = self._dbase.query_testlist(self._taskid, self._scenario)
        result = []
        for item in query:
            result.append(item.__dict__)
        return query

    def is_provider_start(self, case, provider):
        count = self._dbase.query_case_provider_count(self._taskid, case, provider)
        if count:
            return True
        return False

    def is_type_provider_start(self, case, provider, ptype):
        count = self._dbase.query_case_type_provider_count(self._taskid, case, provider, ptype)
        if count:
            return True
        return False

    def is_type_start(self, case, ptype):
        count = self._dbase.query_case_type_count(self._taskid, case, ptype)
        if count:
            return True
        return False

    def is_throughput_start(self, case):
        test_type = "throughput"
        return self.is_type_start(case, test_type)

    def is_frameloss_start(self, case):
        test_type = "frameloss"
        return self.is_type_start(case, test_type)

    def is_latency_start(self, case):
        test_type = "latency"
        return self.is_type_start(case, test_type)

    def get_summary_throughput_data(self, case, provider):
        test_type = "throughput"
        return self.get_summary_tabledata(case, provider, test_type)

    def get_summary_frameLoss_data(self, case, provider):
        test_type = "frameloss"
        return self.get_summary_tabledata(case, provider, test_type)

    def get_summary_tabledata(self, case, provider, test_type, table_type='pdf'):
        table_head = []
        table_body = []
        type_title = {
            "frameloss": "Load",
            "throughput": "Load"
        }
        tools = self.get_test_tools(case)
        if "spirent" in tools:
            table_body = self._dbase.query_summary_table(self._taskid, case, provider, test_type)
            if 'pdf' == table_type:
                table_head = [
                    ["FrameSize (byte)", test_type, "", "", "", "Latency(uSec)", "", ""],
                    ["", "    Mpps    ", "   " + type_title[test_type] + " (%)   ", "CPU Used (%)", " Mpps/Ghz ",
                     " Min ", " Max ", " Avg "]
                ]
            else:
                table_head = [
                    ["FrameSize (byte)", "    Mpps    ", "   " + type_title[test_type] + " (%)   ", "CPU Used (%)",
                     " Mpps/Ghz ", "MinLatency(uSec)", "MaxLatency(uSec)", "AvgLatency(uSec)"],
                ]
        else:
            table_body = self._dbase.query_summary_simpletable(self._taskid, case, provider, test_type)
            if 'pdf' == table_type:
                table_head = [
                    ["FrameSize (byte)", test_type, "", "", "", "Latency(uSec)"],
                    ["", "    Mpps    ", "   " + type_title[test_type] + " (%)", "CPU Used (%)", " Mpps/Ghz ",
                     "  Avg  "]
                ]
            else:
                table_head = [
                    ["FrameSize (byte)", "    Mpps    ", "   " + type_title[test_type] + " (%)   ", "CPU Used (%)",
                     " Mpps/Ghz ", "AvgLatency(uSec)"],
                ]
        return table_head + table_body

    def get_ratedata(self, testid, test_type):
        table_head = [
            ["FrameSize (bytes)", "Bandwidth(Mpps)", "Load (%)", "CPU Usage(%)", "Mpps/Ghz", "AvgLatency(uSec)"],
        ]
        query = self._dbase.query_testdata(testid, test_type)
        table_body = []
        for item in query:
            table_body.append([item.AvgFrameSize, item.Bandwidth, item.OfferedLoad, item.CPU, item.MppspGhz,
                               item.AverageLatency])
        result = []
        if table_body:
            result = table_head + table_body
        return result

    def get_tabledata(self, case, test_type, item):
        type_dict = {
            "FrameSize": "FrameSize (byte)",
            "fastlink": "fastlink",
            "l2switch": "l2switch",
            "rdp": "kernel rdp",
            None: "ovs",
            "line": "line speed"
        }
        item_dict = {
            "Percent": "  ",
            "Mpps": "   ",
            "Avg": "   ",
        }
        table = []
        line_speed = 20.0 if case in ["Tn-2v", "Tn-2"] else 10.0

        for provider in cst.PROVIDERS:
            if self.is_provider_start(case, provider):
                if item == 'Percent':
                    query = self._dbase.query_load(self._taskid, case, provider, test_type)
                elif item == 'Mpps':
                    query = self._dbase.query_bandwidth(self._taskid, case, provider, test_type)
                else:
                    query = self._dbase.query_avglatency(self._taskid, case, provider, test_type)
                query = map(lambda x: list(x), zip(*query))
                if query:
                    table_head = [[type_dict["FrameSize"]] + map(lambda x: "  %4d  " % (x), query[0])]
                    if item == "Avg":
                        data = map(lambda x: item_dict[item] + "%.1f" % x + item_dict[item], query[1])
                    else:
                        data = map(lambda x: item_dict[item] + "%.2f" % x + item_dict[item], query[1])
                    if item == "Mpps":
                        line_table = map(lambda x: "%.2f" % (line_speed * 1000 / (8 * (x + 20))), query[0])
                    table.append([type_dict[provider]] + data)
        if table:
            if item == "Mpps":
                table.append([type_dict["line"]] + line_table)
            table = table_head + table
        return table

    def get_frameloss_tabledata(self, case, test_type):
        item = "Percent"
        table = self.get_tabledata(case, test_type, item)
        return table

    def get_frameloss_chartdata(self, case, test_type):
        result = self.get_frameloss_tabledata(case, test_type)
        result = map(list, zip(*result))
        return result

    def get_framerate_tabledata(self, case, test_type):
        item = "Mpps"
        table = self.get_tabledata(case, test_type, item)
        return table

    def get_framerate_chartdata(self, case, test_type):
        result = self.get_framerate_tabledata(case, test_type)
        result = map(list, zip(*result))
        return result

    def get_latency_tabledata(self, case):
        test_type = "latency"
        item = "Avg"
        table = self.get_tabledata(case, test_type, item)
        return table

    def get_latency_chartdata(self, case):
        result = self.get_latency_tabledata(case)
        result = map(list, zip(*result))
        return result

    def get_latency_bardata(self, case):
        table_data = self.get_latency_tabledata(case)
        result = []
        if table_data:
            ytitle = "Average Latency (uSec)"
            category_names = map(lambda x: "FS:%4d" % int(float(x)) + "LOAD:50", table_data[0][1:])
            bar_ = map(lambda x: x[0], table_data[1:])
            data = map(lambda x: x[1:], table_data[1:])
            result = [ytitle, category_names, bar_, data]
        return result

    def get_bardata(self, case, provider, test_type):
        if test_type == "latency":
            query = self._dbase.query_avglatency(self._taskid, case, provider, test_type)
            item = "Avg"
        else:
            query = self._dbase.query_load(self._taskid, case, provider, test_type)
            item = "Percent"

        title_dict = {
            "Avg": "Latency (uSec)",
            "Percent": test_type + " (%)"
        }
        name_dict = {
            "Avg": " LOAD:50",
            "Percent": " OF:100 "
        }
        color_dict = {
            "Avg": "latency",
            "Percent": "loss"
        }
        ytitle = title_dict[item]
        query = map(lambda x: list(x), zip(*query))
        result = []
        if query:
            category_names = map(lambda x: "FS:%4d" % x + name_dict[item], query[0])
            data = query[1:]
            bar_ = [color_dict[item]]
            result = [ytitle, category_names, bar_, data]
        return result


class TaskData(object):
    def __init__(self, taskid, dbase):
        self.__common = CommonData(taskid, dbase)
        scenario_list = self.__common.get_scenariolist()
        scenario_dic = {}
        for scenario in scenario_list:
            scenario_dic[scenario] = ScenarioData(taskid, dbase, scenario)
        self.__dict__.update(scenario_dic)

    @property
    def common(self):
        return self.__common


class HistoryData(DataProvider):
    def get_data(self, task_list, case, provider, ttype, item):
        """
        @provider  in ["fastlink", "rdp", "l2switch", ""]
        @ttype in ["throughput", "frameloss", "latency"]
        @item in ["avg", "ratep", "load"]
        """
        table = []
        table_head = []
        datas = []
        sizes = []
        for taskid in task_list:
            if item == 'ratep':
                query = self._dbase.query_bandwidth(taskid, case, provider, ttype)
            else:
                query = self._dbase.query_avglatency(taskid, case, provider, ttype)

            if query:
                data = {}
                for size, value in query:
                    data[size] = value
                sizes.extend(data.keys())
                sizes = {}.fromkeys(sizes).keys()
                sizes.sort()
                datas.append({taskid: data})

        result = []
        for data in datas:
            print data
            taskid = data.keys()[0]
            data_th = self._dbase.query_taskdate(taskid)
            testdata = data[taskid]
            item = [data_th]
            for size in sizes:
                item.append(str(testdata.get(size, '')))
            result.append(item)

        if result:
            head_th = "FrameSize (byte)"
            table_head = [[head_th] + map(lambda x: "  %4d  " % (x), sizes)]
            table = table_head + result

        return table

    def get_tasklist(self, count=5):
        task_list = []
        query = self._dbase.query_tasklist()
        if query:
            for item in query:
                if item.TaskID <= self._taskid:
                    task_list.append(item.TaskID)

        task_list = task_list[-count:]
        return task_list

    def get_history_info(self, case):
        provider_dict = {"fastlink": "Fast Link ", "l2switch": "L2Switch ", "rdp": "Kernel RDP "}
        ttype_dict = {
            "throughput": "Throughput Testing ",
            "frameloss": "Frame Loss Testing ",
            "latency": "Latency Testing "
        }

        items_dict = {
            "ratep": "RX Frame Rate(Mpps) ",
            "avg": "Average Latency (uSec) "
        }

        task_list = self.get_tasklist()
        result = []

        for ttype in cst.TTYPES:
            content = {}
            if ttype == "latency":
                item = "avg"
            else:
                item = "ratep"

            for provider in cst.PROVIDERS:
                table_data = self.get_data(task_list, case, provider, ttype, item)
                if table_data:
                    data = {
                        "title": provider_dict[provider] + items_dict[item],
                        "data": table_data
                    }
                    content["title"] = ttype_dict[ttype]
                    content.setdefault("data", [])
                    content["data"].append(data)
            if content:
                result.append(content)
        print result
        return result


def unit_test():
    dbase = DbManage()
    taskid = dbase.get_last_taskid()
    hdata = HistoryData(taskid, dbase)
    task_list = hdata.get_tasklist()

    cdata = CommonData(taskid, dbase)
    scenario_list = cdata.get_scenariolist()
    print scenario_list

    scenario = "Tn"
    sdata = ScenarioData(taskid, dbase, scenario)

    case_list = sdata.get_caselist()
    print case_list

    case = "Tn-1"

    ttypes = ["throughput", "frameloss"]
    items = ["ratep", "load"]

    for provider in cst.PROVIDERS:
        for ttype in ttypes:
            for item in items:
                print provider
                print ttype
                print item
                print hdata.get_data(task_list, case, provider, ttype, item)

    hdata.get_history_info(case)


if __name__ == '__main__':
    unit_test()