"""Order contracts at risk when filters, summary and table receive the blue layout."""

from __future__ import annotations

import os
import socket
from copy import deepcopy
from typing import Any

os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")

import pytest
from PySide6.QtCore import QDate, QPoint, QRect, Qt, QTimer
from PySide6.QtTest import QTest
from PySide6.QtWidgets import QApplication, QLabel

from doctor_workstation.core import PermissionSet
from doctor_workstation.ui.pages import patients as patients_module
from doctor_workstation.ui.pages.patients import PatientOrdersWorkspace, PatientsPage
from doctor_workstation.ui.theme import apply_theme


class _Repository:
    def __init__(self) -> None:
        self.queries: list[dict[str, Any]] = []
        self.rows = [
            {
                "id": 901 + index,
                "order_no": f"PO2026081000{index + 1}",
                "patient_name": name,
                "patient_phone_masked": f"186****482{index}",
                "recipient_phone": f"1860000482{index}",
                "prescription_id": 801 + index,
                "diagnosis_id": 501 + index,
                "amount": 368 + index,
                "effective_amount": 368 + index,
                "prescription_audit_status": 1,
                "payment_slip_audit_status": 1,
                "fulfillment_status": 2,
                "assistant_name": "周医助",
                "doctor_name": "陈医生（演示）",
                "creator_name": "周医助",
                # Source-only values must not fill display fields that are absent.
                "create_time": "2026-09-05 10:15:00",
                "pay_orders": [{"id": 2001 + index, "pay_amount": 368 + index}],
            }
            for index, name in enumerate(("阿青", "林青", "赵青"))
        ]
        self.total = 47
        self.summary = {
            "orders": 47,
            "amount": 12368.5,
            "pending": 8,
            "completed": 9,
            "rejected": 2,
            "rejection_rate": 4.3,
        }

    def patient_orders(self, **query: Any) -> dict[str, Any]:
        self.queries.append(query)
        return {
            "lists": deepcopy(self.rows),
            "count": self.total,
            "extend": {
                "scope": {"label": "测试部门订单范围"},
                "summary": deepcopy(self.summary),
            },
        }

    def list_patients(self, **_query: Any) -> dict[str, Any]:
        return {
            "lists": [{"id": 501, "diagnosis_id": 501, "patient_name": "阿青"}],
            "count": 1,
            "extend": {"scope": {"label": "测试患者范围"}},
        }

    def patient_progress(self, **_query: Any) -> dict[str, Any]:
        return {
            "lists": [],
            "count": 0,
            "extend": {"scope": {"label": "测试面诊范围"}},
        }


def _settle(application: QApplication) -> None:
    for _ in range(3):
        application.processEvents()


def _click(widget, application: QApplication) -> None:
    QTest.mouseClick(widget, Qt.MouseButton.LeftButton)
    _settle(application)


def _rect_in(widget, parent) -> QRect:
    return QRect(widget.mapTo(parent, QPoint()), widget.size())


def _banner_text(workspace: PatientOrdersWorkspace) -> str:
    return " ".join(label.text() for label in workspace.banner.findChildren(QLabel))


@pytest.fixture(scope="module")
def application() -> QApplication:
    application = QApplication.instance() or QApplication([])
    apply_theme(application)
    return application


@pytest.fixture
def workspace_factory(application: QApplication, monkeypatch: pytest.MonkeyPatch):
    def immediate(function: Any, *, on_success=None, on_error=None, on_finished=None):
        try:
            result = function()
        except Exception as error:
            if on_error:
                on_error(error)
            raise
        else:
            if on_success:
                on_success(result)
        finally:
            if on_finished:
                on_finished()

    def reject_network(*_args: Any, **_kwargs: Any):
        pytest.fail("Order visual tests must use only local fixture data")

    monkeypatch.setattr(socket.socket, "connect", reject_network)
    monkeypatch.setattr(socket.socket, "connect_ex", reject_network)
    monkeypatch.setattr(socket, "create_connection", reject_network)
    monkeypatch.setattr(patients_module, "run_async", immediate)
    opened = []

    def create(*, permissions=("*",), width=1270, height=680, page=False):
        repository = _Repository()
        widget = (
            PatientsPage(repository, permissions=PermissionSet(list(permissions)))
            if page
            else PatientOrdersWorkspace(repository, PermissionSet(list(permissions)))
        )
        opened.append(widget)
        widget.resize(width, height)
        widget.show()
        if not page:
            widget.refresh()
        _settle(application)
        return widget, repository

    yield create
    for widget in opened:
        for timer in widget.findChildren(QTimer):
            timer.stop()
        widget.close()
        widget.deleteLater()
    _settle(application)


def test_filter_defaults_and_reset_keep_edited_dates_but_remove_query_limit(
    application: QApplication, workspace_factory
) -> None:
    workspace, repository = workspace_factory()
    default_query = {
        "keyword": "",
        "prescription_audit_status": None,
        "payment_slip_audit_status": None,
        "fulfillment_status": None,
        "start_date": "",
        "end_date": "",
        "page_no": 1,
        "page_size": 15,
    }
    assert repository.queries[0] == default_query
    assert all(query == {**default_query, "page_no": index + 1}
               for index, query in enumerate(repository.queries))
    assert not workspace.use_dates.isChecked()
    assert not workspace.start_date.isEnabled() and not workspace.end_date.isEnabled()
    assert workspace.start_date.date() == QDate.currentDate().addDays(-30)
    assert workspace.end_date.date() == QDate.currentDate()
    assert all(
        combo.currentData() is None
        for combo in (workspace.rx_audit, workspace.pay_audit, workspace.fulfillment)
    )

    before_filters = len(repository.queries)
    workspace.keyword_edit.setText("  林医生  ")
    workspace.rx_audit.setCurrentIndex(workspace.rx_audit.findData(2))
    workspace.pay_audit.setCurrentIndex(workspace.pay_audit.findData(0))
    workspace.fulfillment.setCurrentIndex(workspace.fulfillment.findData(9))
    assert len(repository.queries) == before_filters  # Changing status does not auto-submit.
    _click(workspace.use_dates, application)
    assert workspace.start_date.isEnabled() and workspace.end_date.isEnabled()
    start, end = QDate(2026, 7, 3), QDate(2026, 8, 8)
    workspace.start_date.setDate(start)
    workspace.end_date.setDate(end)
    _click(workspace.search_button, application)
    assert repository.queries[before_filters] == {
        **default_query,
        "keyword": "林医生",
        "prescription_audit_status": 2,
        "payment_slip_audit_status": 0,
        "fulfillment_status": 9,
        "start_date": "2026-07-03",
        "end_date": "2026-08-08",
    }

    workspace.pager.load_more()
    assert repository.queries[-1]["page_no"] == 2
    assert repository.queries[-1]["page_size"] == 15
    workspace.keyword_edit.setText("新检索")
    QTest.keyClick(workspace.keyword_edit, Qt.Key.Key_Return)
    _settle(application)
    assert next(query for query in repository.queries if query["keyword"] == "新检索")["page_no"] == 1
    workspace.start_date.setDate(end.addDays(1))
    before = len(repository.queries)
    _click(workspace.search_button, application)
    assert len(repository.queries) == before
    assert workspace.banner.isVisible()
    assert "开始日期不能晚于结束日期" in _banner_text(workspace)

    _click(workspace.reset_button, application)
    assert repository.queries[-1] == {**default_query, "page_no": repository.queries[-1]["page_no"]}
    assert workspace.keyword_edit.text() == ""
    assert not workspace.use_dates.isChecked()
    assert not workspace.start_date.isEnabled() and not workspace.end_date.isEnabled()
    assert workspace.start_date.date() == end.addDays(1)
    assert workspace.end_date.date() == end
    assert not workspace.banner.isVisible()


def test_twelve_columns_keep_source_text_distinct_ids_and_missing_display_fields(
    application: QApplication, workspace_factory
) -> None:
    workspace, repository = workspace_factory()
    row = repository.rows[0]
    row["order_no"] = "PO-非常长的订单号-20260905-ABCDEFGHIJ"
    row["patient_name"] = "用于检查省略与提示的较长患者姓名"
    row["doctor_name"] = "用于检查分行显示与完整提示信息的开方医生（演示）"
    workspace.refresh()
    _settle(application)
    table = workspace.table
    assert [table.horizontalHeaderItem(column).text() for column in range(table.columnCount())] == [
        "订单",
        "患者",
        "处方 / 诊单",
        "有效金额",
        "处方审核",
        "支付审核",
        "履约",
        "支付单",
        "归属助理",
        "开方人",
        "创建人",
        "创建时间",
    ]
    index = next(
        index
        for index in range(table.rowCount())
        if table.item(index, 0).data(Qt.ItemDataRole.UserRole)["id"] == 901
    )
    assert table.item(index, 0).text() == f"{row['order_no']} · #901"
    assert table.item(index, 1).text() == f"{row['patient_name']} · 186****4820"
    assert table.item(index, 2).text() == "#801 / #501"
    assert table.item(index, 9).text() == row["doctor_name"]
    assert table.item(index, 0).toolTip() == table.item(index, 0).text()
    assert table.item(index, 1).toolTip() == table.item(index, 1).text()
    assert table.item(index, 9).toolTip() == row["doctor_name"]
    assert table.item(index, 7).text() == "—"
    assert table.item(index, 11).text() == "—"
    for column in range(12):
        assert not table.isColumnHidden(column)
        assert table.item(index, column).data(Qt.ItemDataRole.UserRole) == row
        assert row["recipient_phone"] not in table.item(index, column).text()


def test_sorted_selection_buttons_and_menu_emit_current_order_resource_ids(
    application: QApplication, workspace_factory
) -> None:
    workspace, _repository = workspace_factory()
    table = workspace.table
    emitted = []
    workspace.diagnosis_requested.connect(lambda row: emitted.append(("diagnosis", row)))
    workspace.detail_requested.connect(lambda row: emitted.append(("detail", row)))
    workspace.action_requested.connect(lambda key, row: emitted.append((key, row)))
    table.sortItems(0, Qt.SortOrder.AscendingOrder)
    first_id = table.item(0, 0).data(Qt.ItemDataRole.UserRole)["id"]
    table.sortItems(0, Qt.SortOrder.DescendingOrder)
    _settle(application)
    assert table.item(0, 0).data(Qt.ItemDataRole.UserRole)["id"] != first_id
    for index in (0, 2, 1):
        table.selectRow(index)
        _settle(application)
        expected = table.item(index, 0).data(Qt.ItemDataRole.UserRole)
        workspace.diagnosis_button.click()
        workspace.detail_button.click()
        next(
            action for action in workspace.action_menu.actions() if action.text() == "确认发货"
        ).trigger()
        assert [kind for kind, _row in emitted[-3:]] == ["diagnosis", "detail", "ship"]
        for _kind, row in emitted[-3:]:
            assert (row["id"], row["prescription_id"], row["diagnosis_id"]) == (
                expected["id"],
                expected["prescription_id"],
                expected["diagnosis_id"],
            )


@pytest.mark.parametrize(
    ("permissions", "menu", "detail"),
    [
        (("*",), ["撤回支付审核", "修改快递单号", "确认发货", "上传药房"], True),
        (("tcm.prescriptionOrder/detail",), [], True),
        (("tcm.prescriptionOrder/ship",), ["确认发货"], False),
        (("tcm.prescriptionOrder.detail", "tcm.prescriptionOrder.ship"), [], False),
        ((), [], False),
    ],
)
def test_selected_order_menu_requires_canonical_permissions(
    application: QApplication, workspace_factory, permissions, menu, detail
) -> None:
    workspace, _repository = workspace_factory(permissions=permissions)
    assert [action.text() for action in workspace.action_menu.actions()] == menu
    assert workspace.action_button.isVisible() is bool(menu)
    assert workspace.detail_button.isVisible() is detail
    assert workspace.diagnosis_button.isEnabled()
    emitted = []
    workspace.detail_requested.connect(lambda row: emitted.append(row["id"]))
    workspace._request_detail()  # The double-click path also checks permission.
    assert bool(emitted) is detail
    workspace.permissions = PermissionSet([])
    workspace._selection_changed()
    _settle(application)
    assert workspace.action_menu.actions() == []
    assert not workspace.action_button.isVisible()
    assert not workspace.detail_button.isVisible()


@pytest.mark.parametrize(
    ("rx", "pay", "fulfillment", "rx_text", "pay_text", "state", "exclusion"),
    [
        (0, 1, 4, "待审核", "已通过", "已取消", "已取消不计入"),
        (1, 2, 9, "已通过", "已驳回", "拒收", "拒收不计入"),
        (2, 0, 10, "已驳回", "待审核", "退款", "退款不计入"),
        (1, 1, 6, "已通过", "已通过", "已签收", ""),
    ],
)
def test_amount_exclusion_reasons_and_independent_status_text_survive_rendering(
    application: QApplication,
    workspace_factory,
    rx,
    pay,
    fulfillment,
    rx_text,
    pay_text,
    state,
    exclusion,
) -> None:
    workspace, repository = workspace_factory()
    repository.rows = [
        {
            **repository.rows[0],
            "prescription_audit_status": rx,
            "payment_slip_audit_status": pay,
            "fulfillment_status": fulfillment,
            "amount_included": not bool(exclusion),
            "amount_exclusion_text": exclusion,
            "effective_amount": 12368.5,
        }
    ]
    workspace.refresh()
    _settle(application)
    assert workspace.table.item(0, 3).text() == (exclusion or "¥12,368.50")
    assert [workspace.table.item(0, column).text() for column in (4, 5, 6)] == [
        rx_text,
        pay_text,
        state,
    ]
    if fulfillment == 6:
        refund = next(
            action for action in workspace.action_menu.actions() if action.text() == "退款"
        )
        assert refund.property("danger") is True


def test_summary_uses_response_scope_and_legacy_aliases_without_recomputing_rows(
    application: QApplication, workspace_factory
) -> None:
    workspace, repository = workspace_factory()
    assert {key: label.text() for key, label in workspace.metrics.items()} == {
        "orders": "47",
        "amount": "¥12,368.50",
        "pending": "8",
        "completed": "9",
        "rejected": "2",
        "rejection_rate": "4.3%",
    }
    assert workspace.scope_label.text() == "测试部门订单范围"
    assert workspace.pager.total == 47
    assert workspace.pager.page_size == 15
    assert workspace.pager.height() == 24
    # Preserve the existing ratio compatibility, including its known ambiguity.
    repository.summary = {
        "order_count": 20,
        "effective_amount": 700.25,
        "pending_audit": 3,
        "completed": 4,
        "rejected": 1,
        "rejection_rate": 0.05,
    }
    workspace.refresh()
    _settle(application)
    assert {key: label.text() for key, label in workspace.metrics.items()} == {
        "orders": "20",
        "amount": "¥700.25",
        "pending": "3",
        "completed": "4",
        "rejected": "1",
        "rejection_rate": "5.0%",
    }
    before = len(repository.queries)
    for metric in workspace.metrics.values():
        _click(metric, application)
    assert len(repository.queries) == before  # The six metrics are read-only.


@pytest.mark.parametrize("silent", [False, True])
def test_loading_freezes_queries_resets_rows_and_ignores_stale_success_and_failure(
    application: QApplication, workspace_factory, monkeypatch: pytest.MonkeyPatch, silent: bool
) -> None:
    workspace, repository = workspace_factory()
    table = workspace.table
    queued = []
    monkeypatch.setattr(
        patients_module,
        "run_async",
        lambda function, **callbacks: queued.append((function, callbacks)),
    )
    workspace.keyword_edit.setText("旧请求")
    workspace.refresh(silent=silent)
    workspace.keyword_edit.setText("最新请求")
    workspace.rx_audit.setCurrentIndex(workspace.rx_audit.findData(2))
    workspace.pay_audit.setCurrentIndex(workspace.pay_audit.findData(0))
    workspace.fulfillment.setCurrentIndex(workspace.fulfillment.findData(9))
    workspace.use_dates.setChecked(True)
    workspace.start_date.setDate(QDate(2026, 7, 1))
    workspace.end_date.setDate(QDate(2026, 8, 1))
    workspace.refresh(silent=silent)
    _settle(application)
    assert table.rowCount() == 0
    assert workspace.content_stack.currentIndex() == 1
    assert workspace.pager.isVisible()
    assert not workspace.banner.isVisible()

    workspace.keyword_edit.setText("尚未提交")
    workspace.rx_audit.setCurrentIndex(0)
    workspace.use_dates.setChecked(False)
    newer = queued[1][0]()
    assert repository.queries[-1] == {
        "keyword": "最新请求",
        "prescription_audit_status": 2,
        "payment_slip_audit_status": 0,
        "fulfillment_status": 9,
        "start_date": "2026-07-01",
        "end_date": "2026-08-01",
        "page_no": 1,
        "page_size": 15,
    }
    newer["extend"]["scope"]["label"] = "最新范围"
    queued[1][1]["on_success"](newer)
    current_item = table.item(0, 0)
    stale = queued[0][0]()
    assert repository.queries[-1]["keyword"] == "旧请求"
    queued[0][1]["on_success"](stale)
    queued[0][1]["on_error"](RuntimeError("过期失败"))
    _settle(application)
    assert table.item(0, 0) is current_item
    assert workspace.scope_label.text() == "最新范围"
    assert not workspace.banner.isVisible()

    workspace.keyword_edit.setText("最新请求")
    workspace.rx_audit.setCurrentIndex(workspace.rx_audit.findData(2))
    workspace.use_dates.setChecked(True)
    workspace.refresh(silent=silent)
    queued[-1][1]["on_error"](RuntimeError("订单查询失败"))
    _settle(application)
    assert table.item(0, 0) is current_item
    assert workspace.metrics["orders"].text() == "47"
    assert workspace.banner.isVisible()
    assert "订单查询失败" in _banner_text(workspace)
    workspace.refresh(silent=silent)
    queued[-1][1]["on_success"]({"lists": [], "count": 0})
    _settle(application)
    assert table.rowCount() == 0
    assert workspace.content_stack.currentIndex() == 1
    assert "当前范围内暂无订单" in " ".join(
        label.text() for label in workspace.content_stack.currentWidget().findChildren(QLabel)
    )
    assert not workspace.diagnosis_button.isEnabled()
    assert not workspace.detail_button.isEnabled()
    assert workspace.action_menu.actions() == []
    assert workspace.pager.total == 0
    assert workspace.metrics["orders"].text() == "0"
    assert workspace.metrics["amount"].text() == "¥0.00"
    assert not workspace.banner.isVisible()


@pytest.mark.parametrize(("width", "height"), [(1270, 680), (1014, 490), (760, 380)])
def test_layout_keeps_filters_actions_and_load_status_reachable_at_narrow_viewports(
    application: QApplication, workspace_factory, width: int, height: int
) -> None:
    workspace, _repository = workspace_factory(width=width, height=height)
    table = workspace.table
    assert workspace.size().width() == width
    assert workspace.size().height() == height
    assert table.columnCount() == 12
    assert table.horizontalHeader().height() == 46
    assert all(table.rowHeight(index) == 68 for index in range(table.rowCount()))
    assert table.font().pixelSize() == 14
    assert workspace.scope_label.font().pixelSize() == 13
    assert all(metric.font().pixelSize() == 18 for metric in workspace.metrics.values())
    for widget in (
        workspace.keyword_edit,
        workspace.rx_audit,
        workspace.pay_audit,
        workspace.fulfillment,
        workspace.search_button,
        workspace.reset_button,
        workspace.use_dates,
        workspace.start_date,
        workspace.end_date,
    ):
        assert widget.isVisibleTo(workspace)
        assert workspace.filter_card.rect().contains(_rect_in(widget, workspace.filter_card))
    for metric in workspace.metrics.values():
        assert workspace.summary_strip.rect().contains(_rect_in(metric, workspace.summary_strip))
    if width == 1270:
        assert workspace.filter_card.height() == 132
        assert workspace.summary_strip.height() == 96
    if width == 760:
        assert workspace.filter_card.height() == 184
        assert (
            len(
                {
                    metric.mapTo(workspace.summary_strip, QPoint()).y()
                    for metric in workspace.metrics.values()
                }
            )
            == 2
        )
        assert table.horizontalScrollBar().maximum() > 0
        assert workspace.scroll.verticalScrollBar().maximum() > 0

    for host in (
        workspace.filter_card,
        workspace.summary_strip,
        workspace.action_bar,
        workspace.pager,
    ):
        workspace.scroll.ensureWidgetVisible(host, 0, 0)
        _settle(application)
        assert (
            workspace.scroll.viewport().rect().contains(_rect_in(host, workspace.scroll.viewport()))
        ), host.objectName()
    for button in (workspace.diagnosis_button, workspace.detail_button, workspace.action_button):
        assert workspace.action_bar.rect().contains(_rect_in(button, workspace.action_bar))
    assert workspace.pager.height() == 24
    for widget in (workspace.pager.summary_label,):
        assert workspace.pager.rect().contains(_rect_in(widget, workspace.pager))
    table.horizontalScrollBar().setValue(table.horizontalScrollBar().maximum())
    table.scrollToBottom()
    _settle(application)
    assert table.columnViewportPosition(11) >= 0
    assert table.columnViewportPosition(11) + table.columnWidth(11) <= table.viewport().width()
    assert table.rowViewportPosition(2) + table.rowHeight(2) <= table.viewport().height()


def test_tab_switches_keep_patient_styles_scope_deduplication_and_progress_timer(
    application: QApplication, workspace_factory
) -> None:
    page, _repository = workspace_factory(width=1328, height=884, page=True)
    patient = page.patient_workspace
    progress = page.progress_workspace
    patient_style = patient.styleSheet()
    assert patient.table.objectName() == "PatientTable"
    assert patient.table.columnCount() == 10
    assert patient.table.rowHeight(0) == 66
    assert patient.table.horizontalHeader().height() == 42
    assert patient.table.font().pixelSize() == 14
    assert not page.scope_badge.isVisible()
    assert not patient.search_toolbar.isVisible()
    page.filter_disclosure.set_expanded(True)
    _settle(application)
    assert patient.search_toolbar.isVisible()
    assert not progress.timer.isActive()
    page.tabs.setCurrentIndex(2)
    _settle(application)
    progress_style = progress.styleSheet()
    progress_table_font = progress.schedule_table.font()
    progress_metric_font = progress.overview["total"][0].font()
    assert progress.timer.interval() == 15_000
    assert progress.timer.isActive()
    assert not page.scope_badge.isVisible()
    assert not progress.scope_label.isVisible()
    page.filter_disclosure.set_expanded(True)
    _settle(application)
    assert progress.scope_label.isVisible()
    assert progress_table_font.pixelSize() == 14
    assert progress_metric_font.pixelSize() == 18
    assert progress.schedule_table.rowCount() == 7
    assert progress.schedule_table.columnCount() == 7

    page.tabs.setCurrentIndex(1)
    _settle(application)
    assert not progress.timer.isActive()
    assert not page.scope_badge.isVisible()
    assert not patient.search_toolbar.isVisible()
    assert page.order_workspace.scope_label.isVisible()
    assert page.order_workspace.scope_label.text() == "测试部门订单范围"
    assert patient.styleSheet() == patient_style
    assert progress.styleSheet() == progress_style
    assert progress.schedule_table.font() == progress_table_font
    assert progress.overview["total"][0].font() == progress_metric_font
    assert patient.table.rowHeight(0) == 66
    assert patient.table.horizontalHeader().height() == 42

    page.tabs.setCurrentIndex(0)
    _settle(application)
    assert patient.search_toolbar.isVisible()
    assert not page.scope_badge.isVisible()
    assert not progress.timer.isActive()
    page.tabs.setCurrentIndex(2)
    _settle(application)
    assert not page.scope_badge.isVisible()
    assert progress.scope_label.isVisible()
    assert progress.timer.isActive()
    page.hide()
    _settle(application)
    assert not progress.timer.isActive()
    page.show()
    _settle(application)
    assert progress.timer.isActive()