from __future__ import annotations

import unittest
from unittest.mock import patch

from app.api.routes.ops import (
    ops_migration_execute,
    ops_migration_preview,
    ops_migration_source_profile,
    ops_doctor_decision,
    ops_go_live_bundle,
    ops_go_live_review,
    ops_go_live_signoff,
    ops_go_live_summary,
)


class OpsApiRoutesTestCase(unittest.TestCase):
    @patch("app.api.routes.ops.get_ops_migration_source_profile")
    def test_migration_source_profile_route_returns_payload(self, mock_source_profile) -> None:
        mock_source_profile.return_value = {"source_node": {"node_code": "overseas-control-01"}}

        response = ops_migration_source_profile()

        self.assertEqual(0, response.code)
        self.assertEqual("overseas-control-01", response.data["source_node"]["node_code"])
        mock_source_profile.assert_called_once_with()

    @patch("app.api.routes.ops.preview_ops_migration")
    def test_migration_preview_route_passes_payload(self, mock_preview_ops_migration) -> None:
        mock_preview_ops_migration.return_value = (True, "ok", {"plan_steps": [{"key": "sync_env_files"}]})

        payload = {"target_node_code": "node-a"}
        response = ops_migration_preview(payload)

        self.assertEqual(0, response.code)
        self.assertEqual("sync_env_files", response.data["plan_steps"][0]["key"])
        mock_preview_ops_migration.assert_called_once_with(payload)

    @patch("app.api.routes.ops.execute_ops_migration")
    def test_migration_execute_route_returns_error_payload(self, mock_execute_ops_migration) -> None:
        mock_execute_ops_migration.return_value = (False, "failed", {"blocking_reasons": ["ssh missing"]})

        payload = {"target_node_code": "node-a"}
        response = ops_migration_execute(payload)

        self.assertEqual(1, response.code)
        self.assertEqual("failed", response.message)
        self.assertEqual(["ssh missing"], response.data["blocking_reasons"])
        mock_execute_ops_migration.assert_called_once_with(payload)

    @patch("app.api.routes.ops.get_ops_go_live_signoff")
    def test_go_live_signoff_route_uses_service_payload(self, mock_get_ops_go_live_signoff) -> None:
        mock_get_ops_go_live_signoff.return_value = {
            "signoff_status": "ready",
            "headline": "ok",
        }

        response = ops_go_live_signoff(base_url="http://127.0.0.1:8100", report_dir="/tmp/signoff")

        self.assertEqual(0, response.code)
        self.assertEqual("ready", response.data["signoff_status"])
        self.assertEqual("ok", response.data["headline"])
        mock_get_ops_go_live_signoff.assert_called_once_with(
            base_url="http://127.0.0.1:8100",
            report_dir="/tmp/signoff",
        )

    @patch("app.api.routes.ops.get_ops_go_live_summary")
    def test_go_live_summary_route_passes_base_url(self, mock_get_ops_go_live_summary) -> None:
        mock_get_ops_go_live_summary.return_value = {
            "go_live_status": "attention",
        }

        response = ops_go_live_summary(base_url="http://example.test")

        self.assertEqual(0, response.code)
        self.assertEqual("attention", response.data["go_live_status"])
        mock_get_ops_go_live_summary.assert_called_once_with(base_url="http://example.test")

    @patch("app.api.routes.ops.get_ops_go_live_bundle")
    def test_go_live_bundle_route_passes_base_url_and_report_dir(self, mock_get_ops_go_live_bundle) -> None:
        mock_get_ops_go_live_bundle.return_value = {
            "status": "missing",
        }

        response = ops_go_live_bundle(base_url="http://example.test", report_dir="/tmp/go-live")

        self.assertEqual(0, response.code)
        self.assertEqual("missing", response.data["status"])
        mock_get_ops_go_live_bundle.assert_called_once_with(
            base_url="http://example.test",
            report_dir="/tmp/go-live",
        )

    @patch("app.api.routes.ops.get_ops_go_live_review")
    def test_go_live_review_route_passes_base_url_and_report_dir(self, mock_get_ops_go_live_review) -> None:
        mock_get_ops_go_live_review.return_value = {
            "status": "attention",
            "headline": "review",
        }

        response = ops_go_live_review(base_url="http://example.test", report_dir="/tmp/review")

        self.assertEqual(0, response.code)
        self.assertEqual("attention", response.data["status"])
        self.assertEqual("review", response.data["headline"])
        mock_get_ops_go_live_review.assert_called_once_with(
            base_url="http://example.test",
            report_dir="/tmp/review",
        )

    @patch("app.api.routes.ops.get_ops_doctor_decision")
    def test_doctor_decision_route_passes_base_url_and_report_dir(self, mock_get_ops_doctor_decision) -> None:
        mock_get_ops_doctor_decision.return_value = {
            "status": "attention",
            "headline": "doctor",
        }

        response = ops_doctor_decision(base_url="http://example.test", report_dir="/tmp/doctor")

        self.assertEqual(0, response.code)
        self.assertEqual("attention", response.data["status"])
        self.assertEqual("doctor", response.data["headline"])
        mock_get_ops_doctor_decision.assert_called_once_with(
            base_url="http://example.test",
            report_dir="/tmp/doctor",
        )


if __name__ == "__main__":
    unittest.main()