#!/usr/bin/env bash
set -uo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# shellcheck disable=SC1091
source "${SCRIPT_DIR}/lib_ops_center.sh"
ops_center_load_config "${SCRIPT_DIR}"

MAINLAND_BASE_URL_DEFAULT="$(ops_center_resolve_mainland_api_base_url)"
OVERSEAS_BASE_URL_DEFAULT="$(ops_center_resolve_overseas_api_base_url)"
REPORT_ROOT_DEFAULT="${OPS_CENTER_REPORT_ROOT}/go-live-bundles"

REPORT_DIR_INPUT="${1:-}"
MAINLAND_BASE_URL_INPUT="${2:-}"
OVERSEAS_BASE_URL_INPUT="${3:-}"

timestamp_now() {
  date '+%Y%m%d_%H%M%S'
}

normalize_optional_base_url() {
  local raw_value="${1:-}"
  local fallback_value="${2:-}"
  if [[ -z "${raw_value}" ]]; then
    printf '%s' "${fallback_value}"
    return
  fi
  case "${raw_value}" in
    -|none|null|disabled)
      printf ''
      ;;
    *)
      printf '%s' "${raw_value}"
      ;;
  esac
}

if [[ -n "${REPORT_DIR_INPUT}" && "${REPORT_DIR_INPUT}" != http://* && "${REPORT_DIR_INPUT}" != https://* ]]; then
  REPORT_DIR="${REPORT_DIR_INPUT}"
  MAINLAND_BASE_URL="${MAINLAND_BASE_URL_INPUT:-${MAINLAND_BASE_URL_DEFAULT}}"
  OVERSEAS_BASE_URL="$(normalize_optional_base_url "${OVERSEAS_BASE_URL_INPUT:-}" "${OVERSEAS_BASE_URL_DEFAULT}")"
else
  REPORT_DIR="${REPORT_ROOT_DEFAULT}/go-live-bundle-$(timestamp_now)"
  MAINLAND_BASE_URL="${REPORT_DIR_INPUT:-${MAINLAND_BASE_URL_DEFAULT}}"
  OVERSEAS_BASE_URL="$(normalize_optional_base_url "${MAINLAND_BASE_URL_INPUT:-}" "${OVERSEAS_BASE_URL_DEFAULT}")"
fi

mkdir -p "${REPORT_DIR}"

CURL_CONNECT_TIMEOUT="${OPS_CENTER_CURL_CONNECT_TIMEOUT:-3}"
CURL_MAX_TIME="${OPS_CENTER_CURL_MAX_TIME:-15}"
STEP_COMMAND_TIMEOUT_SECONDS="${OPS_CENTER_REPORT_COMMAND_TIMEOUT_SECONDS:-45}"
DOCTOR_DECISION_TIMEOUT_SECONDS="${OPS_CENTER_REPORT_DOCTOR_DECISION_TIMEOUT_SECONDS:-120}"
DOCTOR_EXPORT_TIMEOUT_SECONDS="${OPS_CENTER_REPORT_DOCTOR_EXPORT_TIMEOUT_SECONDS:-180}"
DOCTOR_INNER_REPORT_TIMEOUT_SECONDS="${OPS_CENTER_DOCTOR_INNER_REPORT_TIMEOUT_SECONDS:-60}"

ENV_AUDIT_TXT_PATH="${REPORT_DIR}/00_env_audit.txt"
SUMMARY_TXT_PATH="${REPORT_DIR}/01_go_live_check_summary.txt"
GO_LIVE_JSON_PATH="${REPORT_DIR}/02_go_live_summary.json"
STACK_JSON_PATH="${REPORT_DIR}/03_stack_diagnosis.json"
DRIVER_FEED_JSON_PATH="${REPORT_DIR}/04_driver_feed.json"
CODEX_BRIEF_JSON_PATH="${REPORT_DIR}/05_codex_brief.json"
RELEASE_LAUNCHPAD_JSON_PATH="${REPORT_DIR}/06_release_launchpad.json"
DOCTOR_DECISION_JSON_PATH="${REPORT_DIR}/07_doctor_decision.json"
DOCTOR_EXPORT_STDOUT_PATH="${REPORT_DIR}/08_doctor_export_stdout.txt"
MANIFEST_PATH="${REPORT_DIR}/manifest.json"

declare -a STEP_RESULTS=()

pretty_print_json_file() {
  local source_path="${1:-}"
  python3 - "${source_path}" <<'PY'
import json
import pathlib
import sys

path = pathlib.Path(sys.argv[1])
raw_text = path.read_text(encoding="utf-8") if path.exists() else ""
try:
    payload = json.loads(raw_text)
except Exception:
    print(raw_text)
else:
    print(json.dumps(payload, ensure_ascii=False, indent=2))
PY
}

record_step_result() {
  local key="${1:-}"
  local path="${2:-}"
  local ok="${3:-false}"
  local http_status="${4:-}"
  local exit_code="${5:-0}"
  STEP_RESULTS+=("${key}|${path}|${ok}|${http_status}|${exit_code}")
}

fetch_json_to_file() {
  local key="${1:-}"
  local url="${2:-}"
  local output_path="${3:-}"
  local tmp_path
  tmp_path="$(mktemp)"
  local raw_text http_status
  raw_text="$(curl -sS \
    --connect-timeout "${CURL_CONNECT_TIMEOUT}" \
    --max-time "${CURL_MAX_TIME}" \
    "${url}" \
    -w $'\nHTTP_STATUS=%{http_code}' || true)"
  http_status="${raw_text##*$'\n'HTTP_STATUS=}"
  printf '%s' "${raw_text%$'\n'HTTP_STATUS=*}" > "${tmp_path}"
  pretty_print_json_file "${tmp_path}" > "${output_path}"
  rm -f "${tmp_path}"
  if [[ "${http_status}" == 2* ]]; then
    record_step_result "${key}" "${output_path}" "true" "${http_status}" "0"
    return 0
  fi
  record_step_result "${key}" "${output_path}" "false" "${http_status}" "1"
  return 1
}

capture_command_to_file() {
  local key="${1:-}"
  local output_path="${2:-}"
  shift 2 || true
  capture_command_to_file_with_timeout "${STEP_COMMAND_TIMEOUT_SECONDS}" "${key}" "${output_path}" "$@"
}

capture_command_to_file_with_timeout() {
  local timeout_seconds="${1:-45}"
  local key="${2:-}"
  local output_path="${3:-}"
  shift 3 || true
  local -a wrapped_command=("$@")
  local had_errexit="false"
  case "$-" in
    *e*) had_errexit="true" ;;
  esac
  if command -v timeout >/dev/null 2>&1; then
    wrapped_command=(timeout "${timeout_seconds}" "$@")
  fi
  set +e
  "${wrapped_command[@]}" > "${output_path}" 2>&1
  local exit_code=$?
  if [[ "${had_errexit}" == "true" ]]; then
    set -e
  else
    set +e
  fi
  if [[ "${exit_code}" -eq 0 ]]; then
    record_step_result "${key}" "${output_path}" "true" "" "${exit_code}"
    return 0
  fi
  record_step_result "${key}" "${output_path}" "false" "" "${exit_code}"
  return "${exit_code}"
}

materialize_go_live_summary_fallback() {
  local summary_path="${1:-}"
  local output_path="${2:-}"
  python3 - "${summary_path}" "${output_path}" <<'PY'
import json
import pathlib
import sys

summary_path = pathlib.Path(sys.argv[1])
output_path = pathlib.Path(sys.argv[2])
raw_text = summary_path.read_text(encoding="utf-8") if summary_path.exists() else ""
start = raw_text.find("{")
end = raw_text.rfind("}")
if start < 0 or end < start:
    sys.exit(1)
json_text = raw_text[start:end + 1]
payload = json.loads(json_text)
if not isinstance(payload, dict):
    sys.exit(1)
output_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
PY
}

override_step_result() {
  local key="${1:-}"
  local path="${2:-}"
  local ok="${3:-false}"
  local http_status="${4:-}"
  local exit_code="${5:-0}"
  local -a updated_results=()
  local raw_item existing_key
  for raw_item in "${STEP_RESULTS[@]}"; do
    existing_key="${raw_item%%|*}"
    if [[ "${existing_key}" == "${key}" ]]; then
      continue
    fi
    updated_results+=("${raw_item}")
  done
  STEP_RESULTS=("${updated_results[@]}")
  record_step_result "${key}" "${path}" "${ok}" "${http_status}" "${exit_code}"
}

set +e
capture_command_to_file \
  "env_audit" \
  "${ENV_AUDIT_TXT_PATH}" \
  bash "${SCRIPT_DIR}/drive_ops_center.sh" env-audit "${MAINLAND_BASE_URL}"

capture_command_to_file \
  "go_live_check_summary" \
  "${SUMMARY_TXT_PATH}" \
  bash "${SCRIPT_DIR}/drive_ops_center.sh" go-live-check "${MAINLAND_BASE_URL}" "${OVERSEAS_BASE_URL}" summary

fetch_json_to_file \
  "go_live_summary" \
  "${MAINLAND_BASE_URL}/api/v1/ops/go-live-summary?base_url=${MAINLAND_BASE_URL}" \
  "${GO_LIVE_JSON_PATH}"

if [[ ! -s "${GO_LIVE_JSON_PATH}" || "$(sed -n '1p' "${GO_LIVE_JSON_PATH}" 2>/dev/null)" != "{"* ]]; then
  if materialize_go_live_summary_fallback "${SUMMARY_TXT_PATH}" "${GO_LIVE_JSON_PATH}" 2>/dev/null; then
    override_step_result "go_live_summary" "${GO_LIVE_JSON_PATH}" "true" "fallback" "0"
  fi
fi

if [[ "$(python3 - "${GO_LIVE_JSON_PATH}" <<'PY'
import json
import pathlib
import sys

path = pathlib.Path(sys.argv[1])
try:
    payload = json.loads(path.read_text(encoding="utf-8"))
except Exception:
    print("invalid")
    raise SystemExit(0)

if isinstance(payload, dict) and payload.get("detail") == "Not Found":
    print("not_found")
else:
    print("ok")
PY
)" == "not_found" ]]; then
  if materialize_go_live_summary_fallback "${SUMMARY_TXT_PATH}" "${GO_LIVE_JSON_PATH}" 2>/dev/null; then
    override_step_result "go_live_summary" "${GO_LIVE_JSON_PATH}" "true" "fallback" "0"
  fi
fi

fetch_json_to_file \
  "stack_diagnosis" \
  "${MAINLAND_BASE_URL}/api/v1/ops/stack-diagnosis?base_url=${MAINLAND_BASE_URL}" \
  "${STACK_JSON_PATH}"

fetch_json_to_file \
  "driver_feed" \
  "${MAINLAND_BASE_URL}/api/v1/ops/driver-feed" \
  "${DRIVER_FEED_JSON_PATH}"

fetch_json_to_file \
  "codex_brief" \
  "${MAINLAND_BASE_URL}/api/v1/ops/codex-brief" \
  "${CODEX_BRIEF_JSON_PATH}"

fetch_json_to_file \
  "release_launchpad" \
  "${MAINLAND_BASE_URL}/api/v1/ops/releases/launchpad" \
  "${RELEASE_LAUNCHPAD_JSON_PATH}"

capture_command_to_file_with_timeout \
  "${DOCTOR_EXPORT_TIMEOUT_SECONDS}" \
  "doctor_export" \
  "${DOCTOR_EXPORT_STDOUT_PATH}" \
  env "OPS_CENTER_DOCTOR_REPORT_TIMEOUT_SECONDS=${DOCTOR_INNER_REPORT_TIMEOUT_SECONDS}" \
  bash "${SCRIPT_DIR}/drive_ops_center.sh" doctor-export "${REPORT_DIR}/doctor-export" "${MAINLAND_BASE_URL}" "${OVERSEAS_BASE_URL}"

capture_command_to_file_with_timeout \
  "${DOCTOR_DECISION_TIMEOUT_SECONDS}" \
  "doctor_decision" \
  "${DOCTOR_DECISION_JSON_PATH}" \
  bash "${SCRIPT_DIR}/drive_ops_center.sh" doctor-decision "${REPORT_DIR}/doctor-export"
set -e

python3 - <<'PY' \
  "${MANIFEST_PATH}" \
  "${REPORT_DIR}" \
  "${MAINLAND_BASE_URL}" \
  "${OVERSEAS_BASE_URL}" \
  "${ENV_AUDIT_TXT_PATH}" \
  "${SUMMARY_TXT_PATH}" \
  "${GO_LIVE_JSON_PATH}" \
  "${STACK_JSON_PATH}" \
  "${DRIVER_FEED_JSON_PATH}" \
  "${CODEX_BRIEF_JSON_PATH}" \
  "${RELEASE_LAUNCHPAD_JSON_PATH}" \
  "${DOCTOR_DECISION_JSON_PATH}" \
  "${DOCTOR_EXPORT_STDOUT_PATH}" \
  "${STEP_RESULTS[@]}"
import json
import pathlib
import sys

manifest_path = pathlib.Path(sys.argv[1])
report_dir = pathlib.Path(sys.argv[2])
mainland_base_url = sys.argv[3]
overseas_base_url = sys.argv[4]

file_keys = [
    "env_audit",
    "go_live_check_summary",
    "go_live_summary",
    "stack_diagnosis",
    "driver_feed",
    "codex_brief",
    "release_launchpad",
    "doctor_decision",
    "doctor_export",
]
file_paths = {
    "env_audit": pathlib.Path(sys.argv[5]),
    "go_live_check_summary": pathlib.Path(sys.argv[6]),
    "go_live_summary": pathlib.Path(sys.argv[7]),
    "stack_diagnosis": pathlib.Path(sys.argv[8]),
    "driver_feed": pathlib.Path(sys.argv[9]),
    "codex_brief": pathlib.Path(sys.argv[10]),
    "release_launchpad": pathlib.Path(sys.argv[11]),
    "doctor_decision": pathlib.Path(sys.argv[12]),
    "doctor_export": pathlib.Path(sys.argv[13]),
}

step_results = {}
for raw_item in sys.argv[14:]:
    parts = raw_item.split("|", 4)
    if len(parts) != 5:
        continue
    key, path_value, ok_value, http_status, exit_code = parts
    step_results[key] = {
        "path": path_value,
        "ok": ok_value == "true",
        "http_status": http_status,
        "exit_code": int(exit_code or 0),
    }


def load_json_file(path: pathlib.Path) -> dict:
    if not path.is_file():
        return {}
    try:
        payload = json.loads(path.read_text(encoding="utf-8"))
    except Exception:
        return {}
    return payload if isinstance(payload, dict) else {}


def load_env_audit_summary(path: pathlib.Path) -> dict:
    if not path.is_file():
        return {}
    raw_text = path.read_text(encoding="utf-8", errors="replace")
    marker = "[8/8] condensed env audit summary"
    candidate_text = raw_text.split(marker, 1)[1].strip() if marker in raw_text else raw_text.strip()
    if not candidate_text:
        return {}
    try:
        payload = json.loads(candidate_text)
    except Exception:
        return {}
    return payload if isinstance(payload, dict) else {}

failures = []
artifacts = []
for key in file_keys:
    artifact_path = file_paths[key]
    result = dict(step_results.get(key) or {})
    if not result:
        result = {
            "path": str(artifact_path),
            "ok": artifact_path.exists(),
            "http_status": "",
            "exit_code": 0 if artifact_path.exists() else 1,
        }
    entry = {
        "key": key,
        "path": str(artifact_path),
        "exists": artifact_path.exists(),
        "ok": bool(result.get("ok", False)),
        "http_status": str(result.get("http_status") or ""),
        "exit_code": int(result.get("exit_code", 0) or 0),
    }
    artifacts.append(entry)
    if not entry["ok"]:
        failures.append(key)

go_live_summary_payload = load_json_file(file_paths["go_live_summary"])
stack_diagnosis_payload = load_json_file(file_paths["stack_diagnosis"])
driver_feed_payload = load_json_file(file_paths["driver_feed"])
codex_brief_payload = load_json_file(file_paths["codex_brief"])
env_audit_summary = load_env_audit_summary(file_paths["env_audit"])

stack_diagnosis = dict(stack_diagnosis_payload.get("diagnosis") or {})
driver_feed_summary = dict(driver_feed_payload.get("summary") or {})
codex_brief_summary = dict(codex_brief_payload.get("summary") or {})


def first_nonempty(*values: object) -> str:
    for value in values:
        normalized = str(value or "").strip()
        if normalized:
            return normalized
    return ""


def nonempty_distinct(values: dict[str, str]) -> list[str]:
    return sorted({str(value or "").strip() for value in values.values() if str(value or "").strip()})


def distinct_ints(values: dict[str, int], available_sources: set[str]) -> list[int]:
    return sorted({int(values[source]) for source in values if source in available_sources})


launchpad_target_node_codes = {
    "go_live_summary": str(go_live_summary_payload.get("launchpad_recommended_target_node_code") or "").strip(),
    "stack_diagnosis": str(stack_diagnosis.get("launchpad_recommended_target_node_code") or "").strip(),
    "driver_feed": str(driver_feed_summary.get("launchpad_recommended_target_node_code") or "").strip(),
    "codex_brief": str(codex_brief_summary.get("launchpad_recommended_target_node_code") or "").strip(),
}
launchpad_recovery_labels = {
    "go_live_summary": str(go_live_summary_payload.get("launchpad_recommended_recovery_label") or "").strip(),
    "stack_diagnosis": str(stack_diagnosis.get("launchpad_recommended_recovery_label") or "").strip(),
    "driver_feed": str(driver_feed_summary.get("launchpad_recommended_recovery_label") or "").strip(),
    "codex_brief": str(codex_brief_summary.get("launchpad_recommended_recovery_label") or "").strip(),
}
launchpad_recovery_summaries = {
    "go_live_summary": str(go_live_summary_payload.get("launchpad_recommended_recovery_summary") or "").strip(),
    "stack_diagnosis": str(stack_diagnosis.get("launchpad_recommended_recovery_summary") or "").strip(),
    "driver_feed": str(driver_feed_summary.get("launchpad_recommended_recovery_summary") or "").strip(),
    "codex_brief": str(codex_brief_summary.get("launchpad_recommended_recovery_summary") or "").strip(),
}
launchpad_bootstrap_pending_nodes = {
    "go_live_summary": int(go_live_summary_payload.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
    "stack_diagnosis": int(stack_diagnosis.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
    "driver_feed": int(driver_feed_summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
    "codex_brief": int(codex_brief_summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
}
launchpad_acceptance_ready_nodes = {
    "go_live_summary": int(go_live_summary_payload.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
    "stack_diagnosis": int(stack_diagnosis.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
    "driver_feed": int(driver_feed_summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
    "codex_brief": int(codex_brief_summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
}
available_alignment_sources = {
    source
    for source, payload_value in {
        "go_live_summary": go_live_summary_payload,
        "stack_diagnosis": stack_diagnosis_payload,
        "driver_feed": driver_feed_payload,
        "codex_brief": codex_brief_payload,
    }.items()
    if isinstance(payload_value, dict) and payload_value
}
launchpad_alignment = {
    "consistent": True,
    "target_node_code_consistent": True,
    "recovery_label_consistent": True,
    "recovery_summary_consistent": True,
    "bootstrap_pending_consistent": True,
    "acceptance_ready_consistent": True,
    "available_sources": sorted(available_alignment_sources),
    "target_node_codes": launchpad_target_node_codes,
    "recovery_labels": launchpad_recovery_labels,
    "recovery_summaries": launchpad_recovery_summaries,
    "bootstrap_pending_nodes": launchpad_bootstrap_pending_nodes,
    "acceptance_ready_nodes": launchpad_acceptance_ready_nodes,
}
launchpad_alignment["target_node_code_consistent"] = len(nonempty_distinct({
    source: value for source, value in launchpad_target_node_codes.items() if source in available_alignment_sources
})) <= 1
launchpad_alignment["recovery_label_consistent"] = len(nonempty_distinct({
    source: value for source, value in launchpad_recovery_labels.items() if source in available_alignment_sources
})) <= 1
launchpad_alignment["recovery_summary_consistent"] = len(nonempty_distinct({
    source: value for source, value in launchpad_recovery_summaries.items() if source in available_alignment_sources
})) <= 1
launchpad_alignment["bootstrap_pending_consistent"] = len(
    distinct_ints(launchpad_bootstrap_pending_nodes, available_alignment_sources)
) <= 1
launchpad_alignment["acceptance_ready_consistent"] = len(
    distinct_ints(launchpad_acceptance_ready_nodes, available_alignment_sources)
) <= 1
launchpad_alignment["consistent"] = all([
    bool(launchpad_alignment["target_node_code_consistent"]),
    bool(launchpad_alignment["recovery_label_consistent"]),
    bool(launchpad_alignment["recovery_summary_consistent"]),
    bool(launchpad_alignment["bootstrap_pending_consistent"]),
    bool(launchpad_alignment["acceptance_ready_consistent"]),
])

env_audit_status = str(env_audit_summary.get("status") or "").strip()
env_audit_runtime_may_need_restart = bool(((env_audit_summary.get("runtime") or {}).get("runtime_may_need_restart", False)))
review_status_hint = "ready"
review_headline = "核心上线证据已经齐备，可进入最终人工复核或正式发布门禁。"
if failures or env_audit_status == "blocked":
    review_status_hint = "blocked"
    review_headline = "当前导出包仍有关键阻断项，不能直接作为正式上线终稿。"
elif env_audit_status == "attention" or not launchpad_alignment["consistent"]:
    review_status_hint = "attention"
    if not launchpad_alignment["consistent"]:
        review_headline = "核心报告虽已导出，但 launchpad 摘要在不同 surface 之间存在漂移，建议先重新复核。"
    else:
        review_headline = "核心报告已齐，但环境审计仍提示存在待收口事项。"

payload = {
    "report_dir": str(report_dir),
    "mainland_base_url": mainland_base_url,
    "overseas_base_url": overseas_base_url,
    "artifacts": artifacts,
    "failures": failures,
    "summary": {
        "ok": len(failures) == 0,
        "artifact_total": len(artifacts),
        "failure_total": len(failures),
        "review_status_hint": review_status_hint,
        "review_headline": review_headline,
        "env_audit_status": env_audit_status,
        "env_audit_runtime_may_need_restart": env_audit_runtime_may_need_restart,
        "launchpad_recommended_target_node_code": first_nonempty(
            go_live_summary_payload.get("launchpad_recommended_target_node_code"),
            stack_diagnosis.get("launchpad_recommended_target_node_code"),
            driver_feed_summary.get("launchpad_recommended_target_node_code"),
            codex_brief_summary.get("launchpad_recommended_target_node_code"),
        ),
        "launchpad_recommended_recovery_label": first_nonempty(
            go_live_summary_payload.get("launchpad_recommended_recovery_label"),
            stack_diagnosis.get("launchpad_recommended_recovery_label"),
            driver_feed_summary.get("launchpad_recommended_recovery_label"),
            codex_brief_summary.get("launchpad_recommended_recovery_label"),
        ),
        "launchpad_recommended_recovery_summary": first_nonempty(
            go_live_summary_payload.get("launchpad_recommended_recovery_summary"),
            stack_diagnosis.get("launchpad_recommended_recovery_summary"),
            driver_feed_summary.get("launchpad_recommended_recovery_summary"),
            codex_brief_summary.get("launchpad_recommended_recovery_summary"),
        ),
        "launchpad_onboarding_bootstrap_pending_nodes": max(launchpad_bootstrap_pending_nodes.values() or [0]),
        "launchpad_onboarding_acceptance_ready_nodes": max(launchpad_acceptance_ready_nodes.values() or [0]),
        "launchpad_alignment": launchpad_alignment,
        "recommended_reading_order": [
            "00_env_audit.txt",
            "01_go_live_check_summary.txt",
            "02_go_live_summary.json",
            "03_stack_diagnosis.json",
            "04_driver_feed.json",
            "05_codex_brief.json",
            "06_release_launchpad.json",
            "07_doctor_decision.json",
            "08_doctor_export_stdout.txt",
        ],
    },
}

manifest_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(payload, ensure_ascii=False, indent=2))
PY