import sys

from ..preprocessor import Preprocessor
from ..utils import utils
from .config import *


class Split(Preprocessor):
    config: SplitConfig

    def __init__(self, config, data):
        super(Split, self).__init__(config, data)

    def execute(self):
        result = []
        try:
            result = utils.split(self.config.data[0], self.config.delimiter, self.config.serverless)
        except:
            raise Exception("split slowlog failed", sys.exc_info()[1])
        else:
            return result


class Parse(Preprocessor):
    config: ParseConfig

    def __init__(self, config, data):
        super(Parse, self).__init__(config, data)

    def execute(self):
        result = []
        try:
            result = utils.parse_multi(self.config.data[0], self.config.regex)
        except:
            raise Exception("parse slowlog failed", sys.exc_info()[1])
        else:
            return result


class ConvertToDict(Preprocessor):
    config: ConvertToDictConfig

    def __init__(self, config, data):
        super(ConvertToDict, self).__init__(config, data)

    def execute(self):
        result = []
        try:
            result = utils.convert_to_dict_multi(self.config.data[0])
        except:
            raise Exception("convert slowlog to dictionary failed", sys.exc_info()[1])
        else:
            return result


class Mapping(Preprocessor):
    config: MappingConfig

    def __init__(self, config, data):
        super(Mapping, self).__init__(config, data)

    def execute(self):
        result = []
        try:
            result = utils.mapping_multi(self.config.data[0], self.config.columns,
                                         self.config.values)
        except:
            raise Exception("mapping slowlog failed", sys.exc_info()[1])
        else:
            return result


class Merge(Preprocessor):
    config: MergeConfig

    def __init__(self, config, data):
        super(Merge, self).__init__(config, data)

    def execute(self):
        result = []
        try:
            if self.config.Condition is None:
                result = utils.merge_map_multi(self.config.data[0], self.config.data[1])
            else:
                result = utils.merge_map_multi_condition(self.config.data[0], self.config.data[1], self.config.Condition)
        except:
            raise Exception("merge slowlog map failed", sys.exc_info()[1])
        else:
            return result


# class ConvertToTuple(Preprocessor):
#     config: ConvertToTupleConfig
#
#     def __init__(self, config, data):
#         super(ConvertToTuple, self).__init__(config, data)
#
#     def execute(self):
#         result = []
#         try:
#             result = utils.convert_dict_to_tuple_multi(self.config.data[0], self.config.keys)
#             utils.create_sqlite(self.config.db_name, self.config.create_sql,
#                                 self.config.insert_sql, result)
#         except:
#             raise Exception("convert slowlog to tuple failed", sys.exc_info()[1])
#         else:
#             return result


class CreateSqlite(Preprocessor):
    config: CreateSqliteConfig

    def __init__(self, config, data):
        super(CreateSqlite, self).__init__(config, data)

    def execute(self):
        try:
            utils.create_slowlog_sqlite(self.config.data[0], self.config.db_name, self.config.table_name)
        except:
            raise Exception("create slowlog sqlite failed", sys.exc_info()[1])


class CreateCountSqlite(Preprocessor):
    config: CreateCountSqliteConfig

    def __init__(self, config, data):
        super(CreateCountSqlite, self).__init__(config, data)

    def execute(self):
        try:
            utils.create_slowlog_count_sqlite(self.config.data[0], self.config.start_timestamp,
                                              self.config.end_timestamp, self.config.step,
                                              self.config.db_name, self.config.table_name)
        except:
            raise Exception("create slowlog count sqlite failed", sys.exc_info()[1])

class ParseSQL(Preprocessor):
    config: ParseSQLConfig

    def __init__(self, config, data):
        super(ParseSQL, self).__init__(config, data)

    def execute(self):
        try:
            result=utils.parse_sql_multi(self.config.data[0],self.config.key)
        except:
            raise Exception("parse sql failed", sys.exc_info()[1])
        return result

class AnalyzePlan(Preprocessor):
    config: AnalyzePlanConfig

    def __init__(self, config, data):
        super(AnalyzePlan, self).__init__(config, data)

    def execute(self):
        try:
            result=utils.analyze_plan_multi(self.config.data[0],self.config.key)
        except:
            raise Exception("analyze plan failed", sys.exc_info()[1])
        return result

class TraceSQL(Preprocessor):
    config: TraceSQLConfig
    def __init__(self, config, data):
        super(TraceSQL, self).__init__(config, data)

    def execute(self):
        try:
            result=utils.trace_multi(self.config.data[0],self.config.keys,self.config.key_type,self.config.time_key,self.config.cluster_id)
        except:
            raise Exception("trace SQL failed", sys.exc_info()[1])
        return result