import time

from Modules.Filters.FiltersObj import FiltersObj, DataBaseRange, DataSheetRange, FieldRange, SubFieldRange, data_base
from Modules.Filters.FiltersUtils import FilterUtils
from DBHelper.MongoHelperInstance import DB_TEST


class FilterImpl(object):

    @staticmethod
    def new_filter(**kwargs):
        data = kwargs['data']

        name = DB_TEST.find_single_column(
            '模型数据',
            '筛选器数据',
            {'筛选器名称': data['filter_name']},
            '筛选器名称'
        )
        if name:
            return '筛选器名称已存在'

        filters = FiltersObj()
        filters.filter_id = FilterUtils.make_new_cid()
        filters.filter_name = data['filter_name']
        filters.date = time.strftime("%Y-%m-%d", time.localtime())
        # 处理筛选范围
        filters.filter_range = list()
        for base in data['filter_range']:
            # 数据库名称
            database = DataBaseRange()
            database.value = base['value']
            if len(base['choices']):
                database.choices = list()
                for sheet in base['choices']:
                    # 数据表名称
                    datasheet = DataSheetRange()
                    datasheet.value = sheet['value']
                    if len(sheet['choices']):
                        datasheet.choices = list()
                        for field in sheet['choices']:
                            datafield = FieldRange()
                            datafield.value = field['value']
                            if 'choices' in field and len(field['choices']):
                                datafield.choices = list()
                                for sub in field['choices']:
                                    subfiled = SubFieldRange()
                                    subfiled.value = sub['value']
                                    datafield.choices.append(subfiled)
                            datasheet.choices.append(datafield)
                    database.choices.append(datasheet)
            filters.filter_range.append(database)

        DB_TEST.upsert_single_data(
            '模型数据',
            '筛选器数据',
            {'筛选器名称': data['filter_name']},
            filters.fields_toggle()
        )
        return '新建成功'

    @staticmethod
    def eidt_filter(**kwargs):
        """编辑筛选器"""
        data = kwargs['data']

        case1 = DB_TEST.find_single_column(
            '模型数据',
            '筛选器数据',
            {'筛选器ID': data['filter_id']},
            '筛选器名称'
        )

        case2 = DB_TEST.find_all_data(
            '模型数据',
            '筛选器数据',
            {},
            ['筛选器名称']
        )

        case2 = [item['筛选器名称'] for item in case2]
        case2.remove(case1)

        if data['filter_name'] != case1 and data['filter_name'] in case2:
            return '筛选器名称已存在'

        filters = FiltersObj()
        filters.filter_id = data['filter_id']
        filters.filter_name = data['filter_name']
        filters.date = time.strftime("%Y-%m-%d", time.localtime())
        # 处理筛选范围
        filters.filter_range = list()
        for base in data['filter_range']:
            # 数据库名称
            database = DataBaseRange()
            database.value = base['value']
            if len(base['choices']):
                database.choices = list()
                for sheet in base['choices']:
                    # 数据表名称
                    datasheet = DataSheetRange()
                    datasheet.value = sheet['value']
                    if len(sheet['choices']):
                        datasheet.choices = list()
                        for field in sheet['choices']:
                            datafield = FieldRange()
                            datafield.value = field['value']
                            if 'choices' in field and len(field['choices']):
                                datafield.choices = list()
                                for sub in field['choices']:
                                    subfiled = SubFieldRange()
                                    subfiled.value = sub['value']
                                    datafield.choices.append(subfiled)
                            datasheet.choices.append(datafield)
                    database.choices.append(datasheet)
            filters.filter_range.append(database)

        DB_TEST.update_single_data(
            '模型数据',
            '筛选器数据',
            {'筛选器ID': data['filter_id']},
            filters.fields_toggle()
        )
        return '编辑成功'

    @staticmethod
    def delete_filter(**kwargs):
        """删除筛选器"""
        filter_id = kwargs['filter_id']
        DB_TEST.delete_single_data(
            '模型数据',
            '筛选器数据',
            {'筛选器ID': filter_id}
        )

        return '操作成功'

    @staticmethod
    def search_filter(**kwargs):
        """查询筛选器"""
        filter_name = kwargs['filter_name']
        page_no = kwargs['page_no']
        page_size = kwargs['page_size']

        if len(filter_name):
            total = DB_TEST.find_all_data_with_count(
                '模型数据',
                '筛选器数据',
                {"筛选器名称": filter_name}
            )
            records = DB_TEST.find_data_by_page_with_sort(
                '模型数据',
                '筛选器数据',
                {"筛选器名称": filter_name},
                [],
                {'_id': -1},
                page_size,
                page_no
            )
        else:
            total = DB_TEST.find_all_data_with_count(
                '模型数据',
                '筛选器数据',
                {}
            )
            records = DB_TEST.find_data_by_page_with_sort(
                '模型数据',
                '筛选器数据',
                {},
                [],
                {'_id': -1},
                page_size,
                page_no
            )

        record_list = list()
        for record in records:
            record_dict = dict()
            record_dict['filter_name'] = record['筛选器名称']
            if '筛选器ID' in record:
                record_dict['filter_id'] = record['筛选器ID']
            record_dict['filter_range'] = list()
            for base in record['筛选范围']:
                base_dict = dict()
                base_dict['value'] = base['数据库名称']
                if len(base['选择范围']):
                    base_dict['choices'] = list()
                    for sheet in base['选择范围']:
                        sheet_dict = dict()
                        sheet_dict['value'] = sheet['数据集名称']
                        if '选择范围' in sheet and len(sheet['选择范围']):
                            sheet_dict['choices'] = list()
                            for field in sheet['选择范围']:
                                field_dict = dict()
                                field_dict['value'] = field['字段名称']
                                if '选择范围' in field and len(field['选择范围']):
                                    field_dict['choices'] = list()
                                    for sub in field['选择范围']:
                                        sub_dict = dict()
                                        sub_dict['value'] = sub['子字段名称']
                                        field_dict['choices'].append(sub_dict)
                                sheet_dict['choices'].append(field_dict)
                            base_dict['choices'].append(sheet_dict)
                    record_dict['filter_range'].append(base_dict)
            record_dict['date'] = record['创建日期']
            record_list.append(record_dict)

        result = {
            "total": total,
            "records": record_list
        }

        return result

    @staticmethod
    def search_db_gather(**kwargs):
        """查询数据库所有集合名"""
        db_name = kwargs['db_name']
        if len(db_name):
            records = DB_TEST.find_database_all_gather(db_name)
            return records
        else:
            db_name = None
            records = DB_TEST.find_database_all_gather(db_name)
            return_list = list()
            for record in records:
                if record in data_base:
                    return_list.append(record)

            return return_list

    @staticmethod
    def search_db_field(**kwargs):
        """查询数据集中的所有字段"""
        database = kwargs['database']
        datasheet = kwargs['datasheet']

        records = DB_TEST.find_single_data(
            database,
            datasheet,
            {},
            []
        )

        return_list = list()
        for key, value in records.items():
            if type(value) == dict:
                return_dict = dict()
                return_dict[key] = value
                return_list.append(return_dict)
                continue
            return_list.append(key)
        return return_list