# author:        4N
# createtime:    2021/1/27
# email:         nheweijun@sina.com


import datetime
import traceback
from app.models import Table, Database, DES,Task,db,TableVacuate

from sqlalchemy.engine import ResultProxy
from app.util.component.ApiTemplate import ApiTemplate
from app.util.component.PGUtil import PGUtil
from app.util.component.EntryDataVacuate import VacuateProcess,ThisTask,Process
from app.util.component.StructuredPrint import StructurePrint
from app.util.component.PGUtil import PGUtil
import multiprocessing
import uuid
import configure
from osgeo.ogr import DataSource,Layer

from .table_vacuate_ref import Api as RefApi

class Api(ApiTemplate):
    api_name = "数据抽稀"
    def process(self):

        res = {}
        res["data"] = {}
        db_session = None
        try:
            table_guid = self.para.get("guid")
            table: Table = Table.query.filter_by(guid=table_guid).one_or_none()

            if not table:
                raise Exception("数据不存在！")

            pg_ds :DataSource= PGUtil.open_pg_data_source(0,DES.decode(table.relate_database.sqlalchemy_uri))
            layer = pg_ds.GetLayerByName(table.name)
            # 判断图层是否存在
            if not layer:
                raise Exception("图层不存在！")

            # 判断用户权限
            db_tuple = PGUtil.get_info_from_sqlachemy_uri(DES.decode(table.relate_database.sqlalchemy_uri))
            if not PGUtil.check_table_privilege(table.name,"SELECT",db_tuple[0],pg_ds):
                raise  Exception("用户{}对表{}没有select权限！".format(db_tuple[0],table.name))

            if pg_ds:
                pg_ds.Destroy()

            if Task.query.filter_by(table_guid=table_guid,state=0).one_or_none():
                res["result"] = False
                res["msg"] = "数据精化中！"
                return res
            if table.table_type==0:
                res["result"] = False
                res["msg"] = "非空间表！"
                return res

            # if table.is_vacuate==1:
            #     res["state"] = -1
            #     res["message"] = "已精化！"
            #     return res



            # 初始化task
            task_guid = uuid.uuid1().__str__()
            vacuate_process = multiprocessing.Process(target=self.task,args=(table,task_guid))
            vacuate_process.start()

            ref_api = RefApi()
            ref_api.para["guid"] = table_guid
            ref_grids = ref_api.process()["data"]

            task = Task(guid=task_guid,
                        name="{}精化".format(table.name),
                        table_guid=table_guid,
                        create_time=datetime.datetime.now(),
                        state=0,
                        task_type=2,
                        creator=self.para.get("creator"),
                        file_name=None,
                        database_guid=table.database_guid,
                        process="精化中",
                        parameter=",".join([str(x) for x in ref_grids]))

            db.session.add(task)
            db.session.commit()
            res["msg"] = "图层抽稀已提交！"
            res["data"] = task_guid
            res["result"] = True

        except Exception as e:
            raise e
        finally:
            if db_session:
                db_session.close()
        return res

    def task(self,table,task_guid):

        sys_session = None
        pg_session = None
        pg_ds = None
        vacuate_process = None
        try:
            sys_session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
            sys_session.query(Table).filter_by(guid=table.guid).update(
                {"is_vacuate": 2, "update_time": datetime.datetime.now()})
            sys_session.commit()


            database = sys_session.query(Database).filter_by(guid=table.database_guid).one_or_none()
            pg_session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))

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


            #删除原有数据
            tvs = sys_session.query(TableVacuate).filter_by(table_guid=table.guid).all()
            for tv in tvs :
                sys_session.delete(tv)
                # try:
                #     pg_ds.DeleteLayer(tv.name)
                # except Exception as e :
                #     StructurePrint.print("抽稀图层不存在！","warn")

            # 创建抽稀过程
            options = ["OVERWRITE=yes", "GEOMETRY_NAME={}".format(PGUtil.get_geo_column(table.name,pg_session)),
                       "PRECISION=NO"]

            layer = pg_ds.GetLayerByName(table.name)

            vacuate_process:VacuateProcess = VacuateProcess(layer, table.guid, options,database.sqlalchemy_uri)


            for feature in layer:
                geo = feature.GetGeometryRef()
                #插入抽稀图层
                if geo is not None:
                    vacuate_process.vacuate(geo)


            #新增
            if configure.VACUATE_DB_URI:
                user, passwd, host, port, datab = PGUtil.get_info_from_sqlachemy_uri(configure.VACUATE_DB_URI)
            else:
                user, passwd, host, port, datab = PGUtil.get_info_from_sqlachemy_uri(DES.decode(database.sqlalchemy_uri))
            connectstr = "hostaddr={} port={} dbname='{}' user='{}' password='{}'".format(host, port, datab, user,
                                                                                                  passwd)
            for l in range(vacuate_process.max_level):
                lev = vacuate_process.t_grid_size.index(vacuate_process.this_gridsize[l])

                table_vacuate = TableVacuate(guid=uuid.uuid1().__str__(),
                                             table_guid=table.guid,
                                             level=lev,
                                             name=vacuate_process.vacuate_layers[l].GetName(),
                                             pixel_distance=vacuate_process.this_gridsize[l],
                                             connectstr=DES.encode(connectstr))
                sys_session.add(table_vacuate)

            sys_session.query(Task).filter_by(guid=task_guid).update({"state":1,"update_time":datetime.datetime.now(),
                                                                      "process": "精化完成"})
            sys_session.query(Table).filter_by(guid=table.guid).update(
                {"is_vacuate": 1, "update_time": datetime.datetime.now()})
            sys_session.commit()

        except Exception as e:
            try:
                sys_session.query(Task).filter_by(guid=task_guid).update({"state": -1,"update_time":datetime.datetime.now(),
                                                                          "process": "精化失败"})
                sys_session.query(Table).filter_by(guid=table.guid).update(
                    {"is_vacuate": 0, "update_time": datetime.datetime.now()})

                message = "{} {}".format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e.__str__())
                task_process_guid = uuid.uuid1().__str__()
                task_process = Process(guid=task_process_guid, message=message, time=datetime.datetime.now(),
                                       task_guid=task_guid)
                sys_session.add(task_process)
                sys_session.commit()
                if vacuate_process:
                    vacuate_process.rollback()

                print(traceback.format_exc())
            except Exception as ee:
                print(traceback.format_exc())
        finally:
            if vacuate_process:
                vacuate_process.end()
            if sys_session:
                sys_session.close()
            if pg_session:
                pg_session.close()
            if pg_ds:
                pg_ds.Destroy()


    api_doc = {
        "tags": ["管理接口"],
        "parameters": [
            {"name": "guid",
             "in": "formData",
             "type": "string",
             "description": "表guid", "required": "true"},
        ],
        "responses": {
            200: {
                "schema": {
                    "properties": {
                    }
                }
            }
        }
    }