import json
import time

from DBHelper.MongoHelperInstance import DB_TEST
from Modules.Indicators.Tags.TagsImpl import TagsImpl
from Modules.Interface.InterfaceObj import InterfaceObj
from Modules.Interface.InterfaceUtils import InterfaceUtils
import requests


class InterfaceImpl(object):

    @staticmethod
    def new_calculate_api(**kwargs):
        """新建指标计算接口"""
        data = kwargs['data']

        api = InterfaceObj()
        api.api_id = InterfaceUtils.make_new_cid()
        api.api_name = data['api_name']
        api.describe = data['describe']
        api.address = data['address']
        api.params = list()
        for item in data['params']:
            param = api.Param()
            param.name = item['name']
            param.type = item['type']
            param.mark = item['mark']
        api.tags = list()
        for tag in data['tags']:
            tags = api.Tags()
            tags.tag_name = tag['tag_name']
            tags.tag_id = tag['tag_id']
            api.tags.append(tags)
        api.edit_date = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
        api.status = 'design'

        DB_TEST.insert_single_data(
            '模型数据',
            '计算接口',
            api.fields_toggle()
        )

        api_data = api.fields_toggle()
        impl = TagsImpl()
        parameter = {
            "associate_id": api_data['接口ID'],
            "associate_name": api_data['接口名称'],
            "associate_type": "api",
            "tags_id": [item['标签ID'] for item in api_data['标签']]
        }
        impl.associate_tags(data=parameter)

        return '新建成功'

    @staticmethod
    def check_calculate_api(**kwargs):
        """校验计算函数"""
        address = kwargs['data']['address']
        params = kwargs['data']['params']

        param_dict = dict()
        for param in params:
            param_dict[param['name']] = param['input']

        res = requests.get(url=address, params=param_dict)
        if res.status_code == 200:
            return float(res.text)
        else:
            return '调用接口失败'

    @staticmethod
    def search_calculate_api(**kwargs):
        """查询指标接口"""

        def make_search_body(param):
            body = dict()
            if len(param['name']):
                body['接口名称'] = {"$regex": param['name']}

            if len(param['tags']):
                tags_list = list()
                for tags in param['tags']:
                    tags_dict = dict()
                    tags_dict['标签名称'] = tags['tag_name']
                    tags_dict['标签ID'] = tags['tag_id']
                    tags_list.append(tags_dict)
                body['标签'] = {"$in": tags_list}

            if len(param['status']):
                body['状态'] = 'published' if param['status'] == '已发布' else 'design'

            return body

        def make_sort_body(param):
            if param == 'asc':
                body = {"编辑时间": 1}
            else:
                body = {"编辑时间": -1}

            return body

        data = kwargs['data']
        sort = data['sort']
        page_size = int(data['page_size'])
        page_no = int(data['page_no'])
        search_body = make_search_body(data)
        sort_body = make_sort_body(sort)
        page_size = 10 if page_size > 10 else page_size

        total = DB_TEST.find_all_data_with_count(
            '模型数据',
            '计算接口',
            search_body
        )

        records = DB_TEST.find_data_by_page_with_sort(
            '模型数据',
            '计算接口',
            search_body,
            ['接口ID', '接口名称', '说明', '标签', '编辑时间', '状态'],
            sort_body,
            page_size,
            page_no
        )

        return_list = list()
        if records:
            for record in records:
                return_dict = dict()
                return_dict['api_id'] = record['接口ID']
                return_dict['api_name'] = record['接口名称']
                return_dict['describe'] = record['说明']
                return_dict['tags'] = list()
                for tag in record['标签']:
                    tag_dict = dict()
                    tag_dict['tag_name'] = tag['标签名称']
                    tag_dict['tag_id'] = tag['标签ID']
                    return_dict['tags'].append(tag_dict)
                return_dict['edit_date'] = record['编辑时间']
                return_dict['status'] = record['状态']
                return_list.append(return_dict)

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

        return result

    @staticmethod
    def lock_calculate_api(**kwargs):
        """锁定接口"""
        aid = kwargs['aid']
        api = InterfaceObj()
        api.status = 'published'

        DB_TEST.update_single_data(
            '模型数据',
            '计算接口',
            {'接口ID': aid},
            api.fields_toggle()
        )
        return '锁定成功'

    @staticmethod
    def view_calculate_api(**kwargs):
        aid = kwargs['aid']
        record = DB_TEST.find_single_data(
            '模型数据',
            '计算接口',
            {'接口ID': aid},
            ['接口名称', '说明', '地址', '参数', '标签', '状态']
        )

        return_dict = dict()
        if record:
            return_dict['api_name'] = record['接口名称']
            return_dict['describe'] = record['说明']
            return_dict['address'] = record['地址']
            return_dict['params'] = list()
            if record['参数']:
                for item in record['参数']:
                    param_dict = dict()
                    param_dict['name'] = item['参数名']
                    param_dict['mark'] = item['备注']
                    try:
                        param_dict['type'] = item['类型']
                    except KeyError:
                        pass
                    return_dict['params'].append(param_dict)
            return_dict['tags'] = list()
            for tag in record['标签']:
                tag_dict = dict()
                tag_dict['tag_name'] = tag['标签名称']
                tag_dict['tag_id'] = tag['标签ID']
                return_dict['tags'].append(tag_dict)
            return_dict['status'] = record['状态']

        return return_dict

    @staticmethod
    def edit_calculate_api(**kwargs):
        data = kwargs['data']
        aid = data['api_id']

        status = DB_TEST.find_single_column(
            '模型数据',
            '计算接口',
            {'接口ID': aid},
            '状态'
        )
        if status == 'published':
            return '函数已锁定'

        api = InterfaceObj()
        api.api_name = data['api_name']
        api.describe = data['describe']
        api.address = data['address']
        api.params = list()
        for params in data['params']:
            param = api.Param()
            param.name = params['name']
            param.type = params['type']
            param.mark = params['mark']
            api.params.append(param)
        api.tags = list()
        for tag in data['tags']:
            tags = api.Tags()
            tags.tag_name = tag['tag_name']
            tags.tag_id = tag['tag_id']
            api.tags.append(tags)
        api.edit_date = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())

        update_data = api.fields_toggle()

        DB_TEST.update_single_data(
            '模型数据',
            '计算接口',
            {'接口ID': aid},
            update_data
        )
        return '修改成功'

    @staticmethod
    def delete_calculate_api(**kwargs):
        """删除接口"""
        aid = kwargs['aid']

        tags = DB_TEST.find_single_column(
            '模型数据',
            '计算接口',
            {'接口ID': aid},
            '标签'
        )
        # 删除标签关联的接口
        for tag in tags:
            DB_TEST.delete_single_data_in_array(
                '模型数据',
                '标签数据',
                {'标签ID': tag['标签ID']},
                {"关联数据": {"接口ID": aid}}
            )
        # 删除函数
        DB_TEST.delete_single_data(
            '模型数据',
            '计算接口',
            {'接口ID': aid}
        )

        return '操作成功'