Zabbix Api

MIT License

Copyright (c) 2024

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

#!/usr/bin/env python3
"""
Bulk host management for Zabbix via API.
Supports create, update, delete, and export operations from CSV.

Usage:
    python zabbix-bulk-hosts.py create hosts.csv
    python zabbix-bulk-hosts.py update hosts.csv
    python zabbix-bulk-hosts.py delete hosts.csv
    python zabbix-bulk-hosts.py export output.csv [--group GROUP_NAME]

Environment variables:
    ZABBIX_URL - Zabbix frontend URL (default: http://localhost/zabbix)
    ZABBIX_TOKEN - API token (preferred)
    ZABBIX_USER - Username (fallback)
    ZABBIX_PASSWORD - Password (fallback)

CSV format for create/update:
    hostname,ip,groups,templates,description
    server01,192.168.1.100,Linux servers,Linux by Zabbix agent,Web server
"""

import os
import sys
import csv
import argparse
from zabbix_utils import ZabbixAPI

def get_api():
    url = os.environ.get("ZABBIX_URL", "http://localhost/zabbix")
    api = ZabbixAPI(url=url)

    if "ZABBIX_TOKEN" in os.environ:
        api.login(token=os.environ["ZABBIX_TOKEN"])
    elif "ZABBIX_USER" in os.environ:
        api.login(user=os.environ["ZABBIX_USER"],
                  password=os.environ.get("ZABBIX_PASSWORD", ""))
    else:
        print("Error: Set ZABBIX_TOKEN or ZABBIX_USER/ZABBIX_PASSWORD")
        sys.exit(1)
    return api

def resolve_groups(api, group_names):
    """Convert group names to group IDs."""
    groups = []
    for name in group_names.split(","):
        name = name.strip()
        result = api.hostgroup.get(filter={"name": name}, output=["groupid"])
        if result:
            groups.append({"groupid": result[0]["groupid"]})
        else:
            # Create group if not exists
            result = api.hostgroup.create(name=name)
            groups.append({"groupid": result["groupids"][0]})
    return groups

def resolve_templates(api, template_names):
    """Convert template names to template IDs."""
    templates = []
    for name in template_names.split(","):
        name = name.strip()
        if not name:
            continue
        result = api.template.get(filter={"host": name}, output=["templateid"])
        if result:
            templates.append({"templateid": result[0]["templateid"]})
        else:
            print(f"Warning: Template '{name}' not found")
    return templates

def create_hosts(api, csv_file):
    """Create hosts from CSV file."""
    with open(csv_file) as f:
        reader = csv.DictReader(f)
        for row in reader:
            hostname = row.get("hostname", "").strip()
            ip = row.get("ip", "").strip()

            if not hostname or not ip:
                print(f"Skipping row: missing hostname or ip")
                continue

            # Check if host exists
            existing = api.host.get(filter={"host": hostname}, output=["hostid"])
            if existing:
                print(f"Skip: {hostname} already exists")
                continue

            try:
                groups = resolve_groups(api, row.get("groups", "Discovered hosts"))
                templates = resolve_templates(api, row.get("templates", ""))

                params = {
                    "host": hostname,
                    "groups": groups,
                    "interfaces": [{
                        "type": 1,
                        "main": 1,
                        "useip": 1,
                        "ip": ip,
                        "dns": "",
                        "port": "10050"
                    }]
                }

                if templates:
                    params["templates"] = templates
                if row.get("description"):
                    params["description"] = row["description"]

                result = api.host.create(**params)
                print(f"Created: {hostname} (hostid={result['hostids'][0]})")

            except Exception as e:
                print(f"Error creating {hostname}: {e}")

def update_hosts(api, csv_file):
    """Update existing hosts from CSV file."""
    with open(csv_file) as f:
        reader = csv.DictReader(f)
        for row in reader:
            hostname = row.get("hostname", "").strip()
            if not hostname:
                continue

            existing = api.host.get(filter={"host": hostname}, output=["hostid"])
            if not existing:
                print(f"Skip: {hostname} not found")
                continue

            hostid = existing[0]["hostid"]

            try:
                params = {"hostid": hostid}

                if row.get("groups"):
                    params["groups"] = resolve_groups(api, row["groups"])
                if row.get("templates"):
                    params["templates"] = resolve_templates(api, row["templates"])
                if row.get("description"):
                    params["description"] = row["description"]

                api.host.update(**params)
                print(f"Updated: {hostname}")

            except Exception as e:
                print(f"Error updating {hostname}: {e}")

def delete_hosts(api, csv_file):
    """Delete hosts from CSV file."""
    with open(csv_file) as f:
        reader = csv.DictReader(f)
        for row in reader:
            hostname = row.get("hostname", "").strip()
            if not hostname:
                continue

            existing = api.host.get(filter={"host": hostname}, output=["hostid"])
            if not existing:
                print(f"Skip: {hostname} not found")
                continue

            try:
                api.host.delete(existing[0]["hostid"])
                print(f"Deleted: {hostname}")
            except Exception as e:
                print(f"Error deleting {hostname}: {e}")

def export_hosts(api, csv_file, group_name=None):
    """Export hosts to CSV file."""
    params = {
        "output": ["host", "name", "description"],
        "selectInterfaces": ["ip"],
        "selectGroups": ["name"],
        "selectParentTemplates": ["host"]
    }

    if group_name:
        groups = api.hostgroup.get(filter={"name": group_name}, output=["groupid"])
        if groups:
            params["groupids"] = [groups[0]["groupid"]]

    hosts = api.host.get(**params)

    with open(csv_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["hostname", "ip", "groups", "templates", "description"])

        for host in hosts:
            ip = host["interfaces"][0]["ip"] if host.get("interfaces") else ""
            groups = ",".join(g["name"] for g in host.get("groups", []))
            templates = ",".join(t["host"] for t in host.get("parentTemplates", []))
            writer.writerow([
                host["host"],
                ip,
                groups,
                templates,
                host.get("description", "")
            ])

    print(f"Exported {len(hosts)} hosts to {csv_file}")

def main():
    parser = argparse.ArgumentParser(description="Bulk host management for Zabbix")
    parser.add_argument("action", choices=["create", "update", "delete", "export"])
    parser.add_argument("csv_file", help="CSV file path")
    parser.add_argument("--group", help="Filter by group name (for export)")
    args = parser.parse_args()

    api = get_api()

    if args.action == "create":
        create_hosts(api, args.csv_file)
    elif args.action == "update":
        update_hosts(api, args.csv_file)
    elif args.action == "delete":
        delete_hosts(api, args.csv_file)
    elif args.action == "export":
        export_hosts(api, args.csv_file, args.group)

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Export and import Zabbix configuration.

Usage:
    python zabbix-export.py templates --output templates.json [--name "Template Name"]
    python zabbix-export.py hosts --output hosts.json [--group "Group Name"]
    python zabbix-export.py all --output config.json
    python zabbix-export.py import config.json

Environment variables:
    ZABBIX_URL - Zabbix frontend URL
    ZABBIX_TOKEN - API token
"""

import os
import sys
import json
import argparse
from zabbix_utils import ZabbixAPI

def get_api():
    url = os.environ.get("ZABBIX_URL", "http://localhost/zabbix")
    api = ZabbixAPI(url=url)

    if "ZABBIX_TOKEN" in os.environ:
        api.login(token=os.environ["ZABBIX_TOKEN"])
    elif "ZABBIX_USER" in os.environ:
        api.login(user=os.environ["ZABBIX_USER"],
                  password=os.environ.get("ZABBIX_PASSWORD", ""))
    else:
        print("Error: Set ZABBIX_TOKEN or ZABBIX_USER/ZABBIX_PASSWORD")
        sys.exit(1)
    return api

def export_templates(api, output_file, template_name=None):
    """Export templates to JSON."""
    params = {
        "output": "extend",
        "selectItems": "extend",
        "selectTriggers": "extend",
        "selectGraphs": "extend",
        "selectDiscoveryRules": "extend",
        "selectMacros": "extend",
        "selectTags": "extend"
    }

    if template_name:
        params["filter"] = {"host": template_name}

    templates = api.template.get(**params)

    with open(output_file, "w") as f:
        json.dump({"templates": templates}, f, indent=2)

    print(f"Exported {len(templates)} templates to {output_file}")

def export_hosts(api, output_file, group_name=None):
    """Export hosts to JSON."""
    params = {
        "output": "extend",
        "selectInterfaces": "extend",
        "selectGroups": ["groupid", "name"],
        "selectParentTemplates": ["templateid", "host"],
        "selectMacros": "extend",
        "selectTags": "extend",
        "selectInventory": "extend"
    }

    if group_name:
        groups = api.hostgroup.get(filter={"name": group_name}, output=["groupid"])
        if groups:
            params["groupids"] = [groups[0]["groupid"]]
        else:
            print(f"Warning: Group '{group_name}' not found")

    hosts = api.host.get(**params)

    with open(output_file, "w") as f:
        json.dump({"hosts": hosts}, f, indent=2)

    print(f"Exported {len(hosts)} hosts to {output_file}")

def export_all(api, output_file):
    """Export all configuration."""
    config = {
        "version": api.api_version(),
        "host_groups": api.hostgroup.get(output="extend"),
        "templates": api.template.get(
            output="extend",
            selectItems=["itemid", "name", "key_"],
            selectTriggers=["triggerid", "description"],
            selectMacros="extend"
        ),
        "hosts": api.host.get(
            output="extend",
            selectInterfaces="extend",
            selectGroups=["groupid", "name"],
            selectParentTemplates=["templateid", "host"],
            selectMacros="extend"
        ),
        "actions": api.action.get(
            output="extend",
            selectOperations="extend",
            selectFilter="extend"
        ),
        "media_types": api.mediatype.get(output="extend"),
        "users": api.user.get(output=["userid", "username", "name", "surname"])
    }

    with open(output_file, "w") as f:
        json.dump(config, f, indent=2)

    print(f"Exported configuration to {output_file}")
    print(f"  Host groups: {len(config['host_groups'])}")
    print(f"  Templates: {len(config['templates'])}")
    print(f"  Hosts: {len(config['hosts'])}")
    print(f"  Actions: {len(config['actions'])}")

def import_config(api, input_file):
    """Import configuration from JSON (hosts only for safety)."""
    with open(input_file) as f:
        config = json.load(f)

    if "hosts" in config:
        for host_data in config["hosts"]:
            hostname = host_data.get("host")

            # Check if exists
            existing = api.host.get(filter={"host": hostname}, output=["hostid"])
            if existing:
                print(f"Skip: {hostname} already exists")
                continue

            try:
                # Prepare minimal host creation
                groups = [{"groupid": g["groupid"]} for g in host_data.get("groups", [])]
                if not groups:
                    # Use default group
                    groups = [{"groupid": "2"}]

                interfaces = host_data.get("interfaces", [])
                if interfaces:
                    # Clean interface data
                    interfaces = [{
                        "type": int(i.get("type", 1)),
                        "main": int(i.get("main", 1)),
                        "useip": int(i.get("useip", 1)),
                        "ip": i.get("ip", ""),
                        "dns": i.get("dns", ""),
                        "port": i.get("port", "10050")
                    } for i in interfaces]

                params = {
                    "host": hostname,
                    "groups": groups,
                    "interfaces": interfaces
                }

                templates = host_data.get("parentTemplates", [])
                if templates:
                    params["templates"] = [{"templateid": t["templateid"]} for t in templates]

                api.host.create(**params)
                print(f"Imported: {hostname}")

            except Exception as e:
                print(f"Error importing {hostname}: {e}")

    print("Import complete")

def main():
    parser = argparse.ArgumentParser(description="Export/import Zabbix configuration")
    subparsers = parser.add_subparsers(dest="command", required=True)

    # Templates export
    tpl_parser = subparsers.add_parser("templates", help="Export templates")
    tpl_parser.add_argument("--output", "-o", required=True, help="Output file")
    tpl_parser.add_argument("--name", help="Template name filter")

    # Hosts export
    host_parser = subparsers.add_parser("hosts", help="Export hosts")
    host_parser.add_argument("--output", "-o", required=True, help="Output file")
    host_parser.add_argument("--group", help="Group name filter")

    # All export
    all_parser = subparsers.add_parser("all", help="Export all configuration")
    all_parser.add_argument("--output", "-o", required=True, help="Output file")

    # Import
    import_parser = subparsers.add_parser("import", help="Import configuration")
    import_parser.add_argument("file", help="Input file")

    args = parser.parse_args()
    api = get_api()

    if args.command == "templates":
        export_templates(api, args.output, args.name)
    elif args.command == "hosts":
        export_hosts(api, args.output, args.group)
    elif args.command == "all":
        export_all(api, args.output)
    elif args.command == "import":
        import_config(api, args.file)

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Maintenance window management for Zabbix.

Usage:
    python zabbix-maintenance.py create --name "Weekly Maintenance" --hosts host1,host2 --duration 3600
    python zabbix-maintenance.py create --name "Patching" --groups "Linux servers" --start "2024-01-15 02:00" --duration 7200
    python zabbix-maintenance.py list [--active]
    python zabbix-maintenance.py delete --name "Weekly Maintenance"
    python zabbix-maintenance.py delete --id 123

Environment variables:
    ZABBIX_URL - Zabbix frontend URL
    ZABBIX_TOKEN - API token
"""

import os
import sys
import argparse
import time
from datetime import datetime
from zabbix_utils import ZabbixAPI

def get_api():
    url = os.environ.get("ZABBIX_URL", "http://localhost/zabbix")
    api = ZabbixAPI(url=url)

    if "ZABBIX_TOKEN" in os.environ:
        api.login(token=os.environ["ZABBIX_TOKEN"])
    elif "ZABBIX_USER" in os.environ:
        api.login(user=os.environ["ZABBIX_USER"],
                  password=os.environ.get("ZABBIX_PASSWORD", ""))
    else:
        print("Error: Set ZABBIX_TOKEN or ZABBIX_USER/ZABBIX_PASSWORD")
        sys.exit(1)
    return api

def parse_datetime(dt_str):
    """Parse datetime string to Unix timestamp."""
    if dt_str is None:
        return int(time.time())

    for fmt in ["%Y-%m-%d %H:%M", "%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M"]:
        try:
            return int(datetime.strptime(dt_str, fmt).timestamp())
        except ValueError:
            continue

    raise ValueError(f"Cannot parse datetime: {dt_str}")

def resolve_host_ids(api, host_names):
    """Convert host names to host IDs."""
    host_ids = []
    for name in host_names.split(","):
        name = name.strip()
        result = api.host.get(filter={"host": name}, output=["hostid"])
        if result:
            host_ids.append(result[0]["hostid"])
        else:
            print(f"Warning: Host '{name}' not found")
    return host_ids

def resolve_group_ids(api, group_names):
    """Convert group names to group IDs."""
    group_ids = []
    for name in group_names.split(","):
        name = name.strip()
        result = api.hostgroup.get(filter={"name": name}, output=["groupid"])
        if result:
            group_ids.append(result[0]["groupid"])
        else:
            print(f"Warning: Group '{name}' not found")
    return group_ids

def create_maintenance(api, args):
    """Create a maintenance window."""
    start_time = parse_datetime(args.start)
    duration = int(args.duration)
    end_time = start_time + duration

    params = {
        "name": args.name,
        "active_since": start_time,
        "active_till": end_time,
        "timeperiods": [{
            "timeperiod_type": 0,  # One-time
            "start_date": start_time,
            "period": duration
        }]
    }

    # Add hosts or groups
    if args.hosts:
        host_ids = resolve_host_ids(api, args.hosts)
        if host_ids:
            params["hostids"] = host_ids

    if args.groups:
        group_ids = resolve_group_ids(api, args.groups)
        if group_ids:
            params["groupids"] = group_ids

    if not params.get("hostids") and not params.get("groupids"):
        print("Error: Must specify --hosts or --groups")
        sys.exit(1)

    # Maintenance type
    if args.no_data:
        params["maintenance_type"] = 1  # No data collection
    else:
        params["maintenance_type"] = 0  # With data collection

    # Description
    if args.description:
        params["description"] = args.description

    try:
        result = api.maintenance.create(**params)
        print(f"Created maintenance: {args.name} (id={result['maintenanceids'][0]})")
        print(f"  Start: {datetime.fromtimestamp(start_time)}")
        print(f"  End: {datetime.fromtimestamp(end_time)}")
        print(f"  Duration: {duration}s ({duration//3600}h {(duration%3600)//60}m)")
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)

def list_maintenance(api, args):
    """List maintenance windows."""
    params = {
        "output": ["maintenanceid", "name", "active_since", "active_till",
                   "maintenance_type", "description"],
        "selectHosts": ["host"],
        "selectGroups": ["name"]
    }

    maintenances = api.maintenance.get(**params)

    now = int(time.time())

    for m in maintenances:
        start = int(m["active_since"])
        end = int(m["active_till"])

        # Filter active only if requested
        if args.active and (now < start or now > end):
            continue

        status = "ACTIVE" if start <= now <= end else ("PENDING" if now < start else "EXPIRED")
        mtype = "No data" if m["maintenance_type"] == "1" else "With data"

        print(f"\n[{m['maintenanceid']}] {m['name']} ({status})")
        print(f"  Type: {mtype}")
        print(f"  Start: {datetime.fromtimestamp(start)}")
        print(f"  End: {datetime.fromtimestamp(end)}")

        if m.get("hosts"):
            hosts = [h["host"] for h in m["hosts"]]
            print(f"  Hosts: {', '.join(hosts)}")

        if m.get("groups"):
            groups = [g["name"] for g in m["groups"]]
            print(f"  Groups: {', '.join(groups)}")

def delete_maintenance(api, args):
    """Delete maintenance window."""
    if args.id:
        maintenance_id = args.id
    elif args.name:
        result = api.maintenance.get(filter={"name": args.name},
                                     output=["maintenanceid"])
        if not result:
            print(f"Error: Maintenance '{args.name}' not found")
            sys.exit(1)
        maintenance_id = result[0]["maintenanceid"]
    else:
        print("Error: Must specify --id or --name")
        sys.exit(1)

    try:
        api.maintenance.delete(maintenance_id)
        print(f"Deleted maintenance: {maintenance_id}")
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)

def main():
    parser = argparse.ArgumentParser(description="Zabbix maintenance management")
    subparsers = parser.add_subparsers(dest="command", required=True)

    # Create command
    create_parser = subparsers.add_parser("create", help="Create maintenance window")
    create_parser.add_argument("--name", required=True, help="Maintenance name")
    create_parser.add_argument("--hosts", help="Comma-separated host names")
    create_parser.add_argument("--groups", help="Comma-separated group names")
    create_parser.add_argument("--start", help="Start time (YYYY-MM-DD HH:MM), default: now")
    create_parser.add_argument("--duration", required=True, help="Duration in seconds")
    create_parser.add_argument("--description", help="Description")
    create_parser.add_argument("--no-data", action="store_true",
                               help="Disable data collection during maintenance")

    # List command
    list_parser = subparsers.add_parser("list", help="List maintenance windows")
    list_parser.add_argument("--active", action="store_true", help="Show only active")

    # Delete command
    delete_parser = subparsers.add_parser("delete", help="Delete maintenance window")
    delete_parser.add_argument("--id", help="Maintenance ID")
    delete_parser.add_argument("--name", help="Maintenance name")

    args = parser.parse_args()
    api = get_api()

    if args.command == "create":
        create_maintenance(api, args)
    elif args.command == "list":
        list_maintenance(api, args)
    elif args.command == "delete":
        delete_maintenance(api, args)

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Zabbix environment diagnostics and status check.

Usage:
    python zabbix-status.py           # Full status report
    python zabbix-status.py problems  # Current problems only
    python zabbix-status.py hosts     # Host status summary
    python zabbix-status.py queue     # Queue status

Environment variables:
    ZABBIX_URL - Zabbix frontend URL
    ZABBIX_TOKEN - API token
"""

import os
import sys
import argparse
from datetime import datetime
from zabbix_utils import ZabbixAPI

def get_api():
    url = os.environ.get("ZABBIX_URL", "http://localhost/zabbix")
    api = ZabbixAPI(url=url)

    if "ZABBIX_TOKEN" in os.environ:
        api.login(token=os.environ["ZABBIX_TOKEN"])
    elif "ZABBIX_USER" in os.environ:
        api.login(user=os.environ["ZABBIX_USER"],
                  password=os.environ.get("ZABBIX_PASSWORD", ""))
    else:
        print("Error: Set ZABBIX_TOKEN or ZABBIX_USER/ZABBIX_PASSWORD")
        sys.exit(1)
    return api

SEVERITY_NAMES = {
    "0": "Not classified",
    "1": "Information",
    "2": "Warning",
    "3": "Average",
    "4": "High",
    "5": "Disaster"
}

SEVERITY_COLORS = {
    "0": "\033[90m",  # Gray
    "1": "\033[94m",  # Blue
    "2": "\033[93m",  # Yellow
    "3": "\033[33m",  # Orange
    "4": "\033[91m",  # Light red
    "5": "\033[31m",  # Red
}
RESET = "\033[0m"

def show_problems(api, limit=50):
    """Show current problems."""
    problems = api.problem.get(
        output=["eventid", "name", "severity", "clock", "acknowledged"],
        selectHosts=["host"],
        recent=True,
        sortfield=["severity", "clock"],
        sortorder=["DESC", "DESC"],
        limit=limit
    )

    if not problems:
        print("✓ No active problems")
        return

    print(f"\n{'='*60}")
    print(f"ACTIVE PROBLEMS ({len(problems)})")
    print(f"{'='*60}")

    # Group by severity
    by_severity = {}
    for p in problems:
        sev = p["severity"]
        if sev not in by_severity:
            by_severity[sev] = []
        by_severity[sev].append(p)

    for sev in sorted(by_severity.keys(), reverse=True):
        color = SEVERITY_COLORS.get(sev, "")
        sev_name = SEVERITY_NAMES.get(sev, "Unknown")
        print(f"\n{color}[{sev_name}]{RESET}")

        for p in by_severity[sev]:
            host = p["hosts"][0]["host"] if p.get("hosts") else "Unknown"
            time_str = datetime.fromtimestamp(int(p["clock"])).strftime("%Y-%m-%d %H:%M")
            ack = "✓" if p["acknowledged"] == "1" else " "
            print(f"  {ack} [{time_str}] {host}: {p['name']}")

def show_hosts_status(api):
    """Show host status summary."""
    hosts = api.host.get(
        output=["hostid", "host", "name", "status", "available"],
        selectInterfaces=["ip", "available"]
    )

    total = len(hosts)
    enabled = sum(1 for h in hosts if h["status"] == "0")
    disabled = total - enabled

    available = sum(1 for h in hosts if h.get("available") == "1")
    unavailable = sum(1 for h in hosts if h.get("available") == "2")
    unknown = total - available - unavailable

    print(f"\n{'='*40}")
    print("HOST STATUS")
    print(f"{'='*40}")
    print(f"Total hosts:      {total}")
    print(f"  Enabled:        {enabled}")
    print(f"  Disabled:       {disabled}")
    print(f"\nAgent availability:")
    print(f"  Available:      {available}")
    print(f"  Unavailable:    {unavailable}")
    print(f"  Unknown:        {unknown}")

    # Show unavailable hosts
    unavailable_hosts = [h for h in hosts if h.get("available") == "2"]
    if unavailable_hosts:
        print(f"\nUnavailable hosts ({len(unavailable_hosts)}):")
        for h in unavailable_hosts[:10]:
            ip = h["interfaces"][0]["ip"] if h.get("interfaces") else "N/A"
            print(f"  - {h['host']} ({ip})")
        if len(unavailable_hosts) > 10:
            print(f"  ... and {len(unavailable_hosts) - 10} more")

def show_queue(api):
    """Show item queue status."""
    # Get items not yet processed
    try:
        # This requires specific permissions
        queue = api.queue.get(output="extend")

        if not queue:
            print("✓ Queue is empty")
            return

        print(f"\n{'='*40}")
        print("QUEUE STATUS")
        print(f"{'='*40}")

        # Group by delay
        delays = {}
        for item in queue:
            delay = int(item.get("delay", 0))
            if delay not in delays:
                delays[delay] = 0
            delays[delay] += 1

        for delay in sorted(delays.keys()):
            print(f"  {delay}s+ delay: {delays[delay]} items")

    except Exception as e:
        print(f"Queue status unavailable: {e}")

def show_full_status(api):
    """Show full environment status."""
    print(f"\n{'='*60}")
    print("ZABBIX ENVIRONMENT STATUS")
    print(f"{'='*60}")

    # API info
    version = api.api_version()
    print(f"API Version: {version}")
    print(f"URL: {os.environ.get('ZABBIX_URL', 'http://localhost/zabbix')}")

    # Counts
    hosts = api.host.get(countOutput=True)
    templates = api.template.get(countOutput=True)
    items = api.item.get(countOutput=True, monitored=True)
    triggers = api.trigger.get(countOutput=True, monitored=True)

    print(f"\nObject counts:")
    print(f"  Hosts:     {hosts}")
    print(f"  Templates: {templates}")
    print(f"  Items:     {items}")
    print(f"  Triggers:  {triggers}")

    # Problems summary
    problems = api.problem.get(countOutput=True, recent=True)
    print(f"\nActive problems: {problems}")

    # Show details
    show_hosts_status(api)
    show_problems(api, limit=20)

def main():
    parser = argparse.ArgumentParser(description="Zabbix status check")
    parser.add_argument("command", nargs="?", default="full",
                       choices=["full", "problems", "hosts", "queue"],
                       help="Status type (default: full)")
    parser.add_argument("--limit", type=int, default=50,
                       help="Limit results (for problems)")

    args = parser.parse_args()
    api = get_api()

    if args.command == "full":
        show_full_status(api)
    elif args.command == "problems":
        show_problems(api, args.limit)
    elif args.command == "hosts":
        show_hosts_status(api)
    elif args.command == "queue":
        show_queue(api)

if __name__ == "__main__":
    main()