import re
from io import BytesIO
from ZeroCodeMain.settings import BASE_DIR
from django.http import JsonResponse
from rest_framework import status
from users.models import Permissions
from users.serializers import PermissionsSerializer
from django.db.models import Q
from rest_framework.response import Response
from rest_framework.views import APIView
import requests
import os
from ZeroCodeMain.settings import BASE_DIR
from depend_main.functions.abstractFactoryFunction import create_class, create_class_from_db
from BaseApi.models import *
from dependency.base.utils import *
from .permission import NormalPermissionCheck

config_file_path = os.path.join(BASE_DIR, 'dependency', 'api_config', 'project_info.json')
with open(config_file_path, "r") as config_file:
    config = json.load(config_file)

# 运行前检查
# 检测并确认所有数据库中的model都已经注册并且创建
# TODO 队列检查初始化，若已经存在剔除队列
try:
    instance = Model.objects.all()
    for item in instance:
        model_instance = item.get_django_model()
except Exception as e:
    print(e)


# Create your views here.
class GetAllModelList(APIView):

    def get(self, request):
        instance_in = Model.objects.all()
        get_serializers = build_serializers(Model.__name__, Model, {}, False)
        datas = get_serializers(instance_in, many=True).data
        return Response({
            "datas": datas,
        })


class GetModelDetail(APIView):
    def get(self, request):
        instance_in = ModelField.objects.filter(model_id=request.GET["id"])
        get_serializers = build_serializers(ModelField.__name__, ModelField, {}, False)
        datas = get_serializers(instance_in, many=True).data
        return Response({
            "datas": datas,
        })

    def post(self, request):
        for add_item in request.data:
            if "id" not in add_item:
                add_item["model"] = Model.objects.get(pk=add_item["model"])
                ModelField.objects.create(**add_item)
            else:
                add_item["model"] = add_item["model"]["id"]
                ins = ModelField.objects.get(pk=add_item["id"])
                get_serializers = build_serializers(ModelField.__name__, ModelField, {}, False)
                serializers = get_serializers(ins, data=add_item, partial=True)
                if serializers.is_valid():
                    serializers.save()
        return Response({"msg": "success"})


class GetModelSettingList(APIView):
    def get(self, request):
        settings_list = []
        instance_in = ModelField.objects.filter(model_id=request.GET["id"])
        get_serializers = build_serializers(ModelField.__name__, ModelField, {}, False)
        datas = get_serializers(instance_in, many=True).data
        for items in datas:
            settings_item = ModelSetting.objects.filter(field_id=items["id"])
            settings_serializers = build_serializers(ModelSetting.__name__, ModelSetting, {}, False)
            settings_datas = settings_serializers(settings_item, many=True).data
            settings_list.extend(settings_datas)
        return Response({"datas": settings_list})

    def post(self, request):
        model_id = None
        for add_item in request.data:
            if "id" not in add_item:
                add_item["field"] = ModelField.objects.get(pk=add_item["field"]["id"])
                created_instance = ModelSetting.objects.create(**add_item)
                model_id = ModelField.objects.filter(pk=created_instance.field_id).first().model_id
            else:
                model_id = ModelField.objects.filter(pk=add_item["field"]["id"]).first().model_id
                add_item["field"] = add_item["field"]["id"]
                ins = ModelSetting.objects.get(pk=add_item["id"])
                get_serializers = build_serializers(ModelSetting.__name__, ModelSetting, {}, False)
                serializers = get_serializers(ins, data=add_item, partial=True)
                if serializers.is_valid():
                    serializers.save()
        if model_id is None:
            return Response({"msg": "没有获取到model_id"})
        else:
            Model.objects.get(pk=model_id).get_django_model()
        return Response({"msg": "success"})


class CreateModel(APIView):
    def post(self, request):
        model_ins = Model.objects.create(**request.data)
        model_ins.get_django_model()
        return Response({
            "msg": "success",
            "model": request.data
        })


class GetAppList(APIView):
    def get(self, request):
        data_ins = App.objects.all()
        get_serializers = build_serializers(App.__name__, App, {}, False)
        serializers = get_serializers(data_ins, many=True).data
        return Response({
            "msg": "success",
            "data": serializers
        })


class UseAPI(APIView):
    # permission_classes = [NormalPermissionCheck]

    def post(self, request):
        # TODO 提取数据库部分进入依赖类、加入元数据元对象，元数据元对象逻辑优化
        instance_in = Model.objects.all()
        get_serializers = build_serializers(Model.__name__, Model, {}, False)
        datas = get_serializers(instance_in, many=True).data
        # get api信息
        model_instance = get_model(request.data['model'])
        model_instance_info = get_model_status(request.data['model'])
        get_serializers = build_serializers(model_instance._meta.model_name, model_instance, {}, False)
        self.check_object_permissions(self.request, model_instance_info)
        data = get_serializers(model_instance.objects.get(api_name_en=request.data['api_name'])).data
        with open(os.path.join(BASE_DIR, "api_django.json")) as f:
            port = json.load(f)["port"]
        # 请求api
        if request.content_type.startswith('multipart/form-data'):
            zip_file = request.FILES['zip']
            files = {
                'zip': (zip_file.name, zip_file, 'application/zip')  # 关键修正！
            }
            post_data = {
                "api_info": json.dumps(data),
            }
            del request.data["model"]
            del request.data["zip"]
            for k, v in request.data.items():
                post_data[k] = v
            res = requests.post(f'http://127.0.0.1:{port}/ApiClass/base_api_control/api_url/', files=files,
                                data=post_data)
        else:
            headers = {'Content-Type': 'application/json'}
            post_data = {
                "api_info": data,
                "process_data": request.data["process_data"],
            }
            post_data = json.dumps(post_data)
            res = requests.post(f'http://127.0.0.1:{port}/ApiClass/base_api_control/api_url/', data=post_data,
                                headers=headers)
        """
        对于api返回的信息做出以下规定：
        1、键 data -- 直接显示返回
        2、键 add_data -- 传入对应的model内中进行添加或者修改
        3、键 search_data -- 查询对应的表
        """

        return_data = copy.deepcopy(res.json())
        if 'add_data' in return_data:
            # 添加结束后删除
            for add_item in return_data['add_data']:
                if add_item['model'] == "permission":
                    for add_p in add_item['data']:
                        serializer = PermissionsSerializer(data=add_p)
                        if serializer.is_valid(raise_exception=True):
                            serializer.save()
                else:
                    reverse_add_sub_data(add_item["data"], sub_model_instance=get_model(add_item['model']))
            del return_data['add_data']
        return Response(return_data)


class RelatedRecord(APIView):
    def post(self, request):
        model_name = request.data["model"]["name"]
        ser = []
        for items in get_model(model_name)._meta.get_fields():
            if items.name == request.data["name"]:
                model_ins = items.remote_field.model
                target_data = model_ins.objects.all()
                serializers_re = build_serializers(model_ins._meta.model_name,
                                                   model_ins, {},
                                                   False)
                ser = serializers_re(target_data, many=True).data
        return Response({"msg": "success", "data": ser})


class RecordOperate(APIView):
    def get(self, request):
        return_data = {}
        active_related = False
        return_data_columns = []
        for search_item in request.GET.getlist('search_data[]'):
            if "related" in json.loads(search_item)["Q"]:
                active_related = True
            search_item_model_instance = get_model(json.loads(search_item)['model'])
            search_item_get_serializers = build_serializers(search_item_model_instance._meta.model_name,
                                                            search_item_model_instance, {},
                                                            active_related)
            return_data_columns = get_model_fields(json.loads(search_item)['model'])
            if json.loads(search_item)["Q"] == {}:
                target_data = search_item_model_instance.objects.all()
                datas = search_item_get_serializers(target_data, many=True).data
                return_data = datas
            else:
                filter_data = copy.deepcopy(json.loads(search_item)["Q"])
                if filter_data["Q_obj"] != "":
                    filter_data["Q_obj"] = eval(filter_data["Q_obj"])
                else:
                    del filter_data["Q_obj"]
                if 'id' in filter_data:
                    target_data = search_item_model_instance.objects.get(id=filter_data["id"])
                    datas = search_item_get_serializers(target_data).data
                elif 'uuid' in filter_data:
                    target_data = search_item_model_instance.objects.get(uuid=filter_data["uuid"])
                    datas = search_item_get_serializers(target_data).data
                else:
                    target_data = search_item_model_instance.objects.filter(**filter_data)
                    datas = search_item_get_serializers(target_data, many=True).data
                return_data = datas
        return Response({"msg": "success", "data": {
            "return_data": return_data,
            "return_data_columns": return_data_columns
        }})

    def post(self, request):
        reverse_add_sub_data(request.data['add_data'])
        return Response({"msg": "success", "data": {}})

    def put(self, request):
        pass

    def delete(self, request):
        search_item_model_instance = get_model(request.data['model'])
        filter_data = copy.deepcopy(request.data['Q'])
        if 'id' in filter_data:
            search_item_model_instance.objects.get(id=filter_data["id"]).delete()
        elif 'uuid' in filter_data:
            search_item_model_instance.objects.get(uuid=filter_data["uuid"]).delete()
        return Response({"msg": "success", "data": "删除成功"})


blacklist_ips = {

}


class Blacklist(APIView):
    def get(self, request):
        # SQL 注入检测规则

        # 放行请求
        response = JsonResponse({"status": "allowed"})
        response['apache-status'] = 'allowed'
        return response