# coding=utf-8
#author:        4N
#createtime:    2021/3/24
#email:         nheweijun@sina.com

from app.util import *
import traceback
from osgeo import gdal
from osgeo.gdal import *
from numpy import ndarray
import numpy
from flask import Response
from .util.ImageData import ImageData

import time
import cv2
from app.modules.service.image.models import ImageService,Image
from app.models import db,TileScheme
from app.util.component.ApiTemplate import ApiTemplate
from app.util.component.SliceScheme import SliceScheme
from app.util.component.ParameterUtil import ParameterUtil
import json
from kazoo.client import KazooClient
from threading import Thread
from app.modules.service.image.util.ThriftConnect import ThriftConnect,ThriftPool
import gzip
import random
import copy
from .util.Opencv import Opencv
from .util.Cache import Cache
from .util.MyThread import MyThread

class Api(ApiTemplate):

    api_name = "切片"

    def __init__(self,guid,level, row, col):
        super().__init__()
        self.guid = guid
        self.level = level
        self.row = row
        self.col = col

    def process(self):

        result = {}
        parameter: dict = self.para

        try:
            if parameter.get("guid"):
                self.guid = parameter.get("guid")

            image_service_info, zoo, servers = Cache.cache_data(self.guid)

            # bands = [1, 2, 3]

            # 转换参数
            parameter = ParameterUtil.to_lower(parameter)

            if parameter.get("tilematrix"):
                if parameter.get("tilematrix").__contains__(":"):
                    self.level = int(parameter.get("tilematrix").split(":")[-1])
                else:
                    self.level = int(parameter.get("tilematrix"))
            if parameter.get("tilerow"):
                self.row = int(parameter.get("tilerow"))
            if parameter.get("tilecol"):
                self.col = int(parameter.get("tilecol"))

            image_type = parameter.get("format") if parameter.get("format") else "image/png"
            quality = int(parameter.get("quality")) if parameter.get("quality") else 30
            slice_para = image_service_info["scheme"]
            extent = SliceScheme.get_polygon(slice_para, self.level, self.row, self.col)

            height, width = 256,256


            re = parameter.get("request")
            if re and re.__eq__("GetCapabilities"):
                return self.get_capabilities(image_service_info["service"])

            # 多线程获取分布式数据

            intersect_image = [im for im in image_service_info["images"] if self.determin_intersect(json.loads(im.extent),extent)]

            if len(intersect_image) > 1:

                # 结果矩阵
                pixel_array = numpy.zeros((height, width, 3), dtype=int) + 65536

                thread_list = []

                for image in intersect_image:

                    # 该影像的服务器，随机选取一个
                    image_servers = image.server.split(",")
                    image_servers = [ser for ser in image_servers if ser in servers]
                    if len(image_servers)>0:
                        indx = int(random.random() * len(image_servers))
                        image_server = image_servers[indx]
                    else:
                        image_server = "None"

                    bands = json.loads(image.band_view)

                    image_data = ImageData(image_server,image)

                    thread: MyThread = MyThread(image_data.get_data,args=(extent, bands, height, width))

                    thread.start()
                    thread_list.append(thread)

                for thread in thread_list:
                    thread.join()
                    data = thread.get_result()

                    # 掩膜在中央接口生成,合图
                    mask = numpy.zeros((height, width, 3), dtype=int)
                    mask_data = numpy.zeros((height, width, 3), dtype=int)

                    mask[data == 65536] = 1
                    mask[data != 65536] = 0
                    mask_data[data == 65536] = 0
                    mask_data[data != 65536] = 1

                    # # 掩膜计算
                    pixel_array = pixel_array * mask + data * mask_data

                # opencv 颜色排序为GBR
                d1 = copy.copy(pixel_array[:,:,0])
                pixel_array[:, :, 0] = pixel_array[:,:,2]
                pixel_array[:, :, 2] = d1


            elif len(intersect_image) == 1:
                # 该影像的服务器，随机选取一个
                image = intersect_image[0]
                image_servers = image.server.split(",")
                #判断可用服务器
                image_servers = [ser for ser in image_servers if ser in servers]
                if len(image_servers) > 0:
                    indx = int(random.random() * len(image_servers))
                    image_server = image_servers[indx]
                else:
                    image_server = "None"
                # image_server = image_servers[0]
                bands = json.loads(image.band_view)

                image_data = ImageData(image_server, image)
                pixel_array_t: numpy.ndarray = image_data.get_data(extent, bands, height, width)
                pixel_array = numpy.zeros((height, width, 3), dtype=int)

                for ii in [0, 1, 2]:
                    # opencv 颜色排序为GBR
                    pixel_array[:, :, 2 - ii] = pixel_array_t[:, :, ii]

            else:
                # 结果矩阵
                pixel_array = numpy.zeros((height, width, 3), dtype=int) + 65536


            # 将图片生成在内存中,然后直接返回response
            im_data = Opencv.create_image(image_type, pixel_array, quality)
            return Response(im_data, mimetype=image_type.lower())


        except Exception as e:
            print(traceback.format_exc())
            result["state"] = -1
            result["message"] = e.__str__()
            return result






    def get_capabilities(self):
        return {}



    def determin_intersect(self, extent1, extent2):
        if extent2[2] < extent1[0] or extent2[0] > extent1[2] or extent2[1] > extent1[
            3] or extent2[3] < extent1[1]:
            return False
        else:
            return True


    api_doc = {
        "tags": ["影像接口"],
        "parameters": [
            {"name": "guid",
             "in": "formData",
             "type": "string"},
            {"name": "tilematrix",
             "in": "formData",
             "type": "string"},
            {"name": "tilerow",
             "in": "formData",
             "type": "string"},
            {"name": "tilecol",
             "in": "formData",
             "type": "string"},
            {"name": "format",
             "in": "formData",
             "type": "string"},
            {"name": "quality",
             "in": "formData",
             "type": "string"}

        ],
        "responses": {
            200: {
                "schema": {
                    "properties": {
                    }
                }
            }
        }
    }