import os
import time

import requests
from prometheus_client import Gauge, start_http_server


API_TOKEN = os.getenv("SQLBAK_API_TOKEN")
CHECK_INTERVAL = int(os.getenv("CHECK_INTERVAL", "60"))
EXPORTER_PORT = int(os.getenv("EXPORTER_PORT", "8000"))

# How many hours back the exporter looks when reading job run history.
# Default: 168 hours = 7 days.
#
# The exporter may automatically extend this window when retention settings
# require checking older backups.
JOBRUNS_LOOKBACK_HOURS = int(os.getenv("JOBRUNS_LOOKBACK_HOURS", "168"))

BASE_URL = "https://sqlbak.com/public-api/v1"


# The exporter exposes the following Prometheus metrics:
#
# Server-level:
# - sqlbak_server_online
# - sqlbak_offline_servers_total
# - sqlbak_jobruns_available
# - sqlbak_jobsettings_available
# - sqlbak_last_check_timestamp
#
# Job-level:
# - sqlbak_job_retention_days
# - sqlbak_job_has_backups_older_than_policy
# - sqlbak_job_last_success_age_hours
# - sqlbak_job_backups_succeeded_total
# - sqlbak_job_backups_failed_total
# - sqlbak_job_backups_total
#
# Grafana helper:
# - sqlbak_job_summary


# ---------- Common metrics ----------

server_online = Gauge(
    "sqlbak_server_online",
    "Server online status (1=online, 0=offline)",
    ["server_id", "server_name", "app_type"]
)

offline_servers_gauge = Gauge(
    "sqlbak_offline_servers_total",
    "Number of offline servers"
)

jobruns_available_gauge = Gauge(
    "sqlbak_jobruns_available",
    "Whether jobruns endpoint is available (1=yes, 0=no)"
)

jobsettings_available_gauge = Gauge(
    "sqlbak_jobsettings_available",
    "Whether job settings endpoint is available (1=yes, 0=no)"
)

last_check_gauge = Gauge(
    "sqlbak_last_check_timestamp",
    "Last check timestamp"
)


# ---------- Per-job metrics ----------

job_retention_days_gauge = Gauge(
    "sqlbak_job_retention_days",
    "Retention policy in days for the job and backup type",
    ["server_name", "job_name", "job_id", "server_id", "backup_type"]
)

job_has_backups_older_than_policy_gauge = Gauge(
    "sqlbak_job_has_backups_older_than_policy",
    "Whether job has undeleted backups older than retention policy (1=yes, 0=no)",
    ["server_name", "job_name", "job_id", "server_id", "backup_type"]
)

job_last_success_age_hours_gauge = Gauge(
    "sqlbak_job_last_success_age_hours",
    "Hours since last successful backup for backup type",
    ["server_name", "job_name", "job_id", "server_id", "backup_type"]
)

job_success_count_gauge = Gauge(
    "sqlbak_job_backups_succeeded_total",
    "Number of successful backups in the inspected window",
    ["server_name", "job_name", "job_id", "server_id", "backup_type"]
)

job_failed_count_gauge = Gauge(
    "sqlbak_job_backups_failed_total",
    "Number of failed backups in the inspected window",
    ["server_name", "job_name", "job_id", "server_id", "backup_type"]
)

job_total_count_gauge = Gauge(
    "sqlbak_job_backups_total",
    "Total number of backups in the inspected window",
    ["server_name", "job_name", "job_id", "server_id", "backup_type"]
)

# sqlbak_job_summary is not a separate business metric.
# It duplicates selected values in a format that is easier to use in Grafana tables.
job_summary_gauge = Gauge(
    "sqlbak_job_summary",
    "Helper metric for building compact Grafana tables",
    ["row_key", "server_name", "job_name", "job_id", "server_id", "backup_type", "metric"]
)


def api_get(path, params=None):
    headers = {"X-SqlBak-Token": API_TOKEN}
    response = requests.get(
        f"{BASE_URL}{path}",
        headers=headers,
        params=params or {},
        timeout=30
    )
    response.raise_for_status()
    return response.json()


def get_all_servers():
    all_servers = []
    page = 1

    while True:
        payload = api_get("/servers", params={"page": page, "page_size": 100})
        data = payload.get("data", {})
        servers = data.get("list", [])

        all_servers.extend(servers)

        if not data.get("has_more"):
            break

        page += 1

    return all_servers


def get_all_jobs():
    all_jobs = []
    page = 1

    while True:
        payload = api_get("/jobs", params={"page": page, "page_size": 100})
        data = payload.get("data", {})
        jobs = data.get("list", [])

        all_jobs.extend(jobs)

        if not data.get("has_more"):
            break

        page += 1

    return all_jobs


def get_job_settings(job_id):
    payload = api_get(f"/jobs/{job_id}/settings")
    return payload.get("data", {})


def get_jobruns_for_job(job_id, started_after_ms):
    all_jobruns = []
    page = 1

    while True:
        payload = api_get(
            "/jobruns",
            params={
                "job_id": job_id,
                "started_after": started_after_ms,
                "page": page,
                "page_size": 100
            }
        )

        data = payload.get("data", {})
        jobruns = data.get("list", [])

        all_jobruns.extend(jobruns)

        if not data.get("has_more"):
            break

        page += 1

    return all_jobruns


def get_jobrun_details(jobrun_id):
    payload = api_get(f"/jobruns/{jobrun_id}")
    return payload.get("data", {})


# SqlBak API returns detailed backup type names.
# For Prometheus labels we normalize them to short values:
#
# database_full            -> full
# database_differential    -> diff
# database_transaction_log -> log
# database_incremental     -> inc
# folder                   -> folder
def normalize_backup_type(raw_value):
    v = str(raw_value or "").strip().lower()

    if v == "database_full":
        return "full"
    if v == "database_differential":
        return "diff"
    if v == "database_transaction_log":
        return "log"
    if v == "database_incremental":
        return "inc"
    if v == "folder":
        return "folder"

    return "unknown"


def get_enabled_backup_types_from_settings(job_settings):
    result = set()
    schedule = job_settings.get("schedule_settings") or {}

    if "database_full" in schedule:
        result.add("full")

    if (schedule.get("database_differential") or {}).get("is_enabled"):
        result.add("diff")

    if (schedule.get("database_transaction_log") or {}).get("is_enabled"):
        result.add("log")

    if (schedule.get("database_incremental") or {}).get("is_enabled"):
        result.add("inc")

    folders = job_settings.get("folders_backup_settings") or {}

    for raw_type in folders.get("backup_types", []):
        result.add(normalize_backup_type(raw_type))

    if not result:
        result.add("full")

    return sorted(result)


def months_days_to_days(months, days):
    try:
        m = int(months or 0)
    except (TypeError, ValueError):
        m = 0

    try:
        d = int(days or 0)
    except (TypeError, ValueError):
        d = 0

    return m * 30 + d


def get_retention_days_for_type(job_settings, backup_type):
    destinations = job_settings.get("destinations") or []
    values = []

    for dst in destinations:
        if backup_type == "full":
            days = months_days_to_days(
                dst.get("full_backups_keep_months"),
                dst.get("full_backups_keep_days")
            )
        elif backup_type in ("diff", "log", "inc"):
            days = months_days_to_days(
                dst.get("inc_backups_keep_months"),
                dst.get("inc_backups_keep_days")
            )
        else:
            days = 0

        values.append(days)

    return max(values) if values else 0


def has_not_deleted_files(backup_entry):
    uploads = backup_entry.get("uploads") or []
    found_file = False

    for upload in uploads:
        files = upload.get("files") or []

        for f in files:
            found_file = True

            if not bool(f.get("is_deleted", False)):
                return True

    if found_file:
        return False

    return str(backup_entry.get("status", "")).strip().lower() == "succeeded"


def update_server_metrics(servers):
    offline = 0
    server_online.clear()

    for s in servers:
        sid = str(s.get("id", ""))
        name = str(s.get("name", "unknown"))
        app = str(s.get("app_type", "unknown"))
        status = str(s.get("status", "")).strip().lower()

        val = 1 if status == "online" else 0

        if val == 0:
            offline += 1

        server_online.labels(
            server_id=sid,
            server_name=name,
            app_type=app
        ).set(val)

    offline_servers_gauge.set(offline)


def update_job_metrics(jobs, server_map):
    now_ms = int(time.time() * 1000)

    job_retention_days_gauge.clear()
    job_has_backups_older_than_policy_gauge.clear()
    job_last_success_age_hours_gauge.clear()
    job_success_count_gauge.clear()
    job_failed_count_gauge.clear()
    job_total_count_gauge.clear()
    job_summary_gauge.clear()

    jobsettings_available_gauge.set(1)
    jobruns_available_gauge.set(1)

    for job in jobs:
        job_id_raw = job.get("id")

        if not job_id_raw:
            continue

        job_id = str(job_id_raw)
        job_name = str(job.get("name", "unknown"))
        server_id = str(job.get("server_id", ""))
        server_name = server_map.get(server_id, "unknown")

        try:
            job_settings = get_job_settings(job_id_raw)
        except Exception as e:
            print(f"[WARN] failed to fetch job settings for job_id={job_id}: {e}")
            jobsettings_available_gauge.set(0)
            job_settings = {}

        enabled_backup_types = get_enabled_backup_types_from_settings(job_settings)

        retention_by_type = {
            bt: get_retention_days_for_type(job_settings, bt)
            for bt in enabled_backup_types
        }

        max_retention_days = max(retention_by_type.values() or [0])

        # Retention checks may require looking further back than JOBRUNS_LOOKBACK_HOURS.
        # For example, if retention is 30 days, the exporter needs job runs older than
        # 30 days to detect backups that should have been deleted.
        #
        # We add 7 extra days as a safety margin.
        effective_lookback_hours = max(
            JOBRUNS_LOOKBACK_HOURS,
            (max_retention_days + 7) * 24
        )

        started_after_ms = now_ms - effective_lookback_hours * 60 * 60 * 1000

        try:
            jobruns = get_jobruns_for_job(job_id_raw, started_after_ms)
        except Exception as e:
            print(f"[WARN] failed to fetch jobruns for job_id={job_id}: {e}")
            jobruns_available_gauge.set(0)
            jobruns = []

        stats = {}

        for bt in enabled_backup_types:
            stats[bt] = {
                "succeeded": 0,
                "failed": 0,
                "total": 0,
                "last_success_time": None,
                "has_old_backups": 0,
            }

        for jr in jobruns:
            jobrun_id = jr.get("id")

            if not jobrun_id:
                continue

            try:
                details = get_jobrun_details(jobrun_id)
            except Exception as e:
                print(f"[WARN] failed to fetch jobrun details jobrun_id={jobrun_id}: {e}")
                continue

            run_started_at = details.get("started_at")
            backups = details.get("backups") or []

            for b in backups:
                backup_type = normalize_backup_type(b.get("backup_type"))

                # This exporter focuses on database backups.
                # Folder backups are skipped in job-level statistics.
                if backup_type == "folder":
                    continue

                if backup_type not in stats:
                    stats[backup_type] = {
                        "succeeded": 0,
                        "failed": 0,
                        "total": 0,
                        "last_success_time": None,
                        "has_old_backups": 0,
                    }

                    if backup_type not in retention_by_type:
                        retention_by_type[backup_type] = get_retention_days_for_type(
                            job_settings,
                            backup_type
                        )

                backup_status = str(b.get("status", "")).strip().lower()
                stats[backup_type]["total"] += 1

                if backup_status == "succeeded":
                    stats[backup_type]["succeeded"] += 1

                    if isinstance(run_started_at, (int, float)):
                        last_success = stats[backup_type]["last_success_time"]

                        if last_success is None or run_started_at > last_success:
                            stats[backup_type]["last_success_time"] = run_started_at

                    retention_days = retention_by_type.get(backup_type, 0)

                    if isinstance(run_started_at, (int, float)):
                        age_days = (now_ms - run_started_at) / (1000 * 60 * 60 * 24)

                        if (
                            retention_days > 0
                            and age_days > retention_days
                            and has_not_deleted_files(b)
                        ):
                            stats[backup_type]["has_old_backups"] = 1

                elif backup_status == "failed":
                    stats[backup_type]["failed"] += 1

        all_backup_types = sorted(set(enabled_backup_types) | set(stats.keys()))

        for backup_type in all_backup_types:
            retention_days = int(retention_by_type.get(backup_type, 0))

            type_stats = stats.get(
                backup_type,
                {
                    "succeeded": 0,
                    "failed": 0,
                    "total": 0,
                    "last_success_time": None,
                    "has_old_backups": 0,
                }
            )

            last_success_time = type_stats.get("last_success_time")

            if last_success_time is not None:
                last_success_age_hours = (now_ms - last_success_time) / (1000 * 60 * 60)
            else:
                last_success_age_hours = -1

            label_values = {
                "server_name": server_name,
                "job_name": job_name,
                "job_id": job_id,
                "server_id": server_id,
                "backup_type": backup_type,
            }

            job_retention_days_gauge.labels(**label_values).set(retention_days)
            job_has_backups_older_than_policy_gauge.labels(**label_values).set(
                type_stats["has_old_backups"]
            )
            job_last_success_age_hours_gauge.labels(**label_values).set(
                last_success_age_hours
            )
            job_success_count_gauge.labels(**label_values).set(type_stats["succeeded"])
            job_failed_count_gauge.labels(**label_values).set(type_stats["failed"])
            job_total_count_gauge.labels(**label_values).set(type_stats["total"])

            row_key = f"{server_name}|{job_name}|{backup_type}"

            summary_labels = {
                "row_key": row_key,
                **label_values,
            }

            job_summary_gauge.labels(
                **summary_labels,
                metric="retention_days"
            ).set(retention_days)

            job_summary_gauge.labels(
                **summary_labels,
                metric="last_success_age_hours"
            ).set(last_success_age_hours)

            job_summary_gauge.labels(
                **summary_labels,
                metric="old_backups"
            ).set(type_stats["has_old_backups"])


def collect_metrics():
    servers = get_all_servers()
    jobs = get_all_jobs()

    server_map = {
        str(s.get("id")): str(s.get("name", "unknown"))
        for s in servers
    }

    update_server_metrics(servers)
    update_job_metrics(jobs, server_map)

    last_check_gauge.set(time.time())


def main():
    if not API_TOKEN:
        raise ValueError("Set SQLBAK_API_TOKEN env variable")

    start_http_server(EXPORTER_PORT)
    print(f"Exporter running on http://localhost:{EXPORTER_PORT}/metrics")

    while True:
        try:
            collect_metrics()
        except Exception as e:
            print(f"[ERROR] {e}")
            last_check_gauge.set(time.time())

        time.sleep(CHECK_INTERVAL)


if __name__ == "__main__":
    main()