from osgeo.ogr import *
from osgeo import ogr
from osgeo import gdal
import os
import uuid
import shutil
import time
from app.models import *
from app.util.component.PGUtil import PGUtil
from app.util.component.StructuredPrint import StructurePrint
from sqlalchemy.orm import Session
import configure
import copy
class EntryData:

    def entry(self,parameter):
        meta:dict = parameter.get("meta")

        #设置编码
        encoding = parameter.get("encoding")
        if encoding:
            gdal.SetConfigOption("SHAPE_ENCODING",encoding)
        else:
            gdal.SetConfigOption("SHAPE_ENCODING", "GBK")

        #如果包含cpg文件，优先使用cpg文件中声明的编码
        encoding_cpg = meta.get("encoding")
        if encoding_cpg:
            gdal.SetConfigOption("SHAPE_ENCODING", encoding_cpg)


        # 初始化任务
        this_task = ThisTask(parameter)
        data_path = meta.get("data_path")

        try:
            this_task.write_process("入库任务初始化...")

            this_task.update({"process": "入库中"})
            is_success = None
            if not data_path:
                raise Exception("数据错误！")
            # 分为shp和gdb 2种录入形式

            # 开始事务
            this_task.pg_ds.StartTransaction()
            if data_path.endswith("shp"):
                is_success,new_layer_name = self.entry_shp(data_path,this_task)

            if data_path.endswith("gdb"):
                is_success,new_layer_names = self.entry_gdb(data_path,this_task)

            this_task.write_process("数据入库结束。")

            if is_success:
                # 更新任务为成功任务
                this_task.pg_ds.CommitTransaction()
                this_task.update({"state": 1,"process":"入库完成","update_time": datetime.datetime.now()})
            else:
                # 更新任务为失败任务
                this_task.update({"state": -1, "process": "入库失败", "update_time": datetime.datetime.now()})
                # rollback
                this_task.pg_ds.RollbackTransaction()
        except Exception as e:
            this_task.write_process("{} 任务结束！".format(e.__str__()))
            this_task.update({"state": -1, "process": "入库失败", "update_time": datetime.datetime.now()})
            StructurePrint.print(e.__str__(),"ERROR")
            # rollback
            this_task.pg_ds.RollbackTransaction()
        finally:
            this_task.end()
            try:
                file_tmp_path = os.path.join(data_path.split("file_tmp")[0],"file_tmp")
                dir_path = os.path.dirname(data_path)
                i=0
                while not os.path.dirname(dir_path).__eq__(file_tmp_path) and i<30:
                    dir_path = os.path.dirname(dir_path)
                    i+=1
                if i<30:
                    shutil.rmtree(dir_path,True)
                    StructurePrint.print("删除文件成功！")
                else:
                    raise Exception("找不到文件！")

            except Exception as e:
                StructurePrint.print(e.__str__(), "ERROR")
                StructurePrint.print("删除文件失败！","ERROR")

    def entry_shp(self,data_path,this_task):
        '''
        录入shp
        :param data_path:
        :return:
        '''

        driver: Driver = ogr.GetDriverByName("ESRI Shapefile")
        ds: DataSource = driver.Open(data_path, 1)
        if not ds:
            raise Exception("打开数据失败！")
        layer: Layer = ds.GetLayer(0)

        return self.entry_one_layer(layer, this_task)

    def entry_gdb(self,data_path,this_task):
        '''
        录入gdb
        :param data_path:
        :return:
        '''

        is_successes = []
        new_layer_names=[]
        driver: Driver = ogr.GetDriverByName("OpenFileGDB")
        ds: DataSource = driver.Open(data_path, 0)
        if not ds:
            raise Exception("打开数据失败！")


        for i in range(ds.GetLayerCount()):
            layer: Layer = ds.GetLayer(i)
            is_success, new_layer_name = self.entry_one_layer(layer,this_task)
            new_layer_names.append(new_layer_name)
            is_successes.append(is_success)

        if is_successes.__contains__(False):
            return False,new_layer_names
        else:
            return True,new_layer_names

    def entry_one_layer(self,layer: Layer,this_task):

        # this_task.pg_ds.StartTransaction()
        new_layer_name = None


        try:
            # 图层设置
            parameter = this_task.parameter

            meta: dict = parameter.get("meta")
            overwrite = parameter.get("overwrite") if parameter.get("overwrite") is not None and parameter.get("overwrite")=="yes" else "no"
            geom_name = parameter.get("geom_name") if parameter.get("geom_name") is not None else "geom"
            fid =  parameter.get("fid") if parameter.get("fid") is not None else "fid"
            options = ["OVERWRITE={}".format(overwrite), "FID={}".format(fid), "GEOMETRY_NAME={}".format(geom_name),"PRECISION=NO"]



            # # 中文名处理
            # chinese = is_chinese(new_layer_name)
            # if chinese:
            #     new_layer_name = new_layer_name.__hash__()

            # 将线/面转多线多面，dmap只支持多线面
            geom_type = self.change_geom_type(layer.GetGeomType())

            # 更改图层名
            change_name = False
            origin_name = layer.GetName().lower()

            # 新图层名
            new_layer_name: str = meta.get("layer").get(origin_name)
            origin_name = new_layer_name
            no = 1
            while overwrite.__eq__("no") and this_task.pg_ds.GetLayerByName(new_layer_name) :
                change_name=True
                new_layer_name = origin_name+"_{}".format(no)
                no+=1

            if change_name:
                this_task.write_process("{}图层已存在，更名为{}入库".format(origin_name, new_layer_name))


            this_task.write_process("{}图层正在入库...".format(new_layer_name))

            pg_layer: Layer = this_task.pg_ds.CreateLayer(new_layer_name, layer.GetSpatialRef(), geom_type, options)

            # 复制原图层的属性
            # 去掉fid的属性
            schema = [sche for sche in layer.schema if not sche.name.__eq__(fid)]

            pg_layer.CreateFields(schema)

            count =0
            this_time = time.time()
            for feature in layer:
                count+=1
                if count%10000==0:
                    StructurePrint.print("{}图层已入库{}个对象".format(new_layer_name,count))
                    # print(time.time()-this_time)
                    this_time=time.time()
                geo :Geometry = feature.GetGeometryRef()
                # 如果是空对象不录入
                if geo is not None:
                    if geo.IsEmpty():
                        this_task.write_process("FID:{}要素的空间字段为空，跳过该要素！".format(feature.GetFID()))
                        StructurePrint.print("FID:{}要素的空间字段为空，跳过该要素！".format(feature.GetFID()),"WARN")
                        continue
                out_feature: Feature = copy.copy(feature)

                if geo is not None:
                    out_geom:Geometry = self.change_geom(geo, geom_type)
                    out_feature.SetGeometry(out_geom)

                pg_layer.CreateFeature(out_feature)

            # 注册图层信息
            this_task.register_table(pg_layer,new_layer_name,overwrite,parameter.get("creator"))
            this_task.write_process("{}图层入库成功。".format(new_layer_name))
        except Exception as e:
            # this_task.pg_ds.RollbackTransaction()
            this_task.write_process("{}入库失败，数据回滚！原因：{}".format(new_layer_name,e.__str__()))
            StructurePrint.print("{}入库失败，数据回滚！原因：{}".format(new_layer_name,e.__str__()), "error")
            return False,new_layer_name
        # finally:

        return True,new_layer_name

    def entry_feature(self):
        pass


    def change_geom_type(self,raw):
        if raw.__eq__(-2147483646):
            return 5
        if raw.__eq__(-2147483645):
            return 6
        if raw==2 or raw ==3:
            return raw+3
        if raw==4:
            return 1
        return raw

    def get_table_type(self,raw):
        if raw==4 or raw ==5 or raw ==6:
            return raw-3
        return raw

    def change_geom(self,geo:Geometry,geom_type):
        '''
        转换空间对象的类型，以适应dmap只支持Multi类型
        :param geo:
        :param geom_type:
        :return: 转换后的空间对象
        '''


        # Point = 1,
        # LineString = 2,
        # Polygon = 3,
        # MultiPoint = 4,
        # MultiLineString = 5,
        # MultiPolygon = 6,
        # GeometryCollection = 7,
        # CircularString = 8,
        # CompoundCurve = 9,
        # CurvePolygon = 10,
        # MultiCurve = 11,
        # MultiSurface = 12,
        # PolyhedralSurface = 15,
        # LinearRing = 101,

        # MultiPointZ = -2147483644
        # MultiPolygonZ = -2147483643
        # MultiLineStringZ = -2147483642


        # PointZ = -2147483647
        # LINESTRINGZ=-2147483646
        # POLYGONZ=-2147483645

        if geom_type==5 or geom_type.__eq__(-2147483646):
            return ogr.ForceToMultiLineString(geo)
        if geom_type==6 or geom_type.__eq__(-2147483645):
            return ogr.ForceToMultiPolygon(geo)
        if geom_type==1:
            # 多点转单点，会有问题，只拿了第一个点
            xy = geo.GetPoint()
            point = ogr.Geometry(ogr.wkbPoint)
            point.AddPoint(xy[0], xy[1])
            return point
        return geo

    def write_task_process(self,session, task_guid, message):
        '''
        写详细过程
        :param session:
        :param task_guid:
        :param message:
        :return:
        '''

        task_process_guid = uuid.uuid1().__str__()
        task_process = Process(guid=task_process_guid,
                               message=message,
                               time=datetime.datetime.now(),
                               task_guid=task_guid)
        session.add(task_process)


    def data_check(self):
        pass

class ThisTask:

    def __init__(self, parameter):
        try:
            self.sys_session: Session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
        except Exception as e:
            raise Exception("打开数据库失败！")
        self.parameter = parameter

        # # 初始化task
        # task = Task(guid=parameter.get("task_guid"), name=parameter.get("task_name"),create_time=datetime.datetime.now(),state=0)
        # self.sys_session.add(task)
        # self.sys_session.commit()

        self.task = self.sys_session.query(Task).filter_by(guid=parameter.get("task_guid"))

        self.database = self.sys_session.query(Database).filter_by(
            guid=parameter.get("database_guid")).one_or_none()

        self.catalog_guid = parameter.get("catalog_guid")

        self.pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(self.database.sqlalchemy_uri))

        if self.pg_ds is None:
            raise Exception("打开系统数据库失败！")

    def update(self, update_dict):
        self.task.update(update_dict)
        self.sys_session.commit()

    def write_process(self, message):
        message = "{} {}".format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), message)
        task_process_guid = uuid.uuid1().__str__()
        task_process = Process(guid=task_process_guid, message=message, time=datetime.datetime.now(),
                               task_guid=self.parameter.get("task_guid"))
        self.sys_session.add(task_process)
        self.sys_session.commit()

    def register_table(self, layer: Layer, new_layer_name, overwrite, creator):
        '''
        注册表
        :param layer: 图层
        :param new_layer_name: 图层名
        :return: 表名
        '''

        # 在覆盖模式下，删除原有记录
        if overwrite.__eq__("yes"):
            old_table = self.sys_session.query(Table).filter_by(name=new_layer_name).one_or_none()
            if old_table:
                self.sys_session.delete(old_table)
                self.sys_session.commit()

        this_time = datetime.datetime.now()

        ext = layer.GetExtent()
        if ext[0] < 360:
            ext = [round(e, 6) for e in ext]
        else:
            ext = [round(e, 2) for e in ext]

        # extent = "西：{}，东：{}，南：{}，北：{}".format(ext[0],ext[1],ext[2],ext[3])
        extent = "{},{},{},{}".format(ext[0], ext[1], ext[2], ext[3])

        # 其他相同库也更新
        connectstr = self.database.connectstr
        databs = self.sys_session.query(Database).filter_by(connectstr=connectstr).all()
        databs_guid = [d.guid for d in databs]
        for d_guid in databs_guid:
            table_guid = uuid.uuid1().__str__()
            table = Table(guid=table_guid,
                          database_guid=d_guid,
                          # alias=new_layer_name,
                          creator=creator,
                          name=new_layer_name, create_time=this_time, update_time=this_time,
                          catalog_guid=self.catalog_guid, table_type=self.get_table_type(layer.GetGeomType()),
                          extent=extent,
                          feature_count=layer.GetFeatureCount()
                          )
            self.sys_session.add(table)

            feature_defn: FeatureDefn = layer.GetLayerDefn()

            for i in range(feature_defn.GetFieldCount()):
                field_defn: FieldDefn = feature_defn.GetFieldDefn(i)
                field_name = field_defn.GetName().lower()
                field_alias = field_name if field_defn.GetAlternativeName() is None or field_defn.GetAlternativeName().__eq__(
                    "") else field_defn.GetAlternativeName()
                column = Columns(guid=uuid.uuid1().__str__(), table_guid=table_guid,
                                 name=field_name, alias=field_alias, create_time=this_time, update_time=this_time)
                self.sys_session.add(column)

        self.sys_session.commit()

    def end(self):
        if self.sys_session:
            self.sys_session.close()
        if self.pg_ds:
            self.pg_ds.Destroy()

    def get_table_type(self,raw):
        if raw==4 or raw ==5 or raw ==6:
            return raw-3
        return raw