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


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

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
import multiprocessing
import uuid
import configure
from osgeo.ogr import DataSource

class Api(ApiTemplate):

    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("图层不存在！")
            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()


            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="精化中")
            db.session.add(task)
            db.session.commit()
            res["msg"] = "图层抽稀已提交！"
            res["data"] = table_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))

            # 创建抽稀过程
            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(layer, table.name, options,database.sqlalchemy_uri)


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

            sys_session.query(Task).filter_by(guid=task_guid).update({"state":1,"update_time":datetime.datetime.now()})
            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()})
                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()
                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": {
                    }
                }
            }
        }
    }