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


import numpy
from app.util.component.ParameterUtil import ParameterUtil
from .Cache import Cache
from app.modules.service.models import ImageService
from flask import Response
from .ImageData import ImageData
from .MyThread import MyThread
from .Opencv import Opencv
from app.modules.service.models import Service,TileScheme
import json
import random
import copy
import configure
from app.util.component.SliceScheme import SliceScheme
from app.util.component.ModelVisitor import ModelVisitor
import threading
from .ImageServer import ImageServer

class ImageWMTSServer(ImageServer):
    _instance_lock = threading.Lock()
    singleton = None

    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        if not cls.singleton:
            with ImageWMTSServer._instance_lock:
                cls.singleton = super().__new__(cls)
        return cls.singleton


    def wmts(self,service_name,parameter,type="name"):

        image_service_info, zoo, servers = Cache.cache_data(service_name, type=type)

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

        re = parameter.get("request")
        if re and re.__eq__("GetCapabilities"):
            service = Service.query.filter_by(guid=image_service_info["service"].get("service_guid")).one_or_none()
            return self.get_wmts_capabilities(image_service_info["service"], service)

        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

        # 多线程获取分布式数据

        intersect_image = [im for im in image_service_info["images"] if
                           self.determin_intersect(json.loads(im.get("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.get("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.get("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.get("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.get("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())


    def get_wmts_capabilities(self, image_service, service: Service):
        tile_scheme: TileScheme = TileScheme.query.filter_by(guid=image_service.get("scheme_guid")).one_or_none()
        if not tile_scheme:
            raise Exception("切片方案不存在！")
        tile_scheme = ModelVisitor.object_to_json(tile_scheme)

        xml = '''<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gml="http://www.opengis.net/gml" xsi:schemaLocation="http://www.opengis.net/wmts/1.0 http://schemas.opengis.net/wmts/1.0/wmtsGetCapabilities_response.xsd" version="1.0.0">
             <!--  Service Identification  -->
             <ows:ServiceIdentification>
             <ows:Title>{title}</ows:Title>
             <ows:ServiceType>OGC WMTS</ows:ServiceType>
             <ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
             </ows:ServiceIdentification>

             <!--  Operations Metadata  -->
             <ows:OperationsMetadata>
             <ows:Operation name="GetCapabilities">
             <ows:DCP>
             <ows:HTTP>
             <ows:Get xlink:href="{capabilities_url}">
             <ows:Constraint name="GetEncoding">
             <ows:AllowedValues>
             <ows:Value>RESTful</ows:Value>
             </ows:AllowedValues>
             </ows:Constraint>
             </ows:Get>

             <!--  add KVP binding in 10.1  -->
             <ows:Get xlink:href="{tile_url}?">
             <ows:Constraint name="GetEncoding">
             <ows:AllowedValues>
             <ows:Value>KVP</ows:Value>
             </ows:AllowedValues>
             </ows:Constraint>
             </ows:Get>
             </ows:HTTP>
             </ows:DCP>
             </ows:Operation>
             <ows:Operation name="GetTile">
             <ows:DCP>
             <ows:HTTP>
             <ows:Get xlink:href="{tile_url}">
             <ows:Constraint name="GetEncoding">
             <ows:AllowedValues>
             <ows:Value>RESTful</ows:Value>
             </ows:AllowedValues>
             </ows:Constraint>
             </ows:Get>
             <ows:Get xlink:href="{tile_url}?">
             <ows:Constraint name="GetEncoding">
             <ows:AllowedValues>
             <ows:Value>KVP</ows:Value>
             </ows:AllowedValues>
             </ows:Constraint>
             </ows:Get>
             </ows:HTTP>
             </ows:DCP>
             </ows:Operation>
             </ows:OperationsMetadata>

             <Contents>

             <!-- Layer -->


             <Layer>
             <ows:Title>{title}</ows:Title>
             <ows:Identifier>{title}</ows:Identifier>
             <ows:BoundingBox crs="{crs}">
             <ows:LowerCorner>{xmin} {ymin}</ows:LowerCorner>
             <ows:UpperCorner>{xmax} {ymax}</ows:UpperCorner>
             </ows:BoundingBox>

             <Style isDefault="true">
             <ows:Title>Default Style</ows:Title>
             <ows:Identifier>default</ows:Identifier>
             </Style>
             <Format>image/png</Format>
             <TileMatrixSetLink>
             <TileMatrixSet>{tile_name}</TileMatrixSet>
             </TileMatrixSetLink>

             <ResourceURL format="image/png" resourceType="tile" template="{tile_url}"/>

             </Layer>

             <!-- TileMatrixSet -->


             <TileMatrixSet>

             <TileMatrix>
             <ows:Title>{tile_title}</ows:Title>
             <ows:Abstract>{tile_description}</ows:Abstract>
             <ows:Identifier>{tile_name}</ows:Identifier>
             <ows:SupportedCRS>{crs}</ows:SupportedCRS>

             {tile_matrix}

             </TileMatrix>

             </TileMatrixSet>


             </Contents>
             <ServiceMetadataURL xlink:href="{capabilities_url}"/>
             </Capabilities>'''

        tile_matrix_each = '''
             <TileMatrix>
             <ows:Identifier>{lev}</ows:Identifier>
             <ScaleDenominator>{scale}</ScaleDenominator>
             <TopLeftCorner>{top_left}</TopLeftCorner>
             <TileWidth>{cols}</TileWidth>
             <TileHeight>{rows}</TileHeight>
             </TileMatrix>
        '''

        tile_matrix = ""
        top_left = tile_scheme.get("top_left")
        for level in json.loads(tile_scheme.get("levels")):
            tile_matrix = "{}{}".format(tile_matrix, tile_matrix_each.format(lev=level["level"],
                                                                             scale=level["scale"],
                                                                             top_left=top_left,
                                                                             cols=tile_scheme.get("cols"),
                                                                             rows=tile_scheme.get("rows")))

        extent = json.loads(image_service.get("extent"))

        xml = xml.format(
            capabilities_url="http://{}/API/Service/Image/Capabilities?guid={}".format(configure.deploy_ip_host,
                                                                                       image_service.get("guid")),
            tile_url="http://{}/API/Service/Image/Tile?guid={}".format(configure.deploy_ip_host, image_service.get("guid")),
            crs=tile_scheme.get("crs"),
            xmin=extent[0],
            ymin=extent[1],
            xmax=extent[2],
            ymax=extent[3],
            # TileMatrix = "{TileMatrix}",
            # TileRow = "{TileRow}",
            # TileCol = "{TileCol}",
            guid=image_service.get("guid"),
            title=service.title,
            tile_title=tile_scheme.get("name"),
            tile_name=tile_scheme.get("name"),
            tile_description=tile_scheme.get("description"),
            tile_matrix=tile_matrix
            )

        r = Response(response=xml, status=200, mimetype="application/xml")
        r.headers["Content-Type"] = "text/xml; charset=utf-8"

        return r



    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