from fastapi import APIRouter, Depends, HTTPException, Query
from pydantic import BaseModel
from sqlalchemy import func, select
from sqlalchemy.orm import Session

from datetime import datetime, timezone
from functools import partial

from app.auth.jwt_auth import get_current_user, require_admin
from app.config import get_settings
from app.database import get_db
from app.models import Event, Host
from app.schemas.list_models import HostDetail, HostListResponse, HostSummary
from app.services.agent_version import (
    latest_agent_versions_by_product,
    reference_agent_versions_by_product,
)
from app.services.agent_git_release import get_git_release_versions
from app.services.agent_update import (
    AgentUpdateNotAllowedError,
    execute_agent_update_fallback,
    host_version_status,
    request_agent_update,
)
from app.services.agent_update_settings import get_effective_agent_update_config
from app.services.agent_host_config import get_host_agent_settings, update_host_agent_config
from app.services.host_delete import delete_host_and_related
from app.services.linux_admin_settings import get_effective_linux_admin_config
from app.services.win_admin_settings import get_effective_win_admin_config
from app.services.winrm_connect import (
    HostNotWindowsError,
    HostTargetMissingError,
    WinAdminNotConfiguredError,
    WinRmTestResult,
    iter_winrm_targets,
    test_winrm_connection,
)
from app.services.ssh_connect import (
    HostNotLinuxError as SshHostNotLinuxError,
    HostTargetMissingError as SshHostTargetMissingError,
    LinuxAdminNotConfiguredError,
    SshCommandResult,
    iter_ssh_targets,
    run_ssh_monitor_update,
    test_ssh_connection,
)
from app.services.host_health import (
    HEARTBEAT_TYPE,
    agent_status as compute_agent_status,
    apply_agent_status_host_filter,
    max_daily_report_time_by_host,
    max_event_time_by_host,
)

router = APIRouter(prefix="/hosts", tags=["hosts"])


@router.get("", response_model=HostListResponse)
def list_hosts(
    page: int = Query(1, ge=1),
    page_size: int = Query(50, ge=1, le=200),
    product: str | None = None,
    hostname: str | None = None,
    agent_status: str | None = Query(None, pattern="^(online|stale|unknown)$"),
    db: Session = Depends(get_db),
    _user: str = Depends(get_current_user),
) -> HostListResponse:
    stmt = select(Host)
    count_stmt = select(func.count()).select_from(Host)

    if product:
        stmt = stmt.where(Host.product == product)
        count_stmt = count_stmt.where(Host.product == product)
    if hostname:
        like = f"%{hostname}%"
        host_match = Host.hostname.ilike(like) | Host.display_name.ilike(like)
        stmt = stmt.where(host_match)
        count_stmt = count_stmt.where(host_match)

    settings = get_settings()
    if agent_status:
        stmt, count_stmt = apply_agent_status_host_filter(
            stmt,
            count_stmt,
            agent_status,
            stale_minutes=settings.sac_heartbeat_stale_minutes,
        )

    total = db.scalar(count_stmt) or 0
    rows = db.scalars(
        stmt.order_by(Host.last_seen_at.desc())
        .offset((page - 1) * page_size)
        .limit(page_size)
    ).all()

    hb_map = max_event_time_by_host(db, HEARTBEAT_TYPE)
    report_map = max_daily_report_time_by_host(db)
    latest_map = latest_agent_versions_by_product(db)
    update_cfg = get_effective_agent_update_config(db)
    git_release = get_git_release_versions(update_cfg, db=db)
    reference_map = reference_agent_versions_by_product(
        update_cfg,
        latest_map,
        git_versions=git_release.versions,
    )

    items: list[HostSummary] = []
    for host in rows:
        event_count = db.scalar(
            select(func.count()).select_from(Event).where(Event.host_id == host.id)
        )
        last_hb = hb_map.get(host.id)
        items.append(
            HostSummary(
                id=host.id,
                hostname=host.hostname,
                display_name=host.display_name,
                os_family=host.os_family,
                os_version=host.os_version,
                product=host.product,
                product_version=host.product_version,
                ipv4=host.ipv4,
                last_seen_at=host.last_seen_at,
                event_count=int(event_count or 0),
                last_heartbeat_at=last_hb,
                last_daily_report_at=report_map.get(host.id),
                last_inventory_at=host.inventory_updated_at,
                agent_status=compute_agent_status(
                    last_hb, stale_minutes=settings.sac_heartbeat_stale_minutes
                ),
                version_status=host_version_status(
                    host,
                    cfg=update_cfg,
                    latest_map=latest_map,
                    git_versions=git_release.versions,
                ),
                pending_agent_update=bool(host.pending_agent_update),
            )
        )

    return HostListResponse(
        items=items,
        total=total,
        page=page,
        page_size=page_size,
        latest_agent_versions=latest_map,
        reference_agent_versions=reference_map,
    )


def _host_detail_from_model(
    host: Host,
    *,
    db: Session,
    settings,
) -> HostDetail:
    hb_map = max_event_time_by_host(db, HEARTBEAT_TYPE)
    report_map = max_daily_report_time_by_host(db)
    event_count = db.scalar(
        select(func.count()).select_from(Event).where(Event.host_id == host.id)
    )
    last_hb = hb_map.get(host.id)
    latest_map = latest_agent_versions_by_product(db)
    update_cfg = get_effective_agent_update_config(db)
    git_release = get_git_release_versions(update_cfg, db=db)
    return HostDetail(
        id=host.id,
        hostname=host.hostname,
        display_name=host.display_name,
        os_family=host.os_family,
        os_version=host.os_version,
        product=host.product,
        product_version=host.product_version,
        ipv4=host.ipv4,
        ipv6=host.ipv6,
        last_seen_at=host.last_seen_at,
        event_count=int(event_count or 0),
        last_heartbeat_at=last_hb,
        last_daily_report_at=report_map.get(host.id),
        last_inventory_at=host.inventory_updated_at,
        agent_status=compute_agent_status(last_hb, stale_minutes=settings.sac_heartbeat_stale_minutes),
        version_status=host_version_status(
            host,
            cfg=update_cfg,
            latest_map=latest_map,
            git_versions=git_release.versions,
        ),
        pending_agent_update=bool(host.pending_agent_update),
        agent_instance_id=host.agent_instance_id,
        tags=host.tags if isinstance(host.tags, list) else [],
        use_sac_mode=host.use_sac_mode,
        inventory=host.inventory if isinstance(host.inventory, dict) else None,
        inventory_updated_at=host.inventory_updated_at,
        created_at=host.created_at,
        ssh_admin_ok=host.ssh_admin_ok,
        ssh_admin_checked_at=host.ssh_admin_checked_at,
        pending_update_requested_at=host.pending_update_requested_at,
        pending_update_target_version=host.pending_update_target_version,
        agent_config_revision=int(host.agent_config_revision or 0),
        agent_config=get_host_agent_settings(host) or None,
        agent_update_state=host.agent_update_state,
        agent_update_last_at=host.agent_update_last_at,
        agent_update_last_error=host.agent_update_last_error,
    )


def _set_ssh_admin_status(host: Host, ok: bool) -> None:
    host.ssh_admin_ok = ok
    host.ssh_admin_checked_at = datetime.now(timezone.utc)


@router.get("/{host_id}", response_model=HostDetail)
def get_host(
    host_id: int,
    db: Session = Depends(get_db),
    _user: str = Depends(get_current_user),
) -> HostDetail:
    host = db.get(Host, host_id)
    if host is None:
        raise HTTPException(status_code=404, detail="Host not found")
    settings = get_settings()
    return _host_detail_from_model(host, db=db, settings=settings)


class HostDeleteResponse(BaseModel):
    status: str
    host_id: int
    hostname: str
    deleted_events: int
    deleted_problems: int


class HostWinRmTestResponse(BaseModel):
    ok: bool
    message: str
    target: str
    hostname: str | None = None


class HostSshActionResponse(BaseModel):
    ok: bool
    message: str
    target: str
    stdout: str | None = None
    stderr: str | None = None
    exit_code: int | None = None
    product_version: str | None = None
    ssh_admin_ok: bool | None = None


class HostAgentUpdateRequestResponse(BaseModel):
    status: str
    pending_agent_update: bool
    target_version: str | None = None
    agent_update_state: str | None = None


class HostAgentConfigUpdate(BaseModel):
    settings: dict[str, object] = {}


class HostAgentConfigResponse(BaseModel):
    config_revision: int
    settings: dict[str, object]


def _ssh_action_response(
    result: SshCommandResult,
    *,
    attempts: list[str] | None = None,
    ssh_admin_ok: bool | None = None,
) -> HostSshActionResponse:
    message = result.message
    if attempts:
        message = f"{message} (пробовали: {', '.join(attempts)})"
    return HostSshActionResponse(
        ok=result.ok,
        message=message,
        target=result.target,
        stdout=result.stdout or None,
        stderr=result.stderr or None,
        exit_code=result.exit_code,
        product_version=result.agent_version,
        ssh_admin_ok=ssh_admin_ok,
    )


def _run_ssh_action_on_host(
    host: Host,
    cfg,
    *,
    action,
) -> HostSshActionResponse:
    try:
        targets = iter_ssh_targets(host)
    except SshHostNotLinuxError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc
    except SshHostTargetMissingError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc

    last_result: SshCommandResult | None = None
    attempts: list[str] = []
    for target in targets:
        try:
            result = action(target=target, user=cfg.user, password=cfg.password)
        except LinuxAdminNotConfiguredError as exc:
            raise HTTPException(status_code=400, detail=str(exc)) from exc
        except RuntimeError as exc:
            raise HTTPException(status_code=503, detail=str(exc)) from exc
        last_result = result
        attempts.append(f"{target}={'OK' if result.ok else 'fail'}")
        if result.ok:
            return _ssh_action_response(result, attempts=attempts if len(attempts) > 1 else None)

    assert last_result is not None
    return _ssh_action_response(last_result, attempts=attempts if len(attempts) > 1 else None)


@router.post("/{host_id}/actions/winrm-test", response_model=HostWinRmTestResponse)
def test_host_winrm(
    host_id: int,
    db: Session = Depends(get_db),
    _user=Depends(require_admin),
) -> HostWinRmTestResponse:
    host = db.get(Host, host_id)
    if host is None:
        raise HTTPException(status_code=404, detail="Host not found")

    cfg = get_effective_win_admin_config(db)
    if not cfg.configured:
        raise HTTPException(status_code=400, detail="Windows domain admin is not configured")

    try:
        targets = iter_winrm_targets(host)
    except HostNotWindowsError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc
    except HostTargetMissingError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc

    last_result = None
    attempts: list[str] = []
    for target in targets:
        try:
            result = test_winrm_connection(
                target=target,
                user=cfg.user,
                password=cfg.password,
            )
        except WinAdminNotConfiguredError as exc:
            raise HTTPException(status_code=400, detail=str(exc)) from exc
        except RuntimeError as exc:
            raise HTTPException(status_code=503, detail=str(exc)) from exc
        last_result = result
        attempts.append(f"{target}={'OK' if result.ok else 'fail'}")
        if result.ok:
            if len(targets) > 1:
                result = WinRmTestResult(
                    ok=True,
                    message=f"{result.message} (пробовали: {', '.join(attempts)})",
                    target=result.target,
                    hostname=result.hostname,
                )
            return HostWinRmTestResponse(
                ok=result.ok,
                message=result.message,
                target=result.target,
                hostname=result.hostname,
            )

    assert last_result is not None
    message = last_result.message
    if len(attempts) > 1:
        message = f"{message} (пробовали: {', '.join(attempts)})"
    return HostWinRmTestResponse(
        ok=False,
        message=message,
        target=last_result.target,
        hostname=last_result.hostname,
    )


@router.post("/{host_id}/actions/ssh-test", response_model=HostSshActionResponse)
def test_host_ssh(
    host_id: int,
    db: Session = Depends(get_db),
    _user=Depends(require_admin),
) -> HostSshActionResponse:
    host = db.get(Host, host_id)
    if host is None:
        raise HTTPException(status_code=404, detail="Host not found")

    cfg = get_effective_linux_admin_config(db)
    if not cfg.configured:
        raise HTTPException(status_code=400, detail="Linux SSH admin is not configured")

    response = _run_ssh_action_on_host(host, cfg, action=test_ssh_connection)
    _set_ssh_admin_status(host, response.ok)
    db.commit()
    return response.model_copy(update={"ssh_admin_ok": host.ssh_admin_ok})


@router.post("/{host_id}/actions/agent-update", response_model=HostSshActionResponse)
def update_host_agent_via_ssh(
    host_id: int,
    db: Session = Depends(get_db),
    _user=Depends(require_admin),
) -> HostSshActionResponse:
    host = db.get(Host, host_id)
    if host is None:
        raise HTTPException(status_code=404, detail="Host not found")

    cfg = get_effective_linux_admin_config(db)
    if not cfg.configured:
        raise HTTPException(status_code=400, detail="Linux SSH admin is not configured")

    agent_cfg = get_effective_agent_update_config(db)
    repo_url = (agent_cfg.ssh_git_repo_url or "").strip() or None
    branch = (agent_cfg.git_branch or "main").strip() or "main"
    response = _run_ssh_action_on_host(
        host,
        cfg,
        action=partial(run_ssh_monitor_update, repo_url=repo_url, git_branch=branch),
    )
    _set_ssh_admin_status(host, response.ok)
    if response.ok and response.product_version:
        host.product_version = response.product_version
    db.commit()
    return response.model_copy(
        update={
            "product_version": host.product_version if response.ok else response.product_version,
            "ssh_admin_ok": host.ssh_admin_ok,
        }
    )


@router.post("/{host_id}/actions/request-agent-update", response_model=HostAgentUpdateRequestResponse)
def post_request_agent_update(
    host_id: int,
    db: Session = Depends(get_db),
    _user=Depends(require_admin),
) -> HostAgentUpdateRequestResponse:
    host = db.get(Host, host_id)
    if host is None:
        raise HTTPException(status_code=404, detail="Host not found")
    try:
        request_agent_update(db, host)
    except AgentUpdateNotAllowedError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc
    db.commit()
    return HostAgentUpdateRequestResponse(
        status="requested",
        pending_agent_update=host.pending_agent_update,
        target_version=host.pending_update_target_version,
        agent_update_state=host.agent_update_state,
    )


@router.post("/{host_id}/actions/agent-update-fallback", response_model=HostSshActionResponse)
def post_agent_update_fallback(
    host_id: int,
    db: Session = Depends(get_db),
    _user=Depends(require_admin),
) -> HostSshActionResponse:
    host = db.get(Host, host_id)
    if host is None:
        raise HTTPException(status_code=404, detail="Host not found")

    result = execute_agent_update_fallback(db, host)
    db.commit()
    return HostSshActionResponse(
        ok=result.ok,
        message=result.message,
        target=result.target or host.hostname,
        stdout=result.stdout or None,
        stderr=result.stderr or None,
        exit_code=result.exit_code,
        product_version=result.product_version or (host.product_version if result.ok else None),
        ssh_admin_ok=host.ssh_admin_ok,
    )


@router.patch("/{host_id}/agent-config", response_model=HostAgentConfigResponse)
def patch_host_agent_config(
    host_id: int,
    body: HostAgentConfigUpdate,
    db: Session = Depends(get_db),
    _user=Depends(require_admin),
) -> HostAgentConfigResponse:
    host = db.get(Host, host_id)
    if host is None:
        raise HTTPException(status_code=404, detail="Host not found")
    try:
        update_host_agent_config(db, host, body.settings)
    except ValueError as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc
    db.commit()
    settings = get_host_agent_settings(host)
    return HostAgentConfigResponse(
        config_revision=int(host.agent_config_revision or 0),
        settings=settings,
    )


@router.get("/{host_id}/agent-config", response_model=HostAgentConfigResponse)
def get_host_agent_config(
    host_id: int,
    db: Session = Depends(get_db),
    _user=Depends(require_admin),
) -> HostAgentConfigResponse:
    host = db.get(Host, host_id)
    if host is None:
        raise HTTPException(status_code=404, detail="Host not found")
    settings = get_host_agent_settings(host)
    return HostAgentConfigResponse(
        config_revision=int(host.agent_config_revision or 0),
        settings=settings,
    )


@router.delete("/{host_id}", response_model=HostDeleteResponse)
def delete_host(
    host_id: int,
    db: Session = Depends(get_db),
    _user=Depends(require_admin),
) -> HostDeleteResponse:
    result = delete_host_and_related(db, host_id)
    if result is None:
        raise HTTPException(status_code=404, detail="Host not found")
    db.commit()
    return HostDeleteResponse(
        status="deleted",
        host_id=result.host_id,
        hostname=result.hostname,
        deleted_events=result.deleted_events,
        deleted_problems=result.deleted_problems,
    )