Order-Manager/app/workers.py

"""
Background work that shouldn't run on the GUI thread.

FetchOrdersWorker runs a service's fetch_orders() call off the main
thread and reports back via a signal. As we add more long-running
operations (pushing to Odoo, etc.) they should follow this same
pattern rather than blocking the UI.
"""
from __future__ import annotations

import datetime as dt
import uuid
from typing import List, Tuple, TypedDict

from PyQt6.QtCore import QThread, pyqtSignal
from sqlalchemy import select, delete

from app import config
from app.database import get_session
from app.models import Order
from app.schedule import get_cutoff_time, is_past_cutoff_today
from app.services.base import OrderService, NormalizedOrder
from app.status_rules import get_active_statuses, get_cancelled_statuses, status_in
from app.tracking import get_fulfilled_statuses


class StatusChange(TypedDict):
    ticket_number: str
    old_status: str
    new_status: str


class SaveResult(TypedDict):
    new_count: int
    updated_count: int
    status_changes: List[StatusChange]
    enriched_count: int  # tickets that got tracking numbers merged in
    unmatched_tracking_tickets: List[str]  # tracking data with no matching local ticket


class SendToShipStationWorker(QThread):
    """Runs the emergency ShipStation API send off the GUI thread."""

    finished_ok = pyqtSignal(dict)  # the created shipment's JSON
    failed = pyqtSignal(str)

    def __init__(self, order, parent=None):
        super().__init__(parent)
        self.order = order

    def run(self) -> None:
        from app.services.shipstation_send import send_order_to_shipstation_api, ShipStationSendError

        try:
            result = send_order_to_shipstation_api(self.order)
        except ShipStationSendError as exc:
            self.failed.emit(str(exc))
            return
        except Exception as exc:  # noqa: BLE001
            self.failed.emit(f"Unexpected error sending to ShipStation: {exc}")
            return

        self.finished_ok.emit(result)


class CreateDummyShipmentWorker(QThread):
    """Runs step 1 (dummy outbound shipment creation) off the GUI thread."""

    finished_ok = pyqtSignal(dict)  # the created dummy label's JSON
    failed = pyqtSignal(str)

    def __init__(self, order, parent=None):
        super().__init__(parent)
        self.order = order

    def run(self) -> None:
        from app.services.shipstation_send import create_dummy_shipment, ShipStationSendError

        try:
            result = create_dummy_shipment(self.order)
        except ShipStationSendError as exc:
            self.failed.emit(str(exc))
            return
        except Exception as exc:  # noqa: BLE001
            self.failed.emit(f"Unexpected error creating dummy shipment: {exc}")
            return

        self.finished_ok.emit(result)


class CreateReturnLabelWorker(QThread):
    """Runs step 2 (the real return label, from an already-created dummy)
    off the GUI thread."""

    finished_ok = pyqtSignal(dict)  # the created label's JSON
    failed = pyqtSignal(str)

    def __init__(self, order, dummy_label_id: str, packages: list[dict], charge_event: str, parent=None):
        super().__init__(parent)
        self.order = order
        self.dummy_label_id = dummy_label_id
        self.packages = packages
        self.charge_event = charge_event

    def run(self) -> None:
        from app.services.shipstation_send import create_return_label_from_dummy, ShipStationSendError

        try:
            result = create_return_label_from_dummy(
                self.order, self.dummy_label_id, self.packages, self.charge_event
            )
        except ShipStationSendError as exc:
            self.failed.emit(str(exc))
            return
        except Exception as exc:  # noqa: BLE001
            self.failed.emit(f"Unexpected error creating return label: {exc}")
            return

        self.finished_ok.emit(result)


class FetchOrdersWorker(QThread):
    """Fetches orders from a given service and saves/merges the results."""

    finished_ok = pyqtSignal(object)  # emits a SaveResult
    failed = pyqtSignal(str)

    def __init__(self, service: OrderService, parent=None):
        super().__init__(parent)
        self.service = service

    def run(self) -> None:
        try:
            orders = self.service.fetch_orders()
        except Exception as exc:  # noqa: BLE001 - surface any failure to the UI
            self.failed.emit(str(exc))
            return

        try:
            result = save_orders(orders)
        except Exception as exc:  # noqa: BLE001
            self.failed.emit(f"Fetched {len(orders)} orders but failed to save them: {exc}")
            return

        self.finished_ok.emit(result)


def save_orders(orders: List[NormalizedOrder]) -> SaveResult:
    """
    JIRA-sourced orders are inserted/updated as usual. ShipStation-sourced
    "orders" are actually just tracking-number bundles keyed by ticket
    number - rather than creating a second row, they get merged onto the
    existing JIRA row for that ticket. If no such row exists locally yet,
    the ticket number is reported back as unmatched instead of silently
    dropped.

    Whenever a JIRA ticket's status transitions INTO a fulfilled status
    (Waiting For Return / Device Return Not Needed), fulfilled_at is
    stamped - that's what lets the dashboard show "fulfilled today" and
    what moves it into the Done pile. cancelled_at works the same way for
    CANCELLED_STATUSES - it's what limits the Cancelled tab to "cancelled
    today" rather than showing every cancelled ticket ever.

    These get stamped with dt.datetime.now() (LOCAL time), not utcnow() -
    deliberately, since every "is this today" check elsewhere compares
    against dt.date.today() (also local). Mixing the two caused a real
    bug: a ticket cancelled in the evening in a US timezone would get a
    UTC timestamp that had already rolled into tomorrow, failing the
    same-day check immediately and landing on Done instead of Cancelled.
    """
    session = get_session()
    new_count = 0
    updated_count = 0
    enriched_count = 0
    status_changes: List[StatusChange] = []
    unmatched_tracking_tickets: List[str] = []
    fulfilled_statuses = get_fulfilled_statuses()
    cancelled_statuses = get_cancelled_statuses()

    try:
        for order in orders:
            if order["source"] == "shipstation":
                jira_row = session.execute(
                    select(Order).where(
                        Order.source == "jira",
                        Order.ticket_number == order["ticket_number"],
                    )
                ).scalar_one_or_none()

                if jira_row is None:
                    unmatched_tracking_tickets.append(order["ticket_number"])
                    continue

                jira_row.tracking_numbers = order.get("tracking_numbers", [])
                if order.get("shipping_method"):
                    jira_row.shipping_method = order["shipping_method"]
                enriched_count += 1
                continue

            # source == "jira"
            existing = session.execute(
                select(Order).where(
                    Order.source == order["source"],
                    Order.external_id == order["external_id"],
                )
            ).scalar_one_or_none()

            new_status = order["status"]

            if existing is None:
                session.add(
                    Order(
                        source=order["source"],
                        external_id=order["external_id"],
                        ticket_number=order.get("ticket_number"),
                        company=order.get("company", "Unknown"),
                        skus=order.get("skus", []),
                        line_items=order.get("line_items", []),
                        shipping_info=order.get("shipping_info", {}),
                        creator=order.get("creator"),
                        assignee=order.get("assignee"),
                        description=order.get("description"),
                        tracking_numbers=order.get("tracking_numbers", []),
                        summary=order["summary"],
                        status=new_status,
                        source_created_at=order["source_created_at"],
                        raw_data=order["raw_data"],
                        fulfilled_at=(
                            dt.datetime.now() if status_in(new_status, fulfilled_statuses) else None
                        ),
                        cancelled_at=(
                            dt.datetime.now() if status_in(new_status, cancelled_statuses) else None
                        ),
                    )
                )
                new_count += 1
            else:
                old_status = existing.status
                if old_status != new_status:
                    status_changes.append(
                        StatusChange(
                            ticket_number=existing.ticket_number or existing.external_id,
                            old_status=old_status,
                            new_status=new_status,
                        )
                    )
                    if status_in(new_status, fulfilled_statuses) and not status_in(
                        old_status, fulfilled_statuses
                    ):
                        existing.fulfilled_at = dt.datetime.now()
                    if status_in(new_status, cancelled_statuses) and not status_in(
                        old_status, cancelled_statuses
                    ):
                        existing.cancelled_at = dt.datetime.now()

                existing.ticket_number = order.get("ticket_number")
                existing.company = order.get("company", "Unknown")
                existing.skus = order.get("skus", [])
                existing.line_items = order.get("line_items", [])
                existing.shipping_info = order.get("shipping_info", {})
                existing.creator = order.get("creator")
                existing.assignee = order.get("assignee")
                existing.description = order.get("description")
                existing.summary = order["summary"]
                existing.status = new_status
                existing.source_created_at = order["source_created_at"]
                existing.raw_data = order["raw_data"]
                updated_count += 1

        session.commit()
    finally:
        session.close()

    return SaveResult(
        new_count=new_count,
        updated_count=updated_count,
        status_changes=status_changes,
        enriched_count=enriched_count,
        unmatched_tracking_tickets=unmatched_tracking_tickets,
    )


def reset_local_database() -> int:
    """
    Wipes every locally cached order. This is a rebuildable cache, not a
    system of record - JIRA is - so this is always safe, just requires
    re-running Import from JIRA (and Pull Tracking Numbers) afterward.

    Also the real fix for one specific situation: a ticket that
    transitioned status under an older, buggy version of this app can end
    up with a permanently-wrong fulfilled_at/cancelled_at timestamp, since
    those are only recalculated ON a transition - re-importing an
    already-transitioned ticket finds "no change" and never touches it
    again. A reset clears that stale timestamp entirely; the fresh
    re-import then stamps everything correctly from scratch.
    """
    session = get_session()
    try:
        result = session.execute(delete(Order))
        session.commit()
        return result.rowcount or 0
    finally:
        session.close()


def _emailed_label_sku_for_company(company: str) -> str:
    """Picks whichever configured EMAILED_LABEL_SKUS entry actually
    resolves to the given company via COMPANY_SKU_MAP, rather than
    hardcoding SH007/OK012 - stays correct if either setting changes."""
    from app.companies import parse_mapping, resolve_company_by_sku
    from app.return_labels import get_emailed_label_skus

    sku_map = parse_mapping(config.get("COMPANY_SKU_MAP", config.DEFAULT_COMPANY_SKU_MAP))
    for sku in sorted(get_emailed_label_skus()):
        if resolve_company_by_sku(sku, sku_map) == company:
            return sku.upper()
    return ""


def create_test_shipment_order(company: str) -> Order:
    """
    Creates a synthetic, non-JIRA Order row carrying that company's
    configured emailed-return-label SKU, purely so the existing "Create
    Return Label" flow (return_label_dialog.py + shipstation_send.py) can
    be exercised end-to-end - dummy shipment, then real return label -
    against a throwaway ticket instead of risking a real customer's.

    source="test" keeps this completely separate from real JIRA rows:
    save_orders() only ever matches on source == "jira"/"shipstation", so
    Import from JIRA can never touch or overwrite one of these, and
    delete_test_shipments() cleans them up by that same marker.

    status="Created" so it lands on the Active tab like a real open
    ticket would - that's where staff would naturally go to select it and
    run Create Return Label.
    """
    sku = _emailed_label_sku_for_company(company)
    if not sku:
        raise ValueError(
            f"No EMAILED_LABEL_SKUS entry resolves to '{company}' via COMPANY_SKU_MAP - "
            "check both settings."
        )

    ticket_number = f"TEST-EMAIL-{uuid.uuid4().hex[:8].upper()}"

    order = Order(
        source="test",
        external_id=ticket_number,
        ticket_number=ticket_number,
        company=company,
        skus=[sku],
        line_items=[{"sku": sku, "item_name": "TEST - Emailed Return Label"}],
        shipping_info={
            "name": "TEST ORDER - DO NOT SHIP",
            "phone": "555-555-5555",
            "email": "",
            "address1": "123 Test St",
            "address2": "",
            "city": "Austin",
            "state": "TX",
            "zip": "78701",
        },
        creator="Test Shipment Generator",
        assignee="",
        description=(
            "Synthetic test order created via Data > Create Test Shipment (Email SKU) - "
            "not a real ticket. Safe to delete with Data > Delete Test Shipments."
        ),
        summary=f"TEST - Emailed Return Label ({company})",
        status="Created",
        source_created_at=dt.datetime.now(),
    )

    session = get_session()
    try:
        session.add(order)
        session.commit()
    finally:
        session.close()

    return order


def delete_test_shipments() -> int:
    """Removes every synthetic order created by create_test_shipment_order()
    (source == "test") - real JIRA-sourced rows are untouched, since those
    always have source == "jira"."""
    session = get_session()
    try:
        result = session.execute(delete(Order).where(Order.source == "test"))
        session.commit()
        return result.rowcount or 0
    finally:
        session.close()


def load_all_orders() -> List[Order]:
    session = get_session()
    try:
        return list(
            session.execute(select(Order).order_by(Order.source_created_at.desc())).scalars()
        )
    finally:
        session.close()


def split_orders_by_view(orders: List[Order]) -> Tuple[List[Order], List[Order], List[Order]]:
    """
    Three tabs, allowlist-driven:
      - Active: status is in ACTIVE_STATUSES (just "Created" by default) -
        the only tickets that represent real work still to do.
      - Cancelled: status is in CANCELLED_STATUSES AND it was cancelled
        TODAY. A ticket cancelled on a prior day falls through to Done
        instead - the Cancelled tab is meant to be reviewed same-day and
        then filed away, not accumulate forever.
      - Done: everything else. This deliberately doesn't enumerate every
        "finished" status by name - a JIRA-side automation status like
        "1st Contact Attempt" falls in here automatically just by not
        being Created or (today's) Cancelled, with no code change needed
        when your JIRA workflow adds another downstream status later.
    """
    active_statuses = get_active_statuses()
    cancelled_statuses = get_cancelled_statuses()
    today = dt.date.today()
    active, cancelled, done = [], [], []
    for order in orders:
        if status_in(order.status, active_statuses):
            active.append(order)
        elif (
            status_in(order.status, cancelled_statuses)
            and order.cancelled_at
            and order.cancelled_at.date() == today
        ):
            cancelled.append(order)
        else:
            done.append(order)
    return active, cancelled, done


def load_orders_by_view() -> Tuple[List[Order], List[Order], List[Order]]:
    return split_orders_by_view(load_all_orders())


def mark_shipstation_sent(ticket_number: str) -> None:
    """Stamps shipstation_sent_at after a CONFIRMED emergency API send -
    called once ShipStation's own response confirms creation succeeded.

    Matches by ticket_number alone, not source == "jira" - source is only
    ever "jira" or "test" (synthetic tickets from create_test_shipment_order()),
    and ticket_number is already unique across both, so restricting to "jira"
    here just means this silently no-ops for test tickets instead of erroring."""
    session = get_session()
    try:
        order = session.execute(
            select(Order).where(Order.ticket_number == ticket_number)
        ).scalar_one_or_none()
        if order is not None:
            order.shipstation_sent_at = dt.datetime.now()
            session.commit()
    finally:
        session.close()


def save_dummy_outbound_label_id(ticket_number: str, label_id: str) -> None:
    """Persists step 1's result (the dummy shipment's label_id) so step 2
    (the real return label) can be triggered separately - including in a
    later session, after the dummy has been verified in ShipStation.

    Matches by ticket_number alone - see mark_shipstation_sent() above for why
    this must not be restricted to source == "jira"."""
    session = get_session()
    try:
        order = session.execute(
            select(Order).where(Order.ticket_number == ticket_number)
        ).scalar_one_or_none()
        if order is not None:
            order.dummy_outbound_label_id = label_id
            session.commit()
    finally:
        session.close()


def save_pack_data(ticket_number: str, serial_numbers: dict, packed: bool) -> None:
    """
    Saves serial numbers and the packed/done flag from the Pack Ticket
    dialog. Staff-entered data, not sourced from JIRA - this is the
    beginning of the eventual end-of-day push back to JIRA (deferred for
    now), so nothing here gets overwritten by a JIRA re-import.

    Matches by ticket_number alone, not source == "jira" - see
    mark_shipstation_sent() for why.
    """
    session = get_session()
    try:
        order = session.execute(
            select(Order).where(Order.ticket_number == ticket_number)
        ).scalar_one_or_none()
        if order is None:
            return
        order.serial_numbers = serial_numbers
        was_packed = order.packed
        order.packed = packed
        if packed and not was_packed:
            order.packed_at = dt.datetime.now()
        elif not packed:
            order.packed_at = None
        session.commit()
    finally:
        session.close()


def get_dashboard_stats() -> dict:
    """
    Counts for the dashboard. "Active Orders" and the company breakdown
    reflect only the Active tab (status in ACTIVE_STATUSES) - the actual
    at-hand workload. Cancelled counts the Cancelled tab. Fulfilled-today
    and past-cutoff-today look across ALL of today's tickets regardless
    of which tab they ended up in, since both are about what happened
    today specifically.

    Carryover counts any Active ticket that's already known to spill
    into tomorrow - either it's genuinely left over from a prior day, or
    it arrived today but after the cutoff (same effect, just known a day
    earlier). Since we're only looking at the Active bucket, every
    ticket here is by definition still unresolved - no separate "is it
    still open" check needed.
    """
    orders = load_all_orders()
    active_orders, cancelled_orders, _done_orders = split_orders_by_view(orders)

    cutoff = get_cutoff_time()
    today = dt.date.today()

    by_company: dict[str, int] = {}
    carryover_count = 0
    tracking_received_count = 0

    for order in active_orders:
        by_company[order.company] = by_company.get(order.company, 0) + 1

        if order.tracking_numbers:
            tracking_received_count += 1

        created_before_today = bool(
            order.source_created_at and order.source_created_at.date() < today
        )
        # A ticket that arrived today but after the cutoff won't get worked
        # today either - it's known carryover before the date even rolls
        # over, not just once tomorrow arrives.
        if created_before_today or is_past_cutoff_today(order.source_created_at, cutoff):
            carryover_count += 1

    fulfilled_today_count = sum(
        1 for o in orders if o.fulfilled_at and o.fulfilled_at.date() == today
    )
    past_cutoff_today_count = sum(
        1 for o in orders if is_past_cutoff_today(o.source_created_at, cutoff)
    )

    return {
        "total": len(active_orders),
        "by_company": by_company,
        "cancelled_count": len(cancelled_orders),
        "carryover_count": carryover_count,
        "tracking_received_count": tracking_received_count,
        "fulfilled_today_count": fulfilled_today_count,
        "past_cutoff_today_count": past_cutoff_today_count,
    }