# Copyright (c) 2026 Patrick Motsch
# All rights reserved.
"""Incremental Redmine -> ``poweron_redmine`` mirror sync.

Strategy:
- **Full sync** when ``RedmineInstanceConfig.lastSyncAt`` is None or
  ``force=True`` is requested. Pulls every issue with ``status_id=*``
  (open + closed) for the configured project, paginated.
- **Incremental sync** otherwise. Pulls only issues whose ``updated_on``
  is greater than ``lastSyncAt - overlapSeconds`` (default 1h overlap to
  catch clock skew and missed updates).
- Each issue is upserted into ``RedmineTicketMirror`` (looked up by
  ``(featureInstanceId, redmineId)``).
- The full set of relations attached to each issue replaces any existing
  relation rows for that issue in ``RedmineRelationMirror``.

Concurrency: a per-instance ``asyncio.Lock`` prevents two concurrent
syncs for the same feature instance.

After every successful sync the in-memory stats cache is invalidated for
the instance.
"""

from __future__ import annotations

import asyncio
import logging
import time
from typing import Any, Dict, List, Optional

from modules.connectors.connectorTicketsRedmine import RedmineApiError
from modules.datamodels.datamodelUam import User
from modules.features.redmine.datamodelRedmine import (
    RedmineInstanceConfig,
    RedmineRelationMirror,
    RedmineSyncResultDto,
    RedmineSyncStatusDto,
    RedmineTicketMirror,
)
from modules.features.redmine.interfaceFeatureRedmine import getInterface
from modules.features.redmine.serviceRedmineStatsCache import getStatsCache

logger = logging.getLogger(__name__)


_INCREMENTAL_OVERLAP_SECONDS = 60 * 60  # 1h overlap on incremental syncs
_DEFAULT_PAGE_SIZE = 100
_MAX_PAGES_SAFETY = 5000  # 500k tickets safety cap

_locks: Dict[str, asyncio.Lock] = {}


def _lockFor(featureInstanceId: str) -> asyncio.Lock:
    if featureInstanceId not in _locks:
        _locks[featureInstanceId] = asyncio.Lock()
    return _locks[featureInstanceId]


# ---------------------------------------------------------------------------
# Public API
# ---------------------------------------------------------------------------

async def runSync(
    currentUser: User,
    mandateId: Optional[str],
    featureInstanceId: str,
    *,
    force: bool = False,
    pageSize: int = _DEFAULT_PAGE_SIZE,
) -> RedmineSyncResultDto:
    """Run a (full or incremental) sync for the given feature instance."""
    iface = getInterface(currentUser, mandateId=mandateId, featureInstanceId=featureInstanceId)
    connector = iface.resolveConnector(featureInstanceId)
    cfg = iface.getConfig(featureInstanceId)
    if not connector or not cfg:
        raise RuntimeError(
            f"Redmine instance {featureInstanceId} is not configured or inactive"
        )

    async with _lockFor(featureInstanceId):
        started = time.monotonic()

        # CRITICAL: ensure the schema cache (especially the per-status
        # ``isClosed`` map) is populated BEFORE we iterate issues. Redmine's
        # /issues.json endpoint only returns ``{id, name}`` for the status
        # object -- the closed/open flag lives in /issue_statuses.json. If
        # the cache is empty here, every freshly-synced ticket would land
        # with ``isClosed=False`` and the Stats page would be useless.
        await _ensureSchemaWarm(currentUser, mandateId, featureInstanceId)
        cfg = iface.getConfig(featureInstanceId)  # re-read to get warm cache

        full = force or cfg.lastSyncAt is None
        updated_from_iso: Optional[str] = None
        if not full and cfg.lastSyncAt is not None:
            cursor_epoch = max(0.0, cfg.lastSyncAt - _INCREMENTAL_OVERLAP_SECONDS)
            updated_from_iso = time.strftime(
                "%Y-%m-%dT%H:%M:%SZ", time.gmtime(cursor_epoch)
            )

        try:
            issues = await connector.listAllIssues(
                statusId="*",
                updatedOnFrom=updated_from_iso,
                pageSize=pageSize,
                maxPages=_MAX_PAGES_SAFETY,
                include=["relations"],
            )
        except RedmineApiError as e:
            iface.recordSyncFailure(featureInstanceId, str(e))
            raise

        tickets_upserted = 0
        relations_upserted = 0
        now_epoch = time.time()

        for issue in issues:
            tickets_upserted += _upsertTicket(iface, featureInstanceId, mandateId, issue, now_epoch)
            relations_upserted += _replaceRelations(iface, featureInstanceId, issue, now_epoch)

        # Self-healing pass: re-apply ``isClosed`` to every mirrored ticket
        # using the now-warm schema cache. Fixes pre-existing rows that were
        # synced before the cache was populated (cheap; mirror-local only).
        flags_fixed = _rebuildIsClosedFromSchema(iface, featureInstanceId, now_epoch)
        if flags_fixed:
            logger.info(
                f"runSync({featureInstanceId}): corrected isClosed on {flags_fixed} mirror rows"
            )

        duration_ms = int((time.monotonic() - started) * 1000)
        iface.recordSyncSuccess(
            featureInstanceId,
            full=full,
            ticketsUpserted=tickets_upserted,
            durationMs=duration_ms,
            lastSyncAt=now_epoch,
        )
        getStatsCache().invalidateInstance(featureInstanceId)

        return RedmineSyncResultDto(
            instanceId=featureInstanceId,
            full=full,
            ticketsUpserted=tickets_upserted,
            relationsUpserted=relations_upserted,
            durationMs=duration_ms,
            lastSyncAt=now_epoch,
        )


def getSyncStatus(
    currentUser: User,
    mandateId: Optional[str],
    featureInstanceId: str,
) -> RedmineSyncStatusDto:
    iface = getInterface(currentUser, mandateId=mandateId, featureInstanceId=featureInstanceId)
    cfg = iface.getConfig(featureInstanceId)
    ticket_count = iface.countMirroredTickets(featureInstanceId)
    relation_count = iface.countMirroredRelations(featureInstanceId)
    return RedmineSyncStatusDto(
        instanceId=featureInstanceId,
        lastSyncAt=cfg.lastSyncAt if cfg else None,
        lastFullSyncAt=cfg.lastFullSyncAt if cfg else None,
        lastSyncDurationMs=cfg.lastSyncDurationMs if cfg else None,
        lastSyncTicketCount=cfg.lastSyncTicketCount if cfg else None,
        lastSyncErrorAt=cfg.lastSyncErrorAt if cfg else None,
        lastSyncErrorMessage=cfg.lastSyncErrorMessage if cfg else None,
        mirroredTicketCount=ticket_count,
        mirroredRelationCount=relation_count,
    )


async def upsertSingleTicket(
    currentUser: User,
    mandateId: Optional[str],
    featureInstanceId: str,
    issueId: int,
) -> int:
    """Re-fetch one issue from Redmine and upsert it into the mirror.

    Used by the write paths in ``serviceRedmine`` so the mirror stays
    consistent after every create / update without a full sync.
    Returns the number of relation rows replaced.
    """
    iface = getInterface(currentUser, mandateId=mandateId, featureInstanceId=featureInstanceId)
    connector = iface.resolveConnector(featureInstanceId)
    if not connector:
        raise RuntimeError("Redmine instance not configured")
    issue = await connector.getIssue(int(issueId), includeRelations=True)
    now_epoch = time.time()
    _upsertTicket(iface, featureInstanceId, mandateId, issue, now_epoch)
    relations_upserted = _replaceRelations(iface, featureInstanceId, issue, now_epoch)
    getStatsCache().invalidateInstance(featureInstanceId)
    return relations_upserted


def deleteMirroredTicket(
    currentUser: User,
    mandateId: Optional[str],
    featureInstanceId: str,
    issueId: int,
) -> bool:
    """Drop a ticket and its relations from the mirror after a successful Redmine DELETE."""
    iface = getInterface(currentUser, mandateId=mandateId, featureInstanceId=featureInstanceId)
    deleted = iface.deleteMirroredTicket(featureInstanceId, int(issueId))
    iface.deleteMirroredRelationsForIssue(featureInstanceId, int(issueId))
    getStatsCache().invalidateInstance(featureInstanceId)
    return deleted


# ---------------------------------------------------------------------------
# Per-issue upsert helpers (sync, run inside the per-instance lock)
# ---------------------------------------------------------------------------

def _upsertTicket(
    iface,
    featureInstanceId: str,
    mandateId: Optional[str],
    issue: Dict[str, Any],
    nowEpoch: float,
) -> int:
    redmine_id = issue.get("id")
    if redmine_id is None:
        return 0
    statuses_lookup = (iface.getConfig(featureInstanceId).schemaCache or {}).get("statuses") or []
    is_closed = _statusIsClosed(issue.get("status") or {}, statuses_lookup)
    record = _ticketRecordFromIssue(issue, featureInstanceId, mandateId, is_closed, nowEpoch)
    iface.upsertMirroredTicket(featureInstanceId, int(redmine_id), record)
    return 1


def _replaceRelations(
    iface,
    featureInstanceId: str,
    issue: Dict[str, Any],
    nowEpoch: float,
) -> int:
    issue_id = issue.get("id")
    relations = issue.get("relations") or []
    if issue_id is None:
        return 0
    iface.deleteMirroredRelationsForIssue(featureInstanceId, int(issue_id))
    inserted = 0
    for r in relations:
        rid = r.get("id")
        if rid is None:
            continue
        iface.insertMirroredRelation(
            featureInstanceId,
            {
                "featureInstanceId": featureInstanceId,
                "redmineRelationId": int(rid),
                "issueId": int(r.get("issue_id") or 0),
                "issueToId": int(r.get("issue_to_id") or 0),
                "relationType": str(r.get("relation_type") or "relates"),
                "delay": r.get("delay"),
                "syncedAt": nowEpoch,
            },
        )
        inserted += 1
    return inserted


# ---------------------------------------------------------------------------
# Schema cache warm-up + post-sync isClosed correction
# ---------------------------------------------------------------------------

async def _ensureSchemaWarm(
    currentUser: User,
    mandateId: Optional[str],
    featureInstanceId: str,
) -> None:
    """Make sure ``cfg.schemaCache['statuses']`` exists with the per-status
    ``isClosed`` flag. Called at the start of every sync because Redmine's
    ``/issues.json`` doesn't expose ``is_closed`` on the inline status
    object, so we MUST resolve it via the schema.
    """
    iface = getInterface(currentUser, mandateId=mandateId, featureInstanceId=featureInstanceId)
    cfg = iface.getConfig(featureInstanceId)
    if cfg is None:
        return
    statuses = (cfg.schemaCache or {}).get("statuses") or []
    if statuses:
        return
    # Lazy import to avoid a circular dependency at module load.
    from modules.features.redmine.serviceRedmine import getProjectMeta
    try:
        await getProjectMeta(currentUser, mandateId, featureInstanceId, forceRefresh=True)
    except Exception as e:
        logger.warning(
            f"_ensureSchemaWarm({featureInstanceId}): could not warm schema cache: {e} "
            "-- isClosed flags may be inaccurate until next successful schema fetch."
        )


def _rebuildIsClosedFromSchema(iface, featureInstanceId: str, nowEpoch: float) -> int:
    """Walk the mirror once and fix ``isClosed`` (and ``closedOnTs``) for any
    ticket whose stored value disagrees with the current schema cache.

    Returns the number of rows that were actually corrected. A no-op when
    the schema cache has no statuses (logged once, then the caller can
    decide whether to retry).
    """
    cfg = iface.getConfig(featureInstanceId)
    if cfg is None:
        return 0
    statuses = (cfg.schemaCache or {}).get("statuses") or []
    if not statuses:
        return 0
    closed_ids = {int(s.get("id")) for s in statuses if s.get("id") is not None and s.get("isClosed")}
    rows = iface.listMirroredTickets(featureInstanceId)
    corrections = 0
    for row in rows:
        sid = row.get("statusId")
        if sid is None:
            continue
        should_be_closed = int(sid) in closed_ids
        if bool(row.get("isClosed")) == should_be_closed:
            continue
        # Only the closed/open flag (and the derived closedOnTs) are
        # touched here -- everything else came from Redmine and stays.
        update = {
            "isClosed": bool(should_be_closed),
            "closedOnTs": float(row.get("updatedOnTs")) if (should_be_closed and row.get("updatedOnTs") is not None) else None,
            "syncedAt": nowEpoch,
        }
        try:
            iface.upsertMirroredTicket(featureInstanceId, int(row.get("redmineId")), {**row, **update})
            corrections += 1
        except Exception as e:
            logger.warning(
                f"_rebuildIsClosedFromSchema({featureInstanceId}): could not fix ticket "
                f"#{row.get('redmineId')}: {e}"
            )
    return corrections


# ---------------------------------------------------------------------------
# Pure helpers
# ---------------------------------------------------------------------------

def _statusIsClosed(status: Dict[str, Any], statusesLookup: List[Dict[str, Any]]) -> bool:
    """Best-effort: prefer the schemaCache; fall back to inspecting the
    raw issue (Redmine sets ``is_closed`` on the status object only when
    explicitly requested)."""
    sid = status.get("id")
    if sid is None:
        return False
    for s in statusesLookup:
        if s.get("id") == sid:
            return bool(s.get("isClosed"))
    return bool(status.get("is_closed"))


def _parseRedmineDateToEpoch(value: Optional[str]) -> Optional[float]:
    if not value:
        return None
    try:
        from datetime import datetime
        s = value.replace("Z", "+00:00")
        return datetime.fromisoformat(s).timestamp()
    except Exception:
        return None


def _ticketRecordFromIssue(
    issue: Dict[str, Any],
    featureInstanceId: str,
    mandateId: Optional[str],
    isClosed: bool,
    nowEpoch: float,
) -> Dict[str, Any]:
    tracker = issue.get("tracker") or {}
    status = issue.get("status") or {}
    priority = issue.get("priority") or {}
    assigned = issue.get("assigned_to") or {}
    author = issue.get("author") or {}
    parent = issue.get("parent") or {}
    fixed_version = issue.get("fixed_version") or {}
    category = issue.get("category") or {}
    created_on = issue.get("created_on")
    updated_on = issue.get("updated_on")
    updated_ts = _parseRedmineDateToEpoch(updated_on)

    return {
        "featureInstanceId": featureInstanceId,
        "mandateId": mandateId,
        "redmineId": int(issue.get("id")),
        "subject": str(issue.get("subject") or ""),
        "description": str(issue.get("description") or ""),
        "trackerId": tracker.get("id"),
        "trackerName": tracker.get("name"),
        "statusId": status.get("id"),
        "statusName": status.get("name"),
        "isClosed": bool(isClosed),
        "priorityId": priority.get("id"),
        "priorityName": priority.get("name"),
        "assignedToId": assigned.get("id"),
        "assignedToName": assigned.get("name"),
        "authorId": author.get("id"),
        "authorName": author.get("name"),
        "parentId": parent.get("id"),
        "fixedVersionId": fixed_version.get("id"),
        "fixedVersionName": fixed_version.get("name"),
        "categoryId": category.get("id"),
        "categoryName": category.get("name"),
        "createdOn": created_on,
        "updatedOn": updated_on,
        "createdOnTs": _parseRedmineDateToEpoch(created_on),
        "updatedOnTs": updated_ts,
        # Approximation: Redmine doesn't expose a dedicated "closed_on"
        # timestamp via the issue endpoint. For closed tickets the last
        # updatedOn is the best stable proxy without scanning journals.
        "closedOnTs": updated_ts if bool(isClosed) else None,
        "customFields": list(issue.get("custom_fields") or []),
        "raw": issue,
        "syncedAt": nowEpoch,
    }