import json
import os
from os.path import splitext

from django.views.decorators.csrf import csrf_exempt
from django.http import HttpResponse
from osgeo import ogr

from django.conf import settings
from monitorT.task import Task


class CustomTask(Task):
    CONTROL = True

    def cancel(self):
        pass

    def pause(self):
        pass


@csrf_exempt
@settings.MASTER_TASK_LIST.as_decorator
@CustomTask.as_decorator
def importSHPtoPostgis(task, request=None):
    error = ''
    if request.method == "GET":
        raise Exception("Petición GET no soportada")
    elif request.method == "POST":
        data = json.loads(request.body.decode("utf-8"))
        source = data["source"]
        params = data["connOrigen"]

    connString = "PG: host=%s dbname=%s user=%s password=%s port='%s'" % (
        params.get('host'), params.get('database'), params.get('user'), params.get('password'), params.get('port'))

    ogr_db = ogr.Open(connString)

    files = [cosa for cosa in os.listdir(source)]
    inc = int(100 / len(files))
    progreso = 0
    for file in files:
        if splitext(file)[1].upper() == '.SHP':
            try:
                shp = ogr.Open(source + file)
                if shp is None:
                    print("El shapefile no existe")
                    exit(1)
                else:
                    print(file + " --> El shapefile se abrió satisfactoriamente")

                    shapefile_layer = shp.GetLayer(0)

                    if shapefile_layer is not None:
                        layer_definition = shapefile_layer.GetLayerDefn()

                        # Create layer
                        db_layer = ogr_db.CreateLayer(splitext(file)[0], shapefile_layer.GetSpatialRef(), shapefile_layer.GetGeomType(), ['OVERWRITE=YES'])

                        for i in range(layer_definition.GetFieldCount()):
                            db_layer.CreateField(layer_definition.GetFieldDefn(i))

                        # Copy features
                        for feature in shapefile_layer:
                            db_layer.CreateFeature(feature)
                    else:
                        error = 'No es posible acceder a la capa'
            except:
                error = "No se ha podido subir el fichero " + file
                print(error)
        if task is not None:
            progreso += inc
            task.set_progress(progreso)

    ogr_db.Destroy()

    if error == '':
        task.set_progress(100)
        return HttpResponse('Tablas creadas correctamente!')
    else:
        return HttpResponse(error)


@csrf_exempt
@settings.MASTER_TASK_LIST.as_decorator
@CustomTask.as_decorator
def importGDBtoPostgis(task, request=None):
    error = ''
    layerList = []

    if request.method == "GET":
        raise Exception("Petición GET no soportada")
    elif request.method == "POST":
        data = json.loads(request.body.decode("utf-8"))
        source = data["source"]
        params = data["connOrigen"]

    driver = ogr.GetDriverByName('OpenFileGDB')
    gdb = driver.Open(source)

    connString = "PG: host=%s dbname=%s user=%s password=%s port='%s'" % (
        params.get('host'), params.get('database'), params.get('user'), params.get('password'), params.get('port'))

    ogr_db = ogr.Open(connString)

    for i in gdb:
        daLayer = i.GetName()
        if not daLayer in layerList:
            layerList.append(daLayer)

    layerList.sort()
    inc = float(100 / len(layerList))
    progreso = 0
    for layerName in layerList:
        shapefile_layer = gdb.GetLayer(layerName)

        if shapefile_layer is not None:
            layer_definition = shapefile_layer.GetLayerDefn()

            if shapefile_layer.GetGeomType() != '':
                # Create layer
                db_layer = ogr_db.CreateLayer(layerName, shapefile_layer.GetSpatialRef(), shapefile_layer.GetGeomType(), ['OVERWRITE=YES'])
            else:
                db_layer = ogr_db.CreateLayer(layerName, None, ogr.wkbUnknown, ['OVERWRITE=YES'])

            for i in range(layer_definition.GetFieldCount()):
                db_layer.CreateField(layer_definition.GetFieldDefn(i))

            try:
                # Copy features
                for feature in shapefile_layer:
                    db_layer.CreateFeature(feature)

            except Exception:
                print('Ha ocurrido un error al importar las tablas GDB a Postgres')
        else:
            error = 'No es posible acceder a la capa'

        if task is not None:
            progreso += inc
            task.set_progress(int(progreso))

    ogr_db.Destroy()
    gdb.Destroy()

    if error == '':
        task.set_progress(100)
        return HttpResponse('Tablas creadas correctamente!')
    else:
        return HttpResponse(error)


@csrf_exempt
@settings.MASTER_TASK_LIST.as_decorator
@CustomTask.as_decorator
def importPostgis(task, request=None):
    error = ''

    if request.method == "GET":
        raise Exception("Petición GET no soportada")
    elif request.method == "POST":
        data = json.loads(request.body.decode("utf-8"))
        layers = data["layers"]
        params = data["connOrigen"]
        params2 = data["connDest"]

    connString = "PG: host=%s dbname=%s user=%s password=%s port='%s'"
    connStringSource = connString % (
        params.get('host'), params.get('database'), params.get('user'), params.get('password'), params.get('port'))

    connStringDestiny = connString % (
        params2.get('host'), params2.get('database'), params2.get('user'), params2.get('password'), params2.get('port'))

    gdbSource = ogr.Open(connStringSource)

    # PASAR LA CADENA DE CONEXION POR PARÁMETRO Y VARIAS CAPAS
    #connStringDestiny = "PG: host=%s dbname=%s user=%s password=%s port='%s'" % (
    #    params2.get('host'), params2.get('database'), params2.get('user'), params2.get('password'), params2.get('port'))

    gdbDestiny = ogr.Open(connStringDestiny)

    layersSplit = layers.split(',')

    print(layersSplit)
    inc = float(100 / len(layersSplit))
    progreso = 0

    for layer in layersSplit:
        if layer != '':
            shapefile_layer = gdbSource.GetLayer(layer)

            if shapefile_layer is not None:
                layer_definition = shapefile_layer.GetLayerDefn()

                # Create layer
                db_layer = gdbDestiny.CreateLayer(layer, shapefile_layer.GetSpatialRef(), shapefile_layer.GetGeomType(), ['OVERWRITE=YES'])

                for i in range(layer_definition.GetFieldCount()):
                    db_layer.CreateField(layer_definition.GetFieldDefn(i))

                # Copy features
                for feature in shapefile_layer:
                    db_layer.CreateFeature(feature)
            else:
                error = 'No es posible acceder a la capa'

        if task is not None:
            progreso += inc
            task.set_progress(int(progreso))

    gdbSource.Destroy()

    if error == '':
        task.set_progress(100)
        return HttpResponse('Tablas creadas correctamente')
    else:
        return HttpResponse(error)


@csrf_exempt
@settings.MASTER_TASK_LIST.as_decorator
@CustomTask.as_decorator
def importPostgistoSHP(task, request=None):
    error = ''

    if request.method == "GET":
        raise Exception("Petición GET no soportada")
    elif request.method == "POST":
        data = json.loads(request.body.decode("utf-8"))
        layers = data["layers"]
        params = data["connOrigen"]
        sourceOutShapefile = data["shp"]

        connStringOrigin = "PG: host=%s dbname=%s user=%s password=%s port='%s'" % (
            params.get('host'), params.get('database'), params.get('user'), params.get('password'), params.get('port'))

    gdbSource = ogr.Open(connStringOrigin)

    layersSplit = layers.split(',')

    print(layersSplit)

    outDriver = ogr.GetDriverByName("ESRI Shapefile")

    inc = int(100 / len(layersSplit))
    progreso = 0

    for layer in layersSplit:
        if layer != '':
            # Elimina shapefile si existe
            shpName = sourceOutShapefile + layer + '.shp'
            if os.path.exists(shpName):
                outDriver.DeleteDataSource(shpName)

            outDataSource = outDriver.CreateDataSource(shpName)

            gdb_layer = gdbSource.GetLayer(layer)

            if gdb_layer is not None:
                layer_definition = gdb_layer.GetLayerDefn()

                # Se crea el nuevo shapefile
                layer = layer.encode('utf-8')
                shp_layer = outDataSource.CreateLayer(str(layer), gdb_layer.GetSpatialRef(), gdb_layer.GetGeomType())

                for i in range(layer_definition.GetFieldCount()):
                    shp_layer.CreateField(layer_definition.GetFieldDefn(i))

                # Copy features
                for feature in gdb_layer:
                    shp_layer.CreateFeature(feature)

                outDataSource.Destroy()
            else:
                error = 'No es posible acceder a la capa'

        if task is not None:
            progreso += inc
            task.set_progress(progreso)

    gdbSource.Destroy()

    if error == '':
        task.set_progress(100)
        return HttpResponse('Ficheros creados correctamente')
    else:
        return HttpResponse(error)