import json
import pyproj
import geojson
import geopandas as gpd
# TIPOS DE GEOMETRÍASS
LINE = 'line'
POINT = 'point'
POLYGON = 'polygon'

MULTILINE = 'multiline'
MULTIPOINT = 'multipoint'
MULTIPOLYGON = 'multipolygon'


def give_buffer(geojson, buffer, file_buffered):

        geojson = json.loads(geojson)

        # print(geojson)

        geojson = gpd.GeoDataFrame.from_features(geojson['features'])

        if (str(geojson['geometry'].type[0])).lower() == "polygon" or (str(geojson['geometry'].type[0])).lower() == "multipolygon":
            geojson = geojson.boundary

        buffered = geojson.buffer(buffer,1)
#        print(buffered)
        buffered.to_file(file_buffered, driver="GeoJSON", indent=4) # Necesario que sea un archivo GeoJSON

        return file_buffered

def translate_coords(user=None, task=None, point=None, coordSystem=None):
    
    # print(point, coordSystem)

    if coordSystem[0] == coordSystem[1]:
        return point
    else:
        transformer = pyproj.Transformer.from_crs(coordSystem[0], coordSystem[1], always_xy=True)
        if isinstance(point[0], list):
            point_return = []
            for item in point:
                lat, lon = item[0], item[1]
                lon, lat = transformer.transform(lon, lat)
                point_return.append([lat, lon])
        else:
            lat, lon = point[0], point[1]
            lon, lat = transformer.transform(lon, lat)
            point_return = [lat, lon]
        return point_return

def hacer_buffer(point, geometryType, coordSystem):

    quantity_to_buffer = 2 # Esto son metros

    if isinstance(coordSystem,str):
        coordSystem = [coordSystem]
    
    coordSystem.append("EPSG:25830")

    array_to_geojson = []

    if (geometryType.lower()).find(POINT) != -1:
        array_to_buffer = []
        if (geometryType.lower()).find(MULTIPOINT) != -1:
            prev_array_to_buffer = []
            for index,item in enumerate(point):
                # item = item[::-1]
                if coordSystem[0] == coordSystem[1]:
                    pass
                else:
                    item = translate_coords(None,None,item,coordSystem)
                item = item[::-1]
                coordinateX = item[0]
                coordinateY = item[1]
                prev_array_to_buffer.append([coordinateX, coordinateY])
                array_to_buffer.append(geojson.MultiPoint(prev_array_to_buffer))
                typeClassification = f'{geometryType}_{index}'
                array_to_geojson.append(geojson.Feature(geometry=geojson.Point((coordinateX, coordinateY, 0.0)), properties={"typeClassification": str(typeClassification), "X": str(coordinateX), "Y": str(coordinateY), "Z": "0" }))
                # dict_to_return = complete_dict(coordinateX, coordinateY, typeClassification, dict_to_return)
            geometry_to_buffer = geojson.GeometryCollection(array_to_buffer)
        else:
            item = point
            # item = item[::-1]
            if coordSystem[0] == coordSystem[1]:
                pass
            else:
                item = translate_coords(None,None,item,coordSystem)
            item = item[::-1]
            coordinateX = item[0]
            coordinateY = item[1]
            geometry_to_buffer = geojson.Point((coordinateX, coordinateY))
            typeClassification = f'{geometryType}'
            array_to_geojson.append(geojson.Feature(geometry=geojson.Point((coordinateX, coordinateY, 0.0)), properties={"typeClassification": str(typeClassification), "X": str(coordinateX), "Y": str(coordinateY), "Z": "0" }))
            # dict_to_return = complete_dict(coordinateX, coordinateY, typeClassification, dict_to_return)
    elif (geometryType.lower()).find(LINE) != -1:
        array_to_buffer = []
        if (geometryType.lower()).find(MULTILINE) != -1:
            for index_prev, item_prev in enumerate(point):
                prev_array_to_buffer = []
                for index, item in enumerate(item_prev):
                    item = item[::-1]
                    if coordSystem[0] == coordSystem[1]:
                        pass
                    else:
                        item = translate_coords(None,None,item,coordSystem)
                    item = item[::-1]
                    coordinateX = item[0]
                    coordinateY = item[1]
                    prev_array_to_buffer.append([coordinateX, coordinateY])
                    typeClassification = f'{geometryType}_{index_prev}'
                    array_to_geojson.append(geojson.Feature(geometry=geojson.Point((coordinateX, coordinateY, 0.0)), properties={"typeClassification": str(typeClassification), "X": str(coordinateX), "Y": str(coordinateY), "Z": "0" }))
                    # dict_to_return = complete_dict(coordinateX, coordinateY, typeClassification, dict_to_return)
                array_to_buffer.append(geojson.LineString(prev_array_to_buffer))
            geometry_to_buffer = geojson.MultiLineString(array_to_buffer)
        else:
            for index,item in enumerate(point):
                item = item[::-1]
                if coordSystem[0] == coordSystem[1]:
                    pass
                else:
                    item = translate_coords(None,None,item,coordSystem)
                item = item[::-1]
                coordinateX = item[0]
                coordinateY = item[1]
                array_to_buffer.append([coordinateX, coordinateY])
                typeClassification = f'{geometryType}'
                array_to_geojson.append(geojson.Feature(geometry=geojson.Point((coordinateX, coordinateY, 0.0)), properties={"typeClassification": str(typeClassification), "X": str(coordinateX), "Y": str(coordinateY), "Z": "0" }))
                # dict_to_return = complete_dict(coordinateX, coordinateY, typeClassification, dict_to_return)
            geometry_to_buffer = geojson.LineString(array_to_buffer)
    elif (geometryType.lower()).find(POLYGON) != -1:
        array_to_buffer = []
        if (geometryType.lower()).find(MULTIPOLYGON) != -1:
            for index_prev, item_prev in enumerate(point):
                prev_array_to_buffer = []
                for index, item in enumerate(item_prev):
                    item = item[::-1]
                    if coordSystem[0] == coordSystem[1]:
                        pass
                    else:
                        item = translate_coords(None,None,item,coordSystem)
                    item = item[::-1]
                    coordinateX = item[0]
                    coordinateY = item[1]
                    prev_array_to_buffer.append([coordinateX, coordinateY])
                    typeClassification = f'{geometryType}_{index_prev}'
                    array_to_geojson.append(geojson.Feature(geometry=geojson.Point((coordinateX, coordinateY, 0.0)), properties={"typeClassification": str(typeClassification), "X": str(coordinateX), "Y": str(coordinateY), "Z": "0" }))
                    # dict_to_return = complete_dict(coordinateX, coordinateY, typeClassification, dict_to_return)
                array_to_buffer.append(geojson.Polygon(prev_array_to_buffer))
            geometry_to_buffer = geojson.MultiPolygon(array_to_buffer)
        else:
            for index,item in enumerate(point):
                item = item[::-1]
                if coordSystem[0] == coordSystem[1]:
                    pass
                else:
                    item = translate_coords(None,None,item,coordSystem)
                item = item[::-1]
                coordinateX = item[0]
                coordinateY = item[1]
                array_to_buffer.append([coordinateX, coordinateY])
                typeClassification = f'{geometryType}'
                array_to_geojson.append(geojson.Feature(geometry=geojson.Point((coordinateX, coordinateY, 0.0)), properties={"typeClassification": str(typeClassification), "X": str(coordinateX), "Y": str(coordinateY), "Z": "0" }))
                # dict_to_return = complete_dict(coordinateX, coordinateY, typeClassification, dict_to_return)
            geometry_to_buffer = geojson.Polygon(array_to_buffer)
    
    feature = geojson.Feature(geometry=geometry_to_buffer, properties={"name": "GeoJSON to buffer", "description": f"This geometry type {geometryType} is going to be buffered"})
    feature_collection = geojson.FeatureCollection([feature])
    geojson_to_buffer = geojson.dumps(feature_collection, sort_keys=True)

    give_buffer(geojson_to_buffer, quantity_to_buffer, "/home/pruebas/prueba_buffer.geojson")

    feature_collection = geojson.FeatureCollection(array_to_geojson)
    print(feature_collection)


point = [43.464133, -3.822284]
geometryType = "point"
coordSystem = "EPSG:4326"
hacer_buffer(point, geometryType, coordSystem)