from qgis.PyQt.QtWidgets import QDockWidget, QVBoxLayout, QHBoxLayout, QWidget, QLabel, QGroupBox, QScrollArea, QSplitter, QPushButton, QMessageBox
from qgis.PyQt.QtCore import Qt, QTimer
from qgis.utils import iface
from qgis.core import QgsSettings
from datetime import datetime
from ..utils.task_list import TasksReview
from ..utils.api import APIGetOrderDetails, APICompleteOrder, APIRejectOrder
from ..utils.document_list import DocumentList, BaseDocumentList
from ..utils.messaging_widget import MessagingWidget
from ..utils.cognito_auth import CognitoSession
from .password_confirm_dialog import PasswordConfirmDialog


class OrderDetailDock(QDockWidget):
    """Gedocktes Fenster für Auftragsdetails - ersetzt den modalen OrderDetailDialog."""

    STATUS_MAP = {
        "draft": "Entwurf",
        "inTender": "In Ausschreibung",
        "contracted": "Beauftragt",
        "inDevelopment": "In Bearbeitung",
        "inReview": "Zur Abnahme",
        "completed": "Abgeschlossen"
    }

    def __init__(self, cognito_session=None, order_id=None, plan_id=None):
        super().__init__("XPlanung24 - Auftragsdetails", iface.mainWindow())
        self.cognito_session = cognito_session
        self.order_id = order_id
        self.plan_id = plan_id
        self.order = {}

        self.setAllowedAreas(Qt.RightDockWidgetArea | Qt.LeftDockWidgetArea)
        self.setMinimumWidth(800)

        self._setup_ui()
        self.load_order_details()

    def _setup_ui(self):
        """Initialisiert das UI."""
        # Container Widget
        container = QWidget()
        main_layout = QVBoxLayout(container)
        main_layout.setContentsMargins(0, 0, 0, 0)

        # Styles
        self.setStyleSheet("""
            QDockWidget {
                font-size: 14px;
            }
            QDockWidget::title {
                background-color: #f3f4f6;
                padding: 8px;
                font-weight: bold;
            }
            QGroupBox {
                background-color: #fff;
                border-radius: 8px;
                border: none;
                margin: 0px;
                padding: 6px 0px;
            }
            QPushButton {
                cursor: pointer;
                border: 1px solid #000;
                padding: 4px 12px;
                margin: 2px;
                font-size: 12px;
                height: 24px;
                border-radius: 6px;
            }
            QPushButton:hover {
                background-color: #000;
                color: white;
                border: 1px solid #000;
            }
            QPushButton:pressed {
                background-color: #333;
                color: white;
            }
        """)

        # Detail labels
        self.detail_labels = {}
        for label_text in ["Auftragsnummer", "Auftragsbezeichnung", "Gemeinde", "Erstellt am", "Fortschritt"]:
            self.detail_labels[label_text] = QLabel("-")

        # Dynamic area - hier wird der Inhalt gebaut
        self.dynamic_area = QVBoxLayout()
        main_layout.addLayout(self.dynamic_area)

        self.setWidget(container)

    def load_order_details(self):
        """Lädt die Auftragsdetails vom Backend."""
        if not (self.cognito_session and self.cognito_session.access_token):
            QMessageBox.critical(self, "Fehler", "Keine gültige Authentifizierung vorhanden.")
            return

        try:
            self.order = APIGetOrderDetails(self.cognito_session, self.order_id)

            stage = self.order.get("stage", "-")
            self.detail_labels["Auftragsnummer"].setText(self.order.get("planId", "-"))
            self.detail_labels["Auftragsbezeichnung"].setText(
                (self.order.get("planDetails") or {}).get("name", "-")
            )
            self.detail_labels["Gemeinde"].setText(
                ((self.order.get("planDetails") or {}).get("community") or {}).get("name", "-")
            )
            created_at = self._format_timestamp(self.order.get("createdAt"))
            self.detail_labels["Erstellt am"].setText(created_at)
            self.detail_labels["Fortschritt"].setText(self.STATUS_MAP.get(stage, stage))

            reviews = self.order.get("reviewDetails", [])
            reviews = sorted(reviews, key=lambda x: int(x.get("version", 0)), reverse=True)

            self._build_dynamic_area(stage, reviews)

        except Exception as e:
            QMessageBox.warning(self, "Fehler", f"Konnte Auftragsdetails nicht laden:\n{e}")

    def _build_dynamic_area(self, stage: str, reviewDetails: list):
        """Baut den dynamischen Bereich mit Abnahmeprotokoll und Details."""
        # Clear old widgets
        while self.dynamic_area.count():
            item = self.dynamic_area.takeAt(0)
            if item.widget():
                item.widget().deleteLater()

        # Scrollbereich (LEFT SIDE)
        scroll = QScrollArea()
        scroll.setStyleSheet("""
            QScrollArea {
                border: none;
                background-color: #f9fafb;
            }
        """)
        scroll.setWidgetResizable(True)
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        scroll_content = QWidget()
        scroll_layout = QVBoxLayout(scroll_content)

        # Auftragsdokumente (direkt am Auftrag, nicht an Review)
        base_docs_box = QGroupBox()
        base_docs_inner = QWidget()
        base_docs_layout = QVBoxLayout(base_docs_inner)

        base_docs_title = QLabel("Auftragsdokumente")
        base_docs_title.setStyleSheet("font-weight: bold;")
        base_docs_layout.addWidget(base_docs_title)

        base_docs_desc = QLabel("Dokumente und Plandaten, die direkt am Auftrag hängen.")
        base_docs_desc.setStyleSheet("color: #666; font-size: 12px;")
        base_docs_layout.addWidget(base_docs_desc)

        base_doc_list = BaseDocumentList(
            self.cognito_session,
            self.order_id,
            self
        )
        base_docs_layout.addWidget(base_doc_list)

        base_docs_outer = QVBoxLayout()
        base_docs_outer.addWidget(base_docs_inner)
        base_docs_box.setLayout(base_docs_outer)
        scroll_layout.addWidget(base_docs_box)

        for idx, review in enumerate(reviewDetails):
            box = QGroupBox()
            inner_widget = QWidget()
            inner = QVBoxLayout(inner_widget)

            status = review.get("status", "")
            created = self._format_timestamp(review.get("creationDate"))

            status_version = QLabel(f"Version {review.get('version', '-')}")
            status_version.setStyleSheet("font-weight: bold;")
            inner.addWidget(status_version)

            status_label = QLabel()
            if status == "active" and stage == "inReview":
                status_label.setText("Die Bearbeitung Ihres Auftrags wurde abgeschlossen und kann geprüft werden.")
            elif status == "rejected":
                status_label.setText("Diese Abnahme wurde bereits abgelehnt.")
                status_label.setStyleSheet("color: #dc2626; font-weight: bold;")
            elif status == "cancel":
                status_label.setText("Diese Abnahme wurde zurückgezogen.")
                status_label.setStyleSheet("color: #d97706; font-weight: bold;")
            elif idx == 0:
                status_label.setText("Diese Abnahme wurde abgenommen.")
                status_label.setStyleSheet("color: #16a34a; font-weight: bold;")
            else:
                status_label.setText("Diese Abnahme ist abgelehnt oder zurückgezogen.")
                status_label.setStyleSheet("color: #d97706; font-weight: bold;")

            inner.addWidget(status_label)
            inner.addWidget(QLabel(f"Erstellt am: {created}"))

            doc_list = DocumentList(
                self.cognito_session,
                self.order_id,
                review.get("reviewId", ""),
                self,
                plan_id=self.order.get("planId"),
                user_status=self.order.get("companyStatus", "")
            )
            inner.addWidget(doc_list)

            tasks_widget = TasksReview(
                order_id=self.order_id,
                company_id=self.order.get("companyId", ""),
                user_status=self.order.get("companyStatus", ""),
                order_stage=stage,
                selected_version_status=review.get("status", ""),
                cognito_session=self.cognito_session
            )
            inner.addWidget(tasks_widget)

            # Abnahme/Ablehnung Buttons (nur für orderOwner, inReview, active)
            if (
                self.order.get("companyStatus") == "orderOwner"
                and stage == "inReview"
                and status == "active"
            ):
                action_box = QWidget()
                action_box.setStyleSheet("""
                    QWidget {
                        background-color: #f3f4f6;
                        border-radius: 8px;
                        padding: 12px;
                        margin-top: 8px;
                    }
                """)
                action_layout = QVBoxLayout(action_box)

                action_desc = QLabel(
                    "Entspricht der gelieferte Plan dem Auftrag? "
                    "Wurden alle Punkte zu Ihrer Zufriedenheit bearbeitet?"
                )
                action_desc.setWordWrap(True)
                action_desc.setStyleSheet("font-size: 12px; color: #666; margin-bottom: 8px;")
                action_layout.addWidget(action_desc)

                btn_layout = QHBoxLayout()

                reject_btn = QPushButton("Ablehnen")
                reject_btn.setStyleSheet("""
                    QPushButton {
                        background-color: #fff;
                        border: 1px solid #dc2626;
                        color: #dc2626;
                        padding: 8px 16px;
                    }
                    QPushButton:hover {
                        background-color: #dc2626;
                        color: white;
                    }
                """)
                reject_btn.clicked.connect(lambda: self._reject_review(review.get("reviewId", "")))
                btn_layout.addWidget(reject_btn)

                complete_btn = QPushButton("Auftrag abnehmen")
                complete_btn.setStyleSheet("""
                    QPushButton {
                        background-color: #16a34a;
                        border: 1px solid #16a34a;
                        color: white;
                        padding: 8px 16px;
                    }
                    QPushButton:hover {
                        background-color: #15803d;
                    }
                """)
                complete_btn.clicked.connect(lambda: self._complete_review(review.get("reviewId", "")))
                btn_layout.addWidget(complete_btn)

                btn_layout.addStretch()
                action_layout.addLayout(btn_layout)
                inner.addWidget(action_box)

            outer_layout = QVBoxLayout()
            outer_layout.addWidget(inner_widget)
            box.setLayout(outer_layout)
            scroll_layout.addWidget(box)

        scroll_layout.addStretch()
        scroll.setWidget(scroll_content)

        # Splitter
        splitter = QSplitter(Qt.Horizontal)
        splitter.setChildrenCollapsible(False)

        # LEFT SIDE
        left_container = QWidget()
        left_layout = QVBoxLayout(left_container)

        title = QLabel("Abnahmeprotokoll")
        title.setStyleSheet("font-size: 16px; font-weight: bold; padding: 8px;")
        left_layout.addWidget(title)
        left_layout.addWidget(scroll)

        splitter.addWidget(left_container)

        # RIGHT SIDE
        right_container = QWidget()
        right_container.setStyleSheet("background: #fff;")
        right_layout = QVBoxLayout(right_container)
        right_layout.setContentsMargins(8, 8, 8, 8)

        # Detail Box
        details_box = QGroupBox()
        details_box.setStyleSheet("""
            QGroupBox {
                background-color: #fff;
                border-radius: 8px;
                margin: 0px;
                padding: 6px 0px;
            }
        """)
        title2 = QLabel("Auftragsdetails")
        title2.setStyleSheet("font-size: 16px; font-weight: bold; margin-top: 10px; padding: 5px;")
        right_layout.addWidget(title2)

        details_layout = QVBoxLayout(details_box)
        for label_text, value_label in self.detail_labels.items():
            row = QHBoxLayout()
            row.setContentsMargins(0, 0, 0, 0)
            row.addWidget(QLabel(f"{label_text}:"))
            row.addWidget(value_label)
            details_layout.addLayout(row)
        right_layout.addWidget(details_box)

        # Messaging
        if stage in ["contracted", "inDevelopment", "inReview", "completed"]:
            messaging = MessagingWidget(
                cognito_session=self.cognito_session,
                order_id=self.order_id,
                link_id=None,
                link_type="all",
                company_id=self.order.get("companyId", ""),
                stage=stage
            )
            right_layout.addWidget(messaging)
        else:
            right_layout.addWidget(QWidget())

        right_layout.addStretch()

        splitter.addWidget(right_container)

        splitter.setStretchFactor(0, 1)
        splitter.setStretchFactor(1, 1)

        self.dynamic_area.addWidget(splitter)

        QTimer.singleShot(0, lambda: splitter.setSizes([600, 600]))

    def _format_timestamp(self, ts):
        if not ts or ts == "-":
            return "-"
        try:
            dt = datetime.fromtimestamp(int(ts) / 1000)
            return dt.strftime("%d.%m.%Y %H:%M")
        except Exception:
            return str(ts)

    def _verify_password(self, password: str) -> bool:
        """Prüft das Passwort durch einen Test-Login"""
        settings = QgsSettings()
        username = settings.value("xplanung24/api_username", "")

        if not username:
            return False

        try:
            test_session = CognitoSession()
            test_session.login(username, password)
            return True
        except Exception:
            return False

    def _complete_review(self, review_id: str):
        """Nimmt den Auftrag ab nach Passwort-Bestätigung"""
        dlg = PasswordConfirmDialog(
            parent=self,
            action_text="Auftrag abnehmen",
            description="Sie sind dabei, diesen Auftrag abzunehmen. "
                        "Der Auftrag wird damit als abgeschlossen markiert."
        )

        if dlg.exec_() != dlg.Accepted:
            return

        password = dlg.get_password()

        # Passwort prüfen
        if not self._verify_password(password):
            QMessageBox.critical(
                self,
                "Fehler",
                "Das eingegebene Passwort ist falsch."
            )
            return

        # API aufrufen
        try:
            APICompleteOrder(self.cognito_session, self.order_id)
            QMessageBox.information(
                self,
                "Erfolg",
                "Der Auftrag wurde erfolgreich abgenommen."
            )
            self.load_order_details()
        except Exception as e:
            QMessageBox.critical(
                self,
                "Fehler",
                f"Fehler beim Abnehmen des Auftrags: {e}"
            )

    def _reject_review(self, review_id: str):
        """Lehnt den Auftrag ab nach Passwort-Bestätigung"""
        dlg = PasswordConfirmDialog(
            parent=self,
            action_text="Auftrag ablehnen",
            description="Sie sind dabei, diesen Auftrag abzulehnen. "
                        "Der Auftrag wird zurück in Bearbeitung gesetzt."
        )

        if dlg.exec_() != dlg.Accepted:
            return

        password = dlg.get_password()

        # Passwort prüfen
        if not self._verify_password(password):
            QMessageBox.critical(
                self,
                "Fehler",
                "Das eingegebene Passwort ist falsch."
            )
            return

        # API aufrufen
        try:
            APIRejectOrder(self.cognito_session, self.order_id)
            QMessageBox.information(
                self,
                "Erfolg",
                "Der Auftrag wurde abgelehnt und zurück in Bearbeitung gesetzt."
            )
            self.load_order_details()
        except Exception as e:
            QMessageBox.critical(
                self,
                "Fehler",
                f"Fehler beim Ablehnen des Auftrags: {e}"
            )

    def reject_review(self, review_id):
        QMessageBox.information(self, "Abgelehnt", f"Review {review_id} wurde abgelehnt.")
        self.load_order_details()

    def complete_review(self, review_id):
        QMessageBox.information(self, "Abgenommen", f"Review {review_id} wurde abgenommen.")
        self.load_order_details()

    def closeEvent(self, event):
        """Aufräumen beim Schließen."""
        super().closeEvent(event)


def show_order_detail_dock(cognito_session, order_id, plan_id=None):
    """Öffnet das OrderDetailDock (ersetzt oder zeigt es an)."""
    # Prüfe ob bereits ein Dock offen ist
    existing_dock = getattr(iface, '_xplan_order_dock', None)
    if existing_dock:
        try:
            iface.removeDockWidget(existing_dock)
            existing_dock.deleteLater()
        except Exception:
            pass

    # Neues Dock erstellen
    dock = OrderDetailDock(
        cognito_session=cognito_session,
        order_id=order_id,
        plan_id=plan_id
    )

    # Als iface-Attribut speichern
    iface._xplan_order_dock = dock

    # Dock hinzufügen
    iface.addDockWidget(Qt.RightDockWidgetArea, dock)
    dock.show()
    dock.raise_()

    return dock
