import ogr, osr

class Importer:

    def __init__(self, dbconn, river_id, dest_srs):
        self.dbconn   = dbconn
        self.river_id = river_id
        self.dest_srs = osr.SpatialReference()
        self.dest_srs.ImportFromEPSG(dest_srs)


    def getKind(self, path):
        raise NotImplementedError("Importer.getKind is abstract!")


    def getPath(self, base):
        raise NotImplementedError("Importer.getPath is abstract!")


    def getTablename(self):
        raise NotImplementedError("Importer.getTablename is abstract!")


    def IsFieldSet(self, feat, name):
        try:
            isset = feat.GetField(name)
            return isset is not None
        except:
            return False


    def IsDoubleFieldSet(self, feat, name):
        try:
            isset = feat.GetFieldAsDouble(name)
            return isset is not None
        except:
            return False


    def isShapeRelevant(self, name, path):
        return True


    def walkOverShapes(self, shape):
        (name, path) = shape
        if not self.isShapeRelevant(name, path):
            print "Skip shapefile '%s'" % name
            return

        shp = ogr.Open(shape[1])
        if shp is None:
            print "Shapefile '%s' could not be opened!" % path
            return

        print "Opened shapefile '%s'" % path
        srcLayer = shp.GetLayerByName(name)

        if srcLayer is None:
            print "Layer '%s' was not found!" % name
            return

        return self.shape2Database(srcLayer, name, path)


    def transform(self, feat):
        geometry = feat.GetGeometryRef()
        src_srs  = geometry.GetSpatialReference()

        if src_srs is None:
            print "Error: No source SRS given! No transformation possible!"
            return feat

        transformer = osr.CoordinateTransformation(src_srs, self.dest_srs)
        geometry.Transform(transformer)

        return feat


    def shape2Database(self, srcLayer, name, path):
        table     = ogr.Open(self.dbconn)
        destLayer = table.GetLayerByName(self.getTablename())

        if srcLayer is None:
            print "Shapefile is None!"
            return -1

        if destLayer is None:
            print "No destination layer given!"
            return -1

        count = srcLayer.GetFeatureCount()
        print "Try to add %i features to database." % count

        srcLayer.ResetReading()

        geomType    = -1
        success     = 0
        unsupported = 0
        creationFailed = 0
        featureDef  = destLayer.GetLayerDefn()

        for feat in srcLayer:
            geom     = feat.GetGeometryRef()

            if geom is None:
                continue

            geomType = geom.GetGeometryType()

            if self.isGeometryValid(geomType):
                newFeat = self.createNewFeature(featureDef,
                                                feat,
                                                name=name,
                                                path=path)

                if newFeat is not None:
                    newFeat = self.transform(newFeat)
                    res = destLayer.CreateFeature(newFeat)
                    if res is None or res > 0:
                        print "Error while inserting feature: %r" % res
                    else:
                        success = success + 1
                else:
                    creationFailed = creationFailed + 1
            else:
                unsupported = unsupported + 1

        print "Inserted %i features" % success
        print "Failed to create %i features" % creationFailed
        print "Found %i unsupported features" % unsupported

        try:
            destLayer.CommitTransaction()
        except e:
            print "Exception while committing transaction."

        return geomType