bornhack_plugin.py

"""
BornHack Plugin for QGIS.
"""

import os
import json
import requests
import tempfile

from qgis.PyQt.QtCore import (
    QSettings,
    QTranslator,
    QCoreApplication,
    Qt,
    QThread,
    pyqtSignal,
)
from qgis.PyQt.QtGui import QIcon
from qgis.PyQt.QtWidgets import QAction, QMessageBox, QProgressDialog
from qgis.core import (
    QgsProject,
    QgsVectorLayer,
    QgsFeature,
    QgsGeometry,
    QgsPointXY,
    QgsField,
    QgsFields,
    QgsWkbTypes,
    QgsMessageLog,
    Qgis,
)
from qgis.PyQt.QtCore import QVariant
from qgis.core import (
    QgsExpressionContextUtils,
    QgsVectorFileWriter,
    QgsCoordinateReferenceSystem,
)

# Initialize Qt resources from file resources.py
from .resources import *  # noqa: F403

# Import the code for the dialog
from .layer_dialog import LayerDropdownDialog
from .geojson_dialog import GeoJSONDialog


class ApiWorker(QThread):
    """Worker thread for API requests to avoid blocking the UI"""

    finished = pyqtSignal(list)
    error = pyqtSignal(str)
    progress = pyqtSignal(int)

    def __init__(self, api_url, headers=None):
        super().__init__()
        self.api_url = api_url
        self.headers = headers or {}

    def run(self):
        try:
            self.progress.emit(25)
            response = requests.get(self.api_url, headers=self.headers, timeout=30)
            self.progress.emit(50)

            if response.status_code == 200:
                data = response.json()
                self.progress.emit(75)

                # Handle different API response formats
                features = []
                if isinstance(data, dict):
                    if "features" in data:  # GeoJSON format
                        features = data["features"]
                    elif "data" in data:  # Common API format
                        features = data["data"]
                    else:
                        features = [data]  # Single feature
                elif isinstance(data, list):
                    features = data  # Direct array of features

                self.progress.emit(100)
                self.finished.emit(features)
            else:
                self.error.emit(f"HTTP Error {response.status_code}: {response.text}")

        except requests.exceptions.RequestException as e:
            self.error.emit(f"Network error: {str(e)}")
        except json.JSONDecodeError as e:
            self.error.emit(f"JSON parsing error: {str(e)}")
        except Exception as e:
            self.error.emit(f"Unexpected error: {str(e)}")


class BornHackPlugin:
    """BornHack QGIS Plugin Implementation."""

    def __init__(self, iface):
        """Constructor.

        :param iface: An interface instance that will be passed to this class
            which provides the hook by which you can manipulate the QGIS
            application at run time.
        :type iface: QgsInterface
        """
        # Save reference to the QGIS interface
        self.iface = iface
        # Initialize plugin directory
        self.plugin_dir = os.path.dirname(__file__)
        # Initialize locale
        locale = QSettings().value("locale/userLocale")[0:2]
        locale_path = os.path.join(
            self.plugin_dir, "i18n", "BornHack_{}.qm".format(locale)
        )

        if os.path.exists(locale_path):
            self.translator = QTranslator()
            self.translator.load(locale_path)
            QCoreApplication.installTranslator(self.translator)

        # Declare instance attributes
        self.actions = []
        self.menu = self.tr("&BornHack")
        self.toolbar = self.iface.addToolBar("BornHack")
        self.toolbar.setObjectName("BornHack")

        # Check if plugin was started the first time in current QGIS session
        self.first_start = None

    def tr(self, message):
        """Get the translation for a string using Qt translation API."""
        return QCoreApplication.translate("BornHack", message)

    def add_action(
        self,
        icon_path,
        text,
        callback,
        enabled_flag=True,
        add_to_menu=True,
        add_to_toolbar=True,
        status_tip=None,
        whats_this=None,
        parent=None,
    ):
        """Add a toolbar icon to the toolbar."""

        icon = QIcon(icon_path)
        action = QAction(icon, text, parent)
        action.triggered.connect(callback)
        action.setEnabled(enabled_flag)

        if status_tip is not None:
            action.setStatusTip(status_tip)

        if whats_this is not None:
            action.setWhatsThis(whats_this)

        if add_to_toolbar:
            self.toolbar.addAction(action)

        if add_to_menu:
            self.iface.addPluginToWebMenu(self.menu, action)

        self.actions.append(action)
        return action

    def initGui(self):
        """Create the menu entries and toolbar icons inside the QGIS GUI."""

        icon_path = ":/plugins/bornhack-qgis-plugin/icon-add.png"
        self.add_action(
            icon_path,
            text=self.tr("Add layer"),
            callback=self.run_add_layer,
            parent=self.iface.mainWindow(),
        )

        icon_path = ":/plugins/bornhack-qgis-plugin/icon-edit.png"
        self.add_action(
            icon_path,
            text=self.tr("Update selected layer"),
            callback=self.run_update_layer,
            parent=self.iface.mainWindow(),
        )

        icon_path = ":/plugins/bornhack-qgis-plugin/icon.png"
        self.add_action(
            icon_path,
            text=self.tr("Export selected layer"),
            callback=self.run_export_layer,
            parent=self.iface.mainWindow(),
        )

        # will be set False in run()
        self.first_start = True

    def unload(self):
        """Removes the plugin menu item and icon from QGIS GUI."""
        for action in self.actions:
            self.iface.removePluginWebMenu(self.tr("&BornHack"), action)
            self.iface.removeToolBarIcon(action)
        # remove the toolbar
        del self.toolbar

    def run_add_layer(self):
        """Run method that performs all the real work"""

        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start:
            self.first_start = False
            self.dlg = LayerDropdownDialog()

        # show the dialog
        self.dlg.show()
        # Run the dialog event loop
        result = self.dlg.exec_()

        # See if OK was pressed
        if result:
            self.load_api_data()

    def run_update_layer(self):
        """Run method that updates excisting layers."""

        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start:
            self.first_start = False
            self.dlg = LayerDropdownDialog()

        # show the dialog
        self.dlg.show()
        # Run the dialog event loop
        result = self.dlg.exec_()

        # See if OK was pressed
        if result:
            self.load_api_data(update=True)

    def run_export_layer(self):
        """Run method that exports selected layer."""
        # Get the active layer
        layer = self.iface.activeLayer()

        if not layer:
            QMessageBox.warning(
                self.iface.mainWindow(),
                "No Layer Selected",
                "Please select a vector layer to export.",
            )
            return

        if not hasattr(layer, "geometryType"):
            QMessageBox.warning(
                self.iface.mainWindow(),
                "Invalid Layer Type",
                "Please select a vector layer to export.",
            )
            return

        try:
            # Create temporary file for export
            with tempfile.NamedTemporaryFile(
                suffix=".geojson", delete=False
            ) as temp_file:
                temp_filename = temp_file.name

            # Set up export options
            options = QgsVectorFileWriter.SaveVectorOptions()
            options.driverName = "GeoJSON"
            options.fileEncoding = "UTF-8"

            # Transform to WGS84 (EPSG:4326) for GeoJSON standard
            if layer.crs().authid() != "EPSG:4326":
                from qgis.core import QgsCoordinateTransform

                options.ct = QgsCoordinateTransform(
                    layer.crs(),
                    QgsCoordinateReferenceSystem("EPSG:4326"),
                    QgsProject.instance(),
                )

            # Export the layer to temporary file
            error = QgsVectorFileWriter.writeAsVectorFormatV3(
                layer, temp_filename, QgsProject.instance().transformContext(), options
            )

            if error[0] == QgsVectorFileWriter.NoError:
                # Read the generated GeoJSON content
                with open(temp_filename, "r", encoding="utf-8") as f:
                    geojson_content = f.read()

                # Pretty format the JSON
                geojson_dict = json.loads(geojson_content)
                formatted_content = json.dumps(
                    geojson_dict, indent=2, ensure_ascii=False
                )

                # Show dialog with GeoJSON content
                dialog = GeoJSONDialog(
                    formatted_content, layer.name(), self.iface.mainWindow()
                )
                dialog.exec_()

                # Clean up temporary file
                os.unlink(temp_filename)

            else:
                QMessageBox.critical(
                    self.iface.mainWindow(),
                    "Export Failed",
                    f"Failed to export layer:\n{error[1]}",
                )
                # Clean up temporary file
                if os.path.exists(temp_filename):
                    os.unlink(temp_filename)

        except Exception as e:
            QMessageBox.critical(
                self.iface.mainWindow(),
                "Export Error",
                f"An error occurred during export:\n{str(e)}",
            )

    def load_api_data(self, update=False):
        """Load data from the API and create a vector layer"""

        layer_data = self.dlg.get_selected_data()
        api_url = layer_data["url"]
        if not api_url:
            QMessageBox.warning(
                self.iface.mainWindow(), "Warning", "Please enter an API URL"
            )
            return

        # Get headers if any
        headers = {}
        # if self.dlg.headers_text_edit.toPlainText().strip():
        #    try:
        #        headers = json.loads(self.dlg.headers_text_edit.toPlainText())
        #    except json.JSONDecodeError:
        #        QMessageBox.warning(
        #            self.iface.mainWindow(),
        #            "Warning",
        #            "Invalid JSON format in headers"
        #        )
        #        return

        # Create progress dialog
        progress = QProgressDialog(
            "Loading data from Website...", "Cancel", 0, 100, self.iface.mainWindow()
        )
        progress.setWindowModality(Qt.WindowModal)
        progress.show()

        # Create worker thread
        self.worker = ApiWorker(api_url, headers)
        self.worker.finished.connect(
            lambda features: self.process_json(features, progress, update)
        )
        self.worker.error.connect(lambda error: self.handle_error(error, progress))
        self.worker.progress.connect(progress.setValue)

        progress.canceled.connect(self.worker.terminate)
        self.worker.start()

    def handle_error(self, error_message, progress):
        """Handle API errors"""
        progress.close()
        QMessageBox.critical(self.iface.mainWindow(), "API Error", error_message)
        QgsMessageLog.logMessage(
            f"BornHack Error: {error_message}", "BornHack", Qgis.Critical
        )

    def process_json(self, features, progress, update):
        """Process the json output."""
        progress.close()

        if not features:
            QMessageBox.information(
                self.iface.mainWindow(), "Info", "No features returned from API"
            )
            return

        if update:
            self.update_layer(features, progress)
        else:
            self.create_vector_layer(features, progress)

    def create_vector_layer(self, features, progress):
        """Create a QGIS vector layer from API features"""
        progress.close()

        if not features:
            QMessageBox.information(
                self.iface.mainWindow(), "Info", "No features returned from API"
            )
            return

        layer_data = self.dlg.get_selected_data()
        layer_name = (
            f"{layer_data['camp']} - {layer_data['team']} - {layer_data['name']}"
        )

        try:
            geom_type = self.determine_geometry_type(features[0])
            layer = QgsVectorLayer(geom_type, layer_name, "memory")
            QgsExpressionContextUtils.setLayerVariable(
                layer, "bornhack_layer_url", layer_data["url"]
            )
            provider = layer.dataProvider()
            fields = self.create_fields_from_feature(features[0])
            provider.addAttributes(fields)
            layer.updateFields()
            qgs_features = []
            for feature_data in features:
                layer_fields = layer.fields()
                qgs_feature = self.create_qgs_feature(feature_data, layer_fields)
                if qgs_feature:
                    qgs_features.append(qgs_feature)
            provider.addFeatures(qgs_features)
            layer.updateExtents()
            QgsProject.instance().addMapLayer(layer)
            self.iface.zoomToActiveLayer()
            QMessageBox.information(
                self.iface.mainWindow(),
                "Success",
                f"Successfully loaded {len(qgs_features)} features from BornHack",
            )

        except Exception as e:
            QMessageBox.critical(
                self.iface.mainWindow(), "Error", f"Failed to create layer: {str(e)}"
            )
            QgsMessageLog.logMessage(
                f"Layer creation error: {str(e)}", "BornHack", Qgis.Critical
            )

    def update_layer(self, features, progress):
        """Update a QGIS vector layer from API features"""
        progress.close()

        if not features:
            QMessageBox.information(
                self.iface.mainWindow(), "Info", "No features returned from API"
            )
            return

        layer_data = self.dlg.get_selected_data()

        try:
            selected_layers = self.iface.layerTreeView().selectedLayers()
            if len(selected_layers) > 1:
                print("To many layers selected")
            layer = selected_layers[0]
            layer.startEditing()

            QgsExpressionContextUtils.setLayerVariable(
                layer, "bornhack_layer_url", layer_data["url"]
            )
            provider = layer.dataProvider()

            layer_features = layer.getFeatures()
            for f in layer_features:
                print(f.id)

            # Empty the layer
            provider.truncate()

            # Add features to layer
            qgs_features = []
            for feature_data in features:
                layer_fields = layer.fields()
                qgs_feature = self.create_qgs_feature(feature_data, layer_fields)
                if qgs_feature:
                    qgs_features.append(qgs_feature)

            provider.addFeatures(qgs_features)
            layer.updateExtents()
            layer.commitChanges()

            # Zoom to layer extent
            self.iface.zoomToActiveLayer()

            QMessageBox.information(
                self.iface.mainWindow(),
                "Success",
                f"Successfully loaded {len(qgs_features)} features from BornHack",
            )

        except Exception as e:
            QMessageBox.critical(
                self.iface.mainWindow(), "Error", f"Failed to create layer: {str(e)}"
            )
            QgsMessageLog.logMessage(
                f"Layer creation error: {str(e)}", "BornHack", Qgis.Critical
            )

    def determine_geometry_type(self, feature):
        """Determine QGIS geometry type from feature"""
        if "geometry" in feature:
            geom = feature["geometry"]
            if geom and "type" in geom:
                geom_type = geom["type"].lower()
                if geom_type == "point":
                    return "Point"
                elif geom_type in ["linestring", "multilinestring"]:
                    return "LineString"
                elif geom_type in ["polygon", "multipolygon"]:
                    return "MultiPolygon"
                elif geom_type in ["geometrycollection"]:
                    geom_type = geom["geometries"][0]["type"].lower()
                    if geom_type == "point":
                        return "Point"
                    elif geom_type in ["linestring", "multilinestring"]:
                        return "LineString"
                    elif geom_type in ["polygon", "multipolygon"]:
                        return "MultiPolygon"
        return "Point"  # Default to point

    def create_fields_from_feature(self, feature):
        """Create QgsFields from feature properties"""
        fields = QgsFields()

        # Add fields from properties
        properties = feature.get("properties", feature)
        if "uuid" not in properties:
            fields.append(QgsField(name="uuid", type=QVariant.String))
        for key, value in properties.items():
            if isinstance(value, int):
                fields.append(QgsField(name=key, type=QVariant.Int))
            elif isinstance(value, float):
                fields.append(QgsField(name=key, type=QVariant.Double))
            elif isinstance(value, bool):
                fields.append(QgsField(name=key, type=QVariant.Bool))
            else:
                fields.append(QgsField(name=key, type=QVariant.String))
        return fields

    def create_qgs_feature(self, feature_data, fields):
        """Create QgsFeature from API feature data"""
        try:
            qgs_feature = QgsFeature(fields)

            # Set geometry
            geometry = self.create_geometry(feature_data)
            if geometry:
                qgs_feature.setGeometry(geometry)

            # Set attributes
            properties = feature_data.get("properties", feature_data)
            feature_id = feature_data.get("id")
            if "uuid" not in properties and feature_id:
                properties.update({"uuid": feature_id})

            for field in fields:
                field_name = field.name()
                if field_name == "uuid" and field_name not in properties:
                    # Auto-generate ID if not present
                    qgs_feature.setAttribute(
                        field_name,
                        feature_data.get("uuid", hash(str(feature_data)) % 1000000),
                    )
                elif field_name in properties:
                    qgs_feature.setAttribute(field_name, properties[field_name])
            return qgs_feature

        except Exception as e:
            QgsMessageLog.logMessage(
                f"Feature creation error: {str(e)}", "BornHack", Qgis.Warning
            )
            return None

    def create_geometry(self, feature_data):
        """Create QgsGeometry from feature data"""
        try:
            # Handle GeoJSON geometry
            if "geometry" in feature_data:
                geom_data = feature_data["geometry"]
                if geom_data:
                    return self.parse_geojson_geometry(geom_data)

            # Handle nested geometry field
            if "geom" in feature_data:
                geom_data = feature_data["geom"]
                if geom_data:
                    return self.parse_geojson_geometry(geom_data)

            # Handle WKT geometry
            if "wkt" in feature_data:
                wkt = feature_data["wkt"]
                if wkt:
                    return QgsGeometry.fromWkt(wkt)
            return None

        except Exception as e:
            QgsMessageLog.logMessage(
                f"Geometry creation error: {str(e)}", "BornHack", Qgis.Warning
            )
            return None

    def parse_geojson_geometry(self, geom_data):
        """Parse GeoJSON geometry object recursively"""
        if not geom_data or "type" not in geom_data:
            QgsMessageLog.logMessage(
                "not geom_data or 'type' not in geom_data", "BornHack", Qgis.Warning
            )
            return None

        geom_type = geom_data["type"].lower()

        # Handle GeometryCollection
        if geom_type == "geometrycollection":
            return self.create_geometry_collection(geom_data.get("geometries", []))

        # All other geometry types need coordinates
        if "coordinates" not in geom_data:
            QgsMessageLog.logMessage(
                "'coordinates' not in geom_data", "BornHack", Qgis.Warning
            )
            return None

        # coords = list(itertools.chain.from_iterable(itertools.chain.from_iterable(geom_data['coordinates'])))
        coords = geom_data["coordinates"]

        try:
            if geom_type == "point":
                return self.create_point_geometry(coords)
            elif geom_type == "multipoint":
                return self.create_multipoint_geometry(coords)
            elif geom_type == "linestring":
                return self.create_linestring_geometry(coords)
            elif geom_type == "multilinestring":
                return self.create_multilinestring_geometry(coords)
            elif geom_type == "polygon":
                return self.create_polygon_geometry(coords)
            elif geom_type == "multipolygon":
                return self.create_multipolygon_geometry(coords)
            else:
                QgsMessageLog.logMessage(
                    f"Unsupported geometry type: {geom_type}", "BornHack", Qgis.Warning
                )
                return None

        except Exception as e:
            QgsMessageLog.logMessage(
                f"Error parsing {geom_type}: {str(e)}", "BornHack", Qgis.Warning
            )
            return None

    def create_point_geometry(self, coords):
        """Create point geometry from coordinates"""
        if len(coords) >= 2:
            return QgsGeometry.fromPointXY(QgsPointXY(coords[0], coords[1]))
        return None

    def create_multipoint_geometry(self, coords):
        """Create multipoint geometry from coordinate arrays"""
        points = []
        for coord in coords:
            if len(coord) >= 2:
                points.append(QgsPointXY(coord[0], coord[1]))

        if points:
            return QgsGeometry.fromMultiPointXY(points)
        return None

    def create_linestring_geometry(self, coords):
        """Create linestring geometry from coordinate array"""
        points = []
        for coord in coords:
            if len(coord) >= 2:
                points.append(QgsPointXY(coord[0], coord[1]))

        if len(points) >= 2:
            return QgsGeometry.fromPolylineXY(points)
        return None

    def create_multilinestring_geometry(self, coords):
        """Create multilinestring geometry from nested coordinate arrays"""
        lines = []
        for line_coords in coords:
            points = []
            for coord in line_coords:
                if len(coord) >= 2:
                    points.append(QgsPointXY(coord[0], coord[1]))

            if len(points) >= 2:
                lines.append(points)

        if lines:
            return QgsGeometry.fromMultiPolylineXY(lines)
        return None

    def create_polygon_geometry(self, coords):
        """Create polygon geometry with potential holes"""
        if not coords or len(coords) == 0:
            return None

        # Exterior ring
        exterior = []
        for coord in coords[0]:
            if len(coord) >= 2:
                exterior.append(QgsPointXY(coord[0], coord[1]))

        if len(exterior) < 3:
            return None

        # Interior rings (holes)
        holes = []
        for i in range(1, len(coords)):
            hole = []
            for coord in coords[i]:
                if len(coord) >= 2:
                    hole.append(QgsPointXY(coord[0], coord[1]))

            if len(hole) >= 3:
                holes.append(hole)

        # Create polygon with holes
        polygon_rings = [exterior] + holes
        return QgsGeometry.fromPolygonXY(polygon_rings)

    def create_multipolygon_geometry(self, coords):
        """Create multipolygon geometry from nested coordinate arrays"""
        polygons = []

        for polygon_coords in coords:
            if not polygon_coords or len(polygon_coords) == 0:
                continue

            # Exterior ring
            exterior = []
            for coord in polygon_coords[0]:
                if len(coord) >= 2:
                    exterior.append(QgsPointXY(coord[0], coord[1]))

            if len(exterior) < 3:
                continue

            # Interior rings (holes)
            holes = []
            for i in range(1, len(polygon_coords)):
                hole = []
                for coord in polygon_coords[i]:
                    if len(coord) >= 2:
                        hole.append(QgsPointXY(coord[0], coord[1]))

                if len(hole) >= 3:
                    holes.append(hole)

            # Add polygon with holes
            polygon_rings = [exterior] + holes
            polygons.append(polygon_rings)

        if polygons:
            return QgsGeometry.fromMultiPolygonXY(polygons)
        return None

    def create_geometry_collection(self, geometries):
        """Create geometry collection from array of geometries"""
        if not geometries:
            return None

        # For geometry collections, we'll create a collection of the first geometry
        # or combine multiple geometries if they're the same type
        valid_geometries = []

        for geom_data in geometries:
            geom = self.parse_geojson_geometry(geom_data)
            if geom and not geom.isEmpty() and geom.isGeosValid():
                valid_geometries.append(geom)
            else:
                print("Geom not valid", geom_data)

        if not valid_geometries:
            return None

        # If only one geometry, return it directly
        if len(valid_geometries) == 1:
            return valid_geometries[0]

        # Try to combine geometries of the same type
        geom_types = [geom.type() for geom in valid_geometries]

        # If all geometries are the same type, combine them
        if len(set(geom_types)) == 1:
            geom_type = geom_types[0]

            if geom_type == QgsWkbTypes.PointGeometry:
                # Combine points into multipoint
                points = []
                for geom in valid_geometries:
                    if geom.isMultipart():
                        points.extend(geom.asMultiPoint())
                    else:
                        points.append(geom.asPoint())
                return QgsGeometry.fromMultiPointXY(points)

            elif geom_type == QgsWkbTypes.LineGeometry:
                # Combine lines into multilinestring
                lines = []
                for geom in valid_geometries:
                    if geom.isMultipart():
                        lines.extend(geom.asMultiPolyline())
                    else:
                        lines.append(geom.asPolyline())
                return QgsGeometry.fromMultiPolylineXY(lines)

            elif geom_type == QgsWkbTypes.PolygonGeometry:
                # Combine polygons into multipolygon
                polygons = []
                for geom in valid_geometries:
                    if geom.isMultipart():
                        polygons.extend(geom.asMultiPolygon())
                    else:
                        polygons.append(geom.asPolygon())
                return QgsGeometry.fromMultiPolygonXY(polygons)

        # If mixed types, return the first valid geometry
        return valid_geometries[0]