"""
ⒸAngelaMos | 2025
Handles all Scan model database queries
"""

from __future__ import annotations

from datetime import UTC, datetime
from sqlalchemy.orm import (
    Session,
    joinedload,
)

from config import settings
from models.Scan import Scan


class ScanRepository:
    """
    Repository for Scan database operations
    """
    @staticmethod
    def create_scan(
        db: Session,
        user_id: int,
        target_url: str,
        commit: bool = True
    ) -> Scan:
        """
        Create a new scan

        Args:
            db: Database session
            user_id: User ID who initiated the scan
            target_url: Target URL to scan
            commit: Whether to commit the transaction

        Returns:
            Scan: Created scan instance
        """
        scan = Scan(
            user_id = user_id,
            target_url = target_url,
            scan_date = datetime.now(UTC),
        )
        db.add(scan)
        if commit:
            db.commit()
            db.refresh(scan)
        return scan

    @staticmethod
    def get_by_id(db: Session, scan_id: int) -> Scan | None:
        """
        Get scan by ID with test results loaded

        Args:
            db: Database session
            scan_id: Scan ID

        Returns:
            Scan | None: Scan instance or None if not found
        """
        return (
            db.query(Scan).options(
                joinedload(Scan.test_results)
            ).filter(Scan.id == scan_id).first()
        )

    @staticmethod
    def get_by_user(
        db: Session,
        user_id: int,
        skip: int = 0,
        limit: int | None = None
    ) -> list[Scan]:
        """
        Get all scans for a user with pagination.

        Args:
            db: Database session
            user_id: User ID
            skip: Number of records to skip
            limit: Maximum number of records to return (DEFAULT_PAGINATION_LIMIT)

        Returns:
            list[Scan]: List of scans with test results
        """
        if limit is None:
            limit = settings.DEFAULT_PAGINATION_LIMIT

        return (
            db.query(Scan).options(
                joinedload(Scan.test_results)
            ).filter(Scan.user_id == user_id).order_by(
                Scan.scan_date.desc()
            ).offset(skip).limit(limit).all()
        )

    @staticmethod
    def get_recent(db: Session,
                   limit: int | None = None) -> list[Scan]:
        """
        Get most recent scans across all users.

        Args:
            db: Database session
            limit: Maximum number of scans to return (DEFAULT_PAGINATION_LIMIT)

        Returns:
            list[Scan]: List of recent scans
        """
        if limit is None:
            limit = settings.DEFAULT_PAGINATION_LIMIT

        return (
            db.query(Scan).options(
                joinedload(Scan.test_results)
            ).order_by(Scan.scan_date.desc()).limit(limit).all()
        )

    @staticmethod
    def delete(
        db: Session,
        scan_id: int,
        commit: bool = True
    ) -> bool:
        """
        Delete a scan (cascades to test results).

        Args:
            db: Database session
            scan_id: Scan ID to delete
            commit: Whether to commit the transaction

        Returns:
            bool: True if deleted, False if not found
        """
        scan = ScanRepository.get_by_id(db, scan_id)
        if scan:
            db.delete(scan)
            if commit:
                db.commit()
            return True
        return False

    @staticmethod
    def count_by_user(db: Session, user_id: int) -> int:
        """
        Count total scans for a user.

        Args:
            db: Database session
            user_id: User ID

        Returns:
            int: Total number of scans
        """
        return db.query(Scan).filter(Scan.user_id == user_id).count()