import json
import os
import signal
import socket
import sqlite3
import subprocess
import threading
import time
from pathlib import Path

from fastapi import FastAPI

DB_FILE = Path("/opt/appfactory/data/appfactory/appfactory.db")
TOOLS_DIR = Path("/tools")
SCRIPTS_DIR = Path("/opt/appfactory/workspace/appfactory-tools/scripts")
MAINTENANCE_DIR = Path("/opt/appfactory/workspace/appfactory-tools/maintenance")
ALERTS_DIR = Path("/opt/appfactory/workspace/appfactory-tools/alerts")

WORKER_ID = os.getenv("APPFACTORY_WORKER_ID", socket.gethostname())
POLL_SECONDS = int(os.getenv("APPFACTORY_WORKER_POLL_SECONDS", "3"))
HEARTBEAT_SECONDS = int(os.getenv("APPFACTORY_WORKER_HEARTBEAT_SECONDS", "10"))
CANCEL_CHECK_SECONDS = int(os.getenv("APPFACTORY_CANCEL_CHECK_SECONDS", "2"))
LOG_FLUSH_CHARS = int(os.getenv("APPFACTORY_LOG_FLUSH_CHARS", "8000"))
STREAM_JOIN_TIMEOUT = int(os.getenv("APPFACTORY_STREAM_JOIN_TIMEOUT", "60"))

app = FastAPI(title="AppFactory Worker")

_worker_thread = None
_heartbeat_thread = None
_worker_started = False


def get_connection():
    con = sqlite3.connect(DB_FILE, timeout=30)
    con.row_factory = sqlite3.Row
    return con


def append_job_log(job_id: int, stream: str, message: str):
    con = get_connection()
    con.execute(
        """
        INSERT INTO job_logs (job_id, stream, message, created_at)
        VALUES (?, ?, ?, CURRENT_TIMESTAMP)
        """,
        (job_id, stream, message),
    )
    con.commit()
    con.close()


def get_job_status(job_id: int) -> str | None:
    con = get_connection()
    row = con.execute(
        "SELECT status FROM jobs WHERE id = ?",
        (job_id,),
    ).fetchone()
    con.close()

    if not row:
        return None

    return row["status"]


def update_worker_status(current_job_id=None):
    con = get_connection()

    con.execute(
        """
        INSERT INTO workers (
            id,
            status,
            started_at,
            last_seen_at,
            current_job_id,
            metadata_json
        )
        VALUES (
            ?,
            'online',
            CURRENT_TIMESTAMP,
            CURRENT_TIMESTAMP,
            ?,
            ?
        )
        ON CONFLICT(id)
        DO UPDATE SET
            status = 'online',
            last_seen_at = CURRENT_TIMESTAMP,
            current_job_id = excluded.current_job_id,
            metadata_json = excluded.metadata_json
        """,
        (
            WORKER_ID,
            current_job_id,
            json.dumps(
                {
                    "poll_seconds": POLL_SECONDS,
                    "heartbeat_seconds": HEARTBEAT_SECONDS,
                    "cancel_check_seconds": CANCEL_CHECK_SECONDS,
                },
                ensure_ascii=False,
            ),
        ),
    )

    con.commit()
    con.close()


def heartbeat_loop():
    while True:
        try:
            update_worker_status()
        except Exception as exc:
            print(f"Heartbeat error: {exc}", flush=True)

        time.sleep(HEARTBEAT_SECONDS)


def cleanup_stale_locks():
    con = get_connection()

    con.execute(
        """
        DELETE FROM deployment_locks
        WHERE expires_at IS NOT NULL
          AND expires_at < CURRENT_TIMESTAMP
        """
    )

    con.commit()
    con.close()


def acquire_lock(job: dict) -> bool:
    con = get_connection()

    try:
        con.execute(
            """
            INSERT INTO deployment_locks (
                target_type,
                target_id,
                job_id,
                worker_id,
                acquired_at,
                expires_at
            )
            VALUES (
                ?,
                ?,
                ?,
                ?,
                CURRENT_TIMESTAMP,
                datetime('now', '+30 minutes')
            )
            """,
            (
                job.get("target_type") or job["type"],
                job["target_id"],
                job["id"],
                WORKER_ID,
            ),
        )

        con.commit()
        return True

    except sqlite3.IntegrityError:
        return False

    finally:
        con.close()


def release_lock(job: dict):
    con = get_connection()

    con.execute(
        """
        DELETE FROM deployment_locks
        WHERE target_type = ?
          AND target_id = ?
          AND job_id = ?
        """,
        (
            job.get("target_type") or job["type"],
            job["target_id"],
            job["id"],
        ),
    )

    con.commit()
    con.close()


def extend_lock(job: dict):
    con = get_connection()

    con.execute(
        """
        UPDATE deployment_locks
        SET expires_at = datetime('now', '+30 minutes')
        WHERE target_type = ?
          AND target_id = ?
          AND job_id = ?
        """,
        (
            job.get("target_type") or job["type"],
            job["target_id"],
            job["id"],
        ),
    )

    con.commit()
    con.close()


def recover_stale_jobs():
    con = get_connection()

    rows = con.execute(
        """
        SELECT id
        FROM jobs
        WHERE status IN ('running', 'cancelled_requested')
          AND started_at < datetime('now', '-15 minutes')
        """
    ).fetchall()

    for row in rows:
        job_id = row["id"]

        con.execute(
            """
            UPDATE jobs
            SET status = 'failed',
                finished_at = CURRENT_TIMESTAMP,
                error_text = 'Worker recovery: stale running job'
            WHERE id = ?
            """,
            (job_id,),
        )

        con.execute(
            """
            INSERT INTO job_logs (job_id, stream, message, created_at)
            VALUES (?, 'system', 'Worker recovery marked stale running job as failed', CURRENT_TIMESTAMP)
            """,
            (job_id,),
        )

        con.execute(
            """
            DELETE FROM deployment_locks
            WHERE job_id = ?
            """,
            (job_id,),
        )

    con.commit()
    con.close()


def update_job_status(job_id: int, status: str, error_text: str | None = None, result: dict | None = None):
    con = get_connection()

    if status == "running":
        con.execute(
            """
            UPDATE jobs
            SET status = 'running',
                started_at = COALESCE(started_at, CURRENT_TIMESTAMP),
                worker_id = ?
            WHERE id = ?
            """,
            (WORKER_ID, job_id),
        )
    elif status in ("success", "failed", "cancelled"):
        con.execute(
            """
            UPDATE jobs
            SET status = ?,
                finished_at = CURRENT_TIMESTAMP,
                error_text = ?,
                result_json = ?
            WHERE id = ?
            """,
            (
                status,
                error_text,
                json.dumps(result or {}, ensure_ascii=False),
                job_id,
            ),
        )

    con.commit()
    con.close()


def get_next_job():
    con = get_connection()

    con.execute("BEGIN IMMEDIATE")

    row = con.execute(
        """
        SELECT *
        FROM jobs
        WHERE status = 'queued'
        ORDER BY id ASC
        LIMIT 1
        """
    ).fetchone()

    if not row:
        con.commit()
        con.close()
        return None

    job_id = row["id"]

    con.execute(
        """
        UPDATE jobs
        SET status = 'running',
            started_at = CURRENT_TIMESTAMP,
            worker_id = ?
        WHERE id = ?
          AND status = 'queued'
        """,
        (WORKER_ID, job_id),
    )

    con.commit()
    con.close()

    return dict(row)


def build_env(job: dict):
    payload = json.loads(job.get("payload_json") or "{}")

    env = os.environ.copy()
    env["APPFACTORY_TRIGGER_SOURCE"] = job.get("source") or "worker"
    env["APPFACTORY_TRIGGERED_BY_USER_ID"] = str(job.get("created_by_user_id") or "")
    env["APPFACTORY_TRIGGERED_BY_USERNAME"] = str(job.get("created_by_username") or "")
    env["APPFACTORY_TRIGGERED_BY_DISPLAY_NAME"] = str(job.get("created_by_display_name") or "")
    env["APPFACTORY_COMMIT_AUTHOR"] = str(payload.get("commit_author") or "")
    env["APPFACTORY_PUSHER"] = str(payload.get("pusher") or "")
    env["APPFACTORY_COMMIT_SHA"] = str(payload.get("commit_sha") or "")

    if job.get("type") == "run_alert_script":
        env["APPFACTORY_ALERT_EVENT_ID"] = str(payload.get("alert_event_id") or "")
        env["APPFACTORY_ALERT_RULE_ID"] = str(payload.get("rule_id") or "")
        env["APPFACTORY_ALERT_EVENT_TYPE"] = str(payload.get("event_type") or "")
        env["APPFACTORY_ALERT_SERVICE_ID"] = str(payload.get("service_id") or "")
        env["APPFACTORY_ALERT_INCIDENT_ID"] = str(payload.get("incident_id") or "")
        env["APPFACTORY_ALERT_PAYLOAD_JSON"] = json.dumps(payload.get("alert_payload") or {}, ensure_ascii=False)

    return env


def validate_script_name(script_name: str):
    if not script_name:
        raise ValueError("Missing script_name")

    if "/" in script_name or "\\" in script_name or ".." in script_name:
        raise ValueError("Invalid script name")

    if not script_name.endswith(".sh"):
        raise ValueError("Script must end with .sh")


def command_for_job(job: dict):
    job_type = job["type"]
    target_id = job["target_id"]

    if job_type == "deploy_app":
        return [str(TOOLS_DIR / "deploy-app.sh"), target_id]

    if job_type == "deploy_core_service":
        return [str(TOOLS_DIR / "deploy-core-service.sh"), target_id]

    if job_type == "run_script":
        payload = json.loads(job.get("payload_json") or "{}")
        script_name = payload.get("script_name") or target_id

        validate_script_name(script_name)

        candidate_dirs = [
            MAINTENANCE_DIR,
            SCRIPTS_DIR,
        ]

        script_path = None

        for base_dir in candidate_dirs:
            candidate = base_dir / script_name
            if candidate.exists() and candidate.is_file():
                script_path = candidate
                break

        if script_path is None:
            raise ValueError(f"Script not found: {script_name}")

        script_args = payload.get("args") or []

        if script_name == "delete-app.sh" and not script_args:
            script_args = [target_id]
        
        if isinstance(script_args, str):
            script_args = [script_args]
        
        if not isinstance(script_args, list):
            script_args = []
        
        return [str(script_path), *[str(arg) for arg in script_args]]

    if job_type == "run_alert_script":
        payload = json.loads(job.get("payload_json") or "{}")
        script_name = payload.get("script_name") or target_id

        validate_script_name(script_name)

        script_path = ALERTS_DIR / script_name

        if not script_path.exists():
            raise ValueError(f"Alert script not found: {script_name}")

        if not script_path.is_file():
            raise ValueError(f"Alert script is not a file: {script_name}")

        return [str(script_path)]

    raise ValueError(f"Unsupported job type: {job_type}")


def update_alert_event_from_job(job: dict, status: str, error_text: str | None):
    if job.get("type") != "run_alert_script":
        return

    payload = json.loads(job.get("payload_json") or "{}")
    alert_event_id = payload.get("alert_event_id")

    if not alert_event_id:
        return

    con = get_connection()

    if status == "success":
        alert_status = "success"
    elif status == "cancelled":
        alert_status = "cancelled"
    else:
        alert_status = "failed"

    con.execute(
        """
        UPDATE alert_events
        SET status = ?,
            error_text = ?,
            processed_at = CURRENT_TIMESTAMP
        WHERE id = ?
        """,
        (
            alert_status,
            error_text,
            alert_event_id,
        ),
    )

    con.commit()
    con.close()


class StreamPump:
    """Reads one subprocess stream in a background thread and stores it in the job log.

    The subprocess writes into an OS pipe with a limited buffer. If nobody reads
    the pipe while the process runs, the child blocks on write and never exits,
    so the worker would wait forever. This pump keeps both pipes drained from
    the moment the process starts.
    """

    def __init__(self, job_id: int, stream_name: str, stream):
        self.job_id = job_id
        self.stream_name = stream_name
        self.stream = stream
        self.length = 0
        self._buffer = []
        self._buffer_chars = 0
        self._lock = threading.Lock()
        self._thread = threading.Thread(
            target=self._run,
            name=f"job-{job_id}-{stream_name}",
            daemon=True,
        )

    def start(self):
        self._thread.start()

    def is_alive(self) -> bool:
        return self._thread.is_alive()

    def join(self, timeout: float | None = None):
        self._thread.join(timeout)

    def flush(self):
        # The lock is held across the write so that the reader thread and the
        # main loop cannot store two chunks of the same stream out of order.
        with self._lock:
            if not self._buffer:
                return

            message = "".join(self._buffer)
            self._buffer = []
            self._buffer_chars = 0

            try:
                append_job_log(self.job_id, self.stream_name, message)
            except Exception as exc:
                print(f"Job log write error ({self.stream_name}): {exc}", flush=True)

    def _run(self):
        try:
            for chunk in iter(self.stream.readline, ""):
                with self._lock:
                    self.length += len(chunk)
                    self._buffer.append(chunk)
                    self._buffer_chars += len(chunk)
                    should_flush = self._buffer_chars >= LOG_FLUSH_CHARS

                if should_flush:
                    self.flush()

        except Exception as exc:
            print(f"Stream reader error ({self.stream_name}): {exc}", flush=True)
            try:
                append_job_log(
                    self.job_id,
                    "system",
                    f"Error while reading {self.stream_name}: {exc}",
                )
            except Exception:
                pass

        finally:
            try:
                self.flush()
            except Exception:
                pass

            try:
                self.stream.close()
            except Exception:
                pass


def terminate_process_group(process: subprocess.Popen, job_id: int):
    append_job_log(job_id, "system", "Cancel requested. Terminating process group...")

    try:
        os.killpg(os.getpgid(process.pid), signal.SIGTERM)
        process.wait(timeout=10)
        append_job_log(job_id, "system", "Process group terminated.")
    except subprocess.TimeoutExpired:
        append_job_log(job_id, "system", "Process group did not terminate in time. Killing process group...")
        try:
            os.killpg(os.getpgid(process.pid), signal.SIGKILL)
        except Exception:
            process.kill()
        process.wait(timeout=10)
        append_job_log(job_id, "system", "Process group killed.")
    except Exception as exc:
        append_job_log(job_id, "stderr", f"Error while terminating process group: {exc}")
        try:
            process.kill()
            process.wait(timeout=10)
        except Exception as kill_exc:
            append_job_log(job_id, "stderr", f"Error while killing process: {kill_exc}")


def execute_job(job: dict):
    job_id = int(job["id"])
    target = job["target_id"]

    update_worker_status(current_job_id=job_id)
    append_job_log(job_id, "system", f"Worker {WORKER_ID} started job {job_id} for {target}")
    update_job_status(job_id, "running")

    try:
        command = command_for_job(job)
        env = build_env(job)

        append_job_log(job_id, "system", "Command: " + " ".join(command))

        process = subprocess.Popen(
            command,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            env=env,
            start_new_session=True,
        )

        stdout_pump = StreamPump(job_id, "stdout", process.stdout)
        stderr_pump = StreamPump(job_id, "stderr", process.stderr)

        stdout_pump.start()
        stderr_pump.start()

        cancelled = False

        try:
            while process.poll() is None:
                extend_lock(job)

                stdout_pump.flush()
                stderr_pump.flush()

                status = get_job_status(job_id)

                if status == "cancelled_requested":
                    terminate_process_group(process, job_id)
                    cancelled = True
                    break

                time.sleep(CANCEL_CHECK_SECONDS)

        finally:
            if process.poll() is None:
                terminate_process_group(process, job_id)

            returncode = process.wait()

            for pump in (stdout_pump, stderr_pump):
                pump.join(STREAM_JOIN_TIMEOUT)

                if pump.is_alive():
                    append_job_log(
                        job_id,
                        "system",
                        f"Stream {pump.stream_name} did not reach EOF within {STREAM_JOIN_TIMEOUT} s."
                        " Some output may be missing from the log.",
                    )

                pump.flush()

        if cancelled:
            update_job_status(
                job_id,
                "cancelled",
                error_text="Job cancelled by user request",
                result={"cancelled": True},
            )
            update_alert_event_from_job(job, "cancelled", "Job cancelled by user request")
            append_job_log(job_id, "system", "Job cancelled.")
            return

        if get_job_status(job_id) == "cancelled_requested":
            update_job_status(
                job_id,
                "cancelled",
                error_text="Job cancelled by user request",
                result={"returncode": returncode, "cancelled": True},
            )
            update_alert_event_from_job(job, "cancelled", "Job cancelled by user request")
            append_job_log(job_id, "system", "Job cancelled after process finished.")
            return

        if returncode == 0:
            update_job_status(
                job_id,
                "success",
                result={
                    "returncode": returncode,
                    "stdout_length": stdout_pump.length,
                    "stderr_length": stderr_pump.length,
                },
            )
            update_alert_event_from_job(job, "success", None)
            append_job_log(job_id, "system", "Job finished successfully")
        else:
            error_text = f"Command failed with return code {returncode}"
            update_job_status(
                job_id,
                "failed",
                error_text=error_text,
                result={"returncode": returncode},
            )
            update_alert_event_from_job(job, "failed", error_text)
            append_job_log(job_id, "system", f"Job failed with return code {returncode}")

    except Exception as exc:
        error_text = str(exc)
        update_job_status(job_id, "failed", error_text=error_text)
        update_alert_event_from_job(job, "failed", error_text)
        append_job_log(job_id, "stderr", error_text)

    finally:
        update_worker_status(current_job_id=None)


def worker_loop():
    while True:
        try:
            cleanup_stale_locks()
            recover_stale_jobs()

            job = get_next_job()

            if job:
                if not acquire_lock(job):
                    append_job_log(
                        int(job["id"]),
                        "system",
                        "Deployment lock is already held for this target. Re-queueing job.",
                    )

                    con = get_connection()
                    con.execute(
                        """
                        UPDATE jobs
                        SET status = 'queued',
                            started_at = NULL,
                            worker_id = NULL
                        WHERE id = ?
                        """,
                        (job["id"],),
                    )
                    con.commit()
                    con.close()

                    time.sleep(POLL_SECONDS)
                    continue

                try:
                    execute_job(job)
                finally:
                    release_lock(job)
            else:
                time.sleep(POLL_SECONDS)

        except Exception as exc:
            print(f"Worker loop error: {exc}", flush=True)
            time.sleep(POLL_SECONDS)


@app.on_event("startup")
def start_worker():
    global _worker_thread
    global _heartbeat_thread
    global _worker_started

    if _worker_started:
        return

    cleanup_stale_locks()
    recover_stale_jobs()
    update_worker_status(current_job_id=None)

    _worker_started = True

    _heartbeat_thread = threading.Thread(target=heartbeat_loop, daemon=True)
    _heartbeat_thread.start()

    _worker_thread = threading.Thread(target=worker_loop, daemon=True)
    _worker_thread.start()


@app.get("/health")
def health():
    return {
        "status": "ok",
        "worker_id": WORKER_ID,
        "poll_seconds": POLL_SECONDS,
        "heartbeat_seconds": HEARTBEAT_SECONDS,
        "cancel_check_seconds": CANCEL_CHECK_SECONDS,
    }