import json
import time

from DBHelper.MongoHelperInstance import DB_TEST
from Modules.Interface.InterfaceObj import InterfaceObj
from Utils.CommonUtil import CommonUtils
import requests


class InterfaceImpl(object):

    @staticmethod
    def make_new_cid():
        new_cid = CommonUtils.random_code(8)
        case = DB_TEST.find_single_column(
            "模型数据",
            "计算接口",
            {"接口ID": new_cid},
            "接口ID"
        ) is not None
        while case:
            new_cid = CommonUtils.random_code(8)
        return new_cid

    def new_calculate_api(self, **kwargs):
        """新建指标计算接口"""
        data = kwargs['data']
        api = InterfaceObj()
        api.api_id = self.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 = data['tags']
        api.edit_date = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
        api.status = 'normal'

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

        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 json.loads(res.text)
        else:
            return '校验失败'

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

        def make_search_body(param):
            body = dict()
            search_keys = list(param.keys())
            if 'name' in search_keys:
                body['接口名称'] = {"$regex": param['name']}

            if 'tags' in search_keys:
                body['标签'] = {"$in": param['tags']}

            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'] = record['标签']
                return_dict['edit_date'] = 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 = 'lock'

        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'] = record['标签']
            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 == 'lock':
            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 = data['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 '修改成功'