"""Worker 入口：周期回填到期结算指数。"""

from __future__ import annotations

import logging
import signal
import sys
import time
from typing import Any

from apps.collector.okx_rest import OkxRestClient
from apps.worker.settle import backfill_settlements
from packages.config import get_settings
from packages.db import Repository

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s [worker] %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger("worker")

_STOP = False


def _handle_signal(signum: int, _frame: Any) -> None:
    global _STOP
    log.info("signal %s received, stopping…", signum)
    _STOP = True


def run() -> int:
    settings = get_settings()
    interval = max(60, int(settings.settle_backfill_interval_sec))
    log.info(
        "start settle backfill interval=%ss db=%s",
        interval,
        settings.db_path,
    )
    repo = Repository(settings.db_path)
    client = OkxRestClient(
        base_url=settings.okx_base_url,
        proxy=settings.okx_proxy or None,
    )
    try:
        while not _STOP:
            try:
                result = backfill_settlements(
                    repo,
                    underlying=settings.underlying,
                    index_inst_id=settings.index_inst_id,
                    client=client,
                )
                log.info(
                    "backfill filled=%s skipped=%s errors=%s",
                    len(result["filled"]),
                    len(result["skipped"]),
                    len(result["errors"]),
                )
                for err in result["errors"][:5]:
                    log.warning("  %s", err)
            except Exception as e:  # noqa: BLE001
                log.exception("backfill loop failed: %s", e)

            end = time.monotonic() + interval
            while not _STOP and time.monotonic() < end:
                time.sleep(min(1.0, end - time.monotonic()))
    finally:
        client.close()
        repo.close()
        log.info("stopped")
    return 0


def main() -> None:
    signal.signal(signal.SIGINT, _handle_signal)
    signal.signal(signal.SIGTERM, _handle_signal)
    sys.exit(run())


if __name__ == "__main__":
    main()