"""
Resolve failed sync items — mark as succeeded and clear last_error in sync_state.

Use when products are confirmed active on Magento despite prior sync failures.
Those SKUs will no longer appear in /api/magento/sync/failed-items.

CLI: python -m app.jobs.magento_resolve_failed_items --connection-id X [--all | --skus SKU1,SKU2,...] [--dry-run]
"""

from __future__ import annotations

import argparse
import logging
import sys

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


def run_resolve(
    connection_id: int,
    *,
    skus: list[str] | None = None,
    all_failed: bool = False,
    dry_run: bool = False,
) -> dict:
    """
    Mark failed sync items as resolved for the given connection.
    - skus: resolve only these SKUs
    - all_failed: resolve all failed items for the connection
    Either skus or all_failed must be set.
    """
    from db.session import get_session
    from db.magento_repositories import (
        SqlAlchemyMagentoConnectionRepository,
        SqlAlchemyMagentoSyncRepository,
        SqlAlchemyMagentoSyncStateRepository,
    )

    if not skus and not all_failed:
        return {"status": "failed", "error": "Provide --skus or --all"}

    with get_session() as session:
        conn_repo = SqlAlchemyMagentoConnectionRepository(session)
        conn = conn_repo.get_by_id(connection_id)
        if not conn:
            return {"status": "failed", "error": f"Connection {connection_id} not found"}

        sync_repo = SqlAlchemyMagentoSyncRepository(session)
        state_repo = SqlAlchemyMagentoSyncStateRepository(session)

        if dry_run:
            items = sync_repo.get_failed_sync_items(
                connection_id,
                limit=5000,
                unique_skus=bool(skus),
            )
            if skus:
                items = [i for i in items if i.get("sku") in skus]
            return {
                "status": "dry_run",
                "would_resolve": len(items),
                "skus": [i.get("sku") for i in items if i.get("sku")],
            }

        count = sync_repo.mark_failed_items_resolved(
            connection_id,
            skus=skus if skus else None,
            state_repo=state_repo,
        )
        session.commit()
    return {"status": "success", "items_resolved": count}


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Resolve failed sync items (products now active on Magento)"
    )
    parser.add_argument("--connection-id", type=int, required=True)
    parser.add_argument(
        "--skus",
        type=str,
        help="Comma-separated SKUs to resolve (default: none)",
    )
    parser.add_argument(
        "--all",
        action="store_true",
        help="Resolve all failed items for the connection",
    )
    parser.add_argument("--dry-run", action="store_true")
    args = parser.parse_args()

    skus = None
    if args.skus:
        skus = [s.strip() for s in args.skus.split(",") if s.strip()]

    result = run_resolve(
        args.connection_id,
        skus=skus,
        all_failed=args.all,
        dry_run=args.dry_run,
    )

    if result.get("status") == "failed":
        logger.error(result.get("error", "unknown"))
        return 1

    if result.get("status") == "dry_run":
        logger.info("Dry run: would resolve %d items", result.get("would_resolve", 0))
        return 0

    logger.info("Resolved %d failed sync items", result.get("items_resolved", 0))
    return 0


if __name__ == "__main__":
    sys.exit(main())