#!/bin/bash
# Round01 real-desktop QA for Finder tabs/pages. It verifies that CG-only
# Finder pages inherit the high-confidence fullscreen Space from their visible
# host, and that clicking such a card actually selects the matching Finder tab
# instead of only reporting a WindowServer activation success.

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
OUTPUT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
# shellcheck source=build-output-paths.sh
source "$SCRIPT_DIR/build-output-paths.sh"
APP="$BUILD_CURRENT_APP"
RUN_ID="$(date +%Y%m%d_%H%M%S)"
REPORT_DIR="$BUILD_REPORT_ROOT/round01-finder-tabs-live-$RUN_ID"
DEV_LOG="$HOME/Library/Logs/Aligner/aligner-dev.log"
REPORT_WAIT="${ALIGNER_ROUND1_FINDER_TABS_REPORT_WAIT:-35.0}"

fail() {
  echo "Round01 Finder tabs live QA failed: $*" >&2
  exit 1
}

aligner_pids_for_current_app() {
  ps -axo pid=,args= | while read -r pid command; do
    case "$command" in
      "$APP/Contents/MacOS/Aligner"*) echo "$pid" ;;
    esac
  done
}

stop_current_aligner() {
  for pid in $(aligner_pids_for_current_app); do
    kill "$pid" 2>/dev/null || true
  done

  for _ in {1..30}; do
    [ -z "$(aligner_pids_for_current_app)" ] && return
    sleep 0.1
  done

  fail "current Aligner app did not exit before QA"
}

dev_log_size() {
  if [ -f "$DEV_LOG" ]; then
    stat -f%z "$DEV_LOG"
  else
    echo 0
  fi
}

extract_dev_log_since() {
  local offset="$1"
  local output="$2"
  if [ ! -f "$DEV_LOG" ]; then
    : >"$output"
    return
  fi

  dd if="$DEV_LOG" bs=1 skip="$offset" 2>/dev/null >"$output" || : >"$output"
}

wait_for_report() {
  local report="$1"
  local mode="$2"
  /usr/bin/python3 - "$report" "$REPORT_WAIT" "$mode" <<'PY'
import json
import sys
import time

path = sys.argv[1]
timeout = float(sys.argv[2])
mode = sys.argv[3]
deadline = time.monotonic() + timeout
last_report = None

def ready(report):
    if report.get("snapshotLoaded") is not True:
        return False
    if mode == "loaded":
        return True
    if mode == "activated":
        return (
            report.get("quickSwitchVisible") is False
            and report.get("lastActivationResult") is not None
        )
    return False

while time.monotonic() < deadline:
    try:
        with open(path, "r", encoding="utf-8") as file:
            report = json.load(file)
        last_report = report
        if ready(report):
            sys.exit(0)
    except FileNotFoundError:
        pass
    except json.JSONDecodeError:
        pass
    time.sleep(0.2)

if last_report is not None:
    print(json.dumps(last_report, indent=2, ensure_ascii=False), file=sys.stderr)
print(f"Finder tabs report {path} did not reach mode={mode} within {timeout:.1f}s", file=sys.stderr)
sys.exit(1)
PY
}

run_snapshot_dump() {
  local snapshot="$1"
  local stderr_log="$2"
  stop_current_aligner
  ALIGNER_DIAGNOSTICS_INCLUDE_SENSITIVE=1 \
    "$APP/Contents/MacOS/Aligner" \
    --round0-skip-permissions \
    --round01-dump-window-snapshot \
    --round01-dump-window-snapshot-pretty >"$snapshot" 2>"$stderr_log"
}

run_report() {
  local report="$1"
  local app_log="$2"
  stop_current_aligner
  rm -f "$report"
  ALIGNER_DIAGNOSTICS_INCLUDE_SENSITIVE=1 \
    "$APP/Contents/MacOS/Aligner" \
    --round0-skip-permissions \
    --round01-open-quick-switch \
    --round01-disable-screenshot-refresh \
    --round01-quick-switch-auto-hide-after=20.0 \
    --round01-quick-switch-quit-after=21.0 \
    --round01-quick-switch-report="$report" >"$app_log" 2>&1 &
  local app_pid="$!"
  if ! wait_for_report "$report" "loaded"; then
    kill "$app_pid" 2>/dev/null || true
    wait "$app_pid" 2>/dev/null || true
    return 1
  fi
  kill "$app_pid" 2>/dev/null || true
  wait "$app_pid" 2>/dev/null || true
}

run_click() {
  local window_id="$1"
  local report="$2"
  local app_log="$3"
  stop_current_aligner
  rm -f "$report"
  ALIGNER_DIAGNOSTICS_INCLUDE_SENSITIVE=1 \
    "$APP/Contents/MacOS/Aligner" \
    --round0-skip-permissions \
    --round01-open-quick-switch \
    --round01-disable-screenshot-refresh \
    --round01-debug-mouse-sequence="click-card-id:$window_id" \
    --round01-quick-switch-quit-after=34.0 \
    --round01-quick-switch-report="$report" >"$app_log" 2>&1 &
  local app_pid="$!"
  if ! wait_for_report "$report" "activated"; then
    kill "$app_pid" 2>/dev/null || true
    wait "$app_pid" 2>/dev/null || true
    return 1
  fi
  wait "$app_pid" 2>/dev/null || true
}

focused_finder_window_report() {
  local output="$1"
  swift - "$output" <<'SWIFT'
import AppKit
import ApplicationServices
import Foundation

func fail(_ message: String, code: Int32 = 2) -> Never {
    fputs(message + "\n", stderr)
    exit(code)
}

func jsonString(_ value: String) -> String {
    let data = try! JSONSerialization.data(withJSONObject: ["value": value], options: [])
    let text = String(data: data, encoding: .utf8)!
    let prefix = "{\"value\":\""
    let suffix = "\"}"
    return String(text.dropFirst(prefix.count).dropLast(suffix.count))
}

func stableFingerprint(_ text: String) -> String {
    var hash: UInt64 = 0xcbf29ce484222325
    for byte in text.utf8 {
        hash ^= UInt64(byte)
        hash = hash &* 0x100000001b3
    }
    return String(format: "%016llx", hash)
}

func title(of element: AXUIElement) -> String? {
    var value: CFTypeRef?
    guard AXUIElementCopyAttributeValue(element, kAXTitleAttribute as CFString, &value) == .success else {
        return nil
    }
    return value as? String
}

func focusedWindowID(_ element: AXUIElement) -> UInt32? {
    var value: CFTypeRef?
    if AXUIElementCopyAttributeValue(element, "AXWindowNumber" as CFString, &value) == .success,
       let number = value as? NSNumber {
        return number.uint32Value
    }
    return nil
}

let outputPath = CommandLine.arguments[1]
guard let finder = NSWorkspace.shared.runningApplications.first(where: { $0.bundleIdentifier == "com.apple.finder" }) else {
    fail("Finder is not running")
}

let appElement = AXUIElementCreateApplication(finder.processIdentifier)
var windowValue: CFTypeRef?
var axError = AXUIElementCopyAttributeValue(appElement, kAXFocusedWindowAttribute as CFString, &windowValue)
if axError != .success || windowValue == nil || CFGetTypeID(windowValue!) != AXUIElementGetTypeID() {
    axError = AXUIElementCopyAttributeValue(appElement, kAXMainWindowAttribute as CFString, &windowValue)
}
guard axError == .success,
      let rawWindow = windowValue,
      CFGetTypeID(rawWindow) == AXUIElementGetTypeID()
else {
    fail("Finder focused/main window is unavailable: \(axError)")
}

let window = rawWindow as! AXUIElement
let windowTitle = title(of: window) ?? ""
let output = """
{
  "bundleIdentifier": "com.apple.finder",
  "pid": \(finder.processIdentifier),
  "focusedWindowID": \(focusedWindowID(window).map(String.init) ?? "null"),
  "title": "\(jsonString(windowTitle))",
  "titleLength": \(windowTitle.count),
  "titleHash": "\(stableFingerprint(windowTitle))"
}
"""
try output.write(toFile: outputPath, atomically: true, encoding: .utf8)
SWIFT
}

extract_attributed_ids() {
  local log_file="$1"
  /usr/bin/python3 - "$log_file" <<'PY'
import re
import sys

ids = []
for line in open(sys.argv[1], "r", encoding="utf-8", errors="replace"):
    if "event=windowEnumeration.finderTabSpaceAttribution" not in line:
        continue
    match = re.search(r'attributedWindowIDs="?(\[[^\]"]*\])"?', line)
    if not match:
        continue
    ids = [int(value) for value in re.findall(r"\d+", match.group(1))]

print(",".join(str(value) for value in sorted(set(ids))))
PY
}

select_targets() {
  local snapshot="$1"
  local report="$2"
  local attributed_ids_csv="$3"
  local output="$4"
  /usr/bin/python3 - "$snapshot" "$report" "$attributed_ids_csv" "$output" <<'PY'
import json
import os
import sys

snapshot_path, report_path, ids_csv, output_path = sys.argv[1:5]
attributed_ids = {int(value) for value in ids_csv.split(",") if value}
max_targets = max(1, int(os.environ.get("ALIGNER_ROUND1_FINDER_TABS_MAX_TARGETS", "4")))
with open(snapshot_path, "r", encoding="utf-8") as file:
    snapshot = json.load(file)
with open(report_path, "r", encoding="utf-8") as file:
    report = json.load(file)

def require(condition, message):
    if not condition:
        print(message, file=sys.stderr)
        sys.exit(4)

snapshot_windows = {window.get("id"): window for window in snapshot.get("windows", [])}
finder_candidates = [
    window for window_id, window in snapshot_windows.items()
    if window.get("app", {}).get("bundleIdentifier") == "com.apple.finder"
    and window.get("identifierSource") == "cgWindow"
    and window.get("title")
]
require(finder_candidates, "snapshot must contain at least one Finder CG-only tab/page")

root = report.get("rootView", {})
cards = []
for column in root.get("waterfallColumns", []):
    if column.get("bundleIdentifier") != "com.apple.finder":
        continue
    for card in column.get("cards", []):
        window = snapshot_windows.get(card.get("windowID"), {})
        if window.get("app", {}).get("bundleIdentifier") != "com.apple.finder":
            continue
        if window.get("identifierSource") != "cgWindow":
            continue
        visible = card.get("visibleFrame") or {}
        if visible.get("width", 0) <= 1 or visible.get("height", 0) <= 1:
            continue
        title = card.get("title") or snapshot_windows.get(card.get("windowID"), {}).get("title") or ""
        if not title.strip():
            continue
        cards.append((column, card, title))

require(cards, "Quick Switch report must expose at least one visible Finder CG tab/page card")

title_counts = {}
for _, _, title in cards:
    title_counts[title] = title_counts.get(title, 0) + 1

cards.sort(key=lambda item: (
    0 if not (snapshot_windows.get(item[1].get("windowID"), {}).get("spaceIDs") or []) else 1,
    0 if title_counts[item[2]] == 1 else 1,
    item[1].get("globalIndex", 10**9),
    item[1].get("windowID", 10**9),
))
targets = []
seen_window_ids = set()
for column, card, title in cards:
    window_id = card["windowID"]
    if window_id in seen_window_ids:
        continue
    seen_window_ids.add(window_id)
    targets.append({
        "windowID": window_id,
        "appGroupIndex": column["appGroupIndex"],
        "windowIndex": card["windowIndex"],
        "primarySpaceID": card.get("primarySpaceID"),
        "hasAttributedSpace": window_id in attributed_ids,
        "snapshotSpaceIDs": snapshot_windows.get(window_id, {}).get("spaceIDs") or [],
        "title": title,
        "titleLength": len(title),
        "titleHash": card.get("titleHash") or snapshot_windows.get(window_id, {}).get("titleHash"),
        "visibleFrame": card.get("visibleFrame"),
    })
    if len(targets) >= max_targets:
        break

require(targets, "Quick Switch report must expose at least one selectable Finder tab/page target")

with open(output_path, "w", encoding="utf-8") as file:
    json.dump(targets, file, indent=2, ensure_ascii=False)

print(f"TARGET_COUNT={len(targets)}")
PY
}

target_at_index() {
  local targets="$1"
  local index="$2"
  local output="$3"
  /usr/bin/python3 - "$targets" "$index" "$output" <<'PY'
import json
import sys

targets_path, index_text, output_path = sys.argv[1:4]
index = int(index_text)
with open(targets_path, "r", encoding="utf-8") as file:
    targets = json.load(file)
if index < 0 or index >= len(targets):
    print(f"target index {index} is out of range", file=sys.stderr)
    sys.exit(4)
target = targets[index]
with open(output_path, "w", encoding="utf-8") as file:
    json.dump(target, file, indent=2, ensure_ascii=False)
print(f"TARGET_WINDOW_ID={target['windowID']}")
print(f"TARGET_SPACE_ID={target.get('primarySpaceID')}")
PY
}

assert_click_report() {
  local report="$1"
  local target="$2"
  /usr/bin/python3 - "$report" "$target" <<'PY'
import json
import sys

with open(sys.argv[1], "r", encoding="utf-8") as file:
    report = json.load(file)
with open(sys.argv[2], "r", encoding="utf-8") as file:
    target = json.load(file)

def require(condition, message):
    if not condition:
        print(message, file=sys.stderr)
        print(json.dumps({
            "targetWindowID": target.get("windowID"),
            "lastCommittedWindowID": report.get("lastCommittedWindowID"),
            "lastActivationWindowID": report.get("lastActivationWindowID"),
            "lastActivationResult": report.get("lastActivationResult"),
            "lastActivationError": report.get("lastActivationError"),
            "quickSwitchVisible": report.get("quickSwitchVisible"),
        }, indent=2, ensure_ascii=False), file=sys.stderr)
        sys.exit(5)

require(report.get("lastCommittedWindowID") == target["windowID"], "commit must target the clicked Finder card")
require(report.get("lastActivationWindowID") == target["windowID"], "activation must receive exact Finder tab/page windowID")
require(report.get("lastActivationResult") == "activated", "activation result must be activated")
require(report.get("quickSwitchVisible") is False, "Quick Switch must close after click activation")
PY
}

assert_focused_finder_title() {
  local target="$1"
  local focused="$2"
  /usr/bin/python3 - "$target" "$focused" <<'PY'
import json
import sys

with open(sys.argv[1], "r", encoding="utf-8") as file:
    target = json.load(file)
with open(sys.argv[2], "r", encoding="utf-8") as file:
    focused = json.load(file)

target_title = target.get("title", "").strip()
focused_title = focused.get("title", "").strip()
if target_title != focused_title:
    print("Focused Finder window title must match clicked tab/page title", file=sys.stderr)
    print(json.dumps({
        "targetWindowID": target.get("windowID"),
        "targetTitleHash": target.get("titleHash"),
        "targetTitleLength": target.get("titleLength"),
        "focusedWindowID": focused.get("focusedWindowID"),
        "focusedTitleHash": focused.get("titleHash"),
        "focusedTitleLength": focused.get("titleLength"),
    }, indent=2, ensure_ascii=False), file=sys.stderr)
    sys.exit(6)

print(json.dumps({
    "case": "finderTabRealActivation",
    "targetWindowID": target.get("windowID"),
    "targetSpaceID": target.get("primarySpaceID"),
    "targetTitleHash": target.get("titleHash"),
    "targetTitleLength": target.get("titleLength"),
    "focusedWindowID": focused.get("focusedWindowID"),
    "focusedTitleHash": focused.get("titleHash"),
    "focusedTitleLength": focused.get("titleLength"),
}, indent=2, ensure_ascii=False))
PY
}

assert_no_finder_activation_failure_log() {
  local log_file="$1"
  local target="$2"
  /usr/bin/python3 - "$log_file" "$target" <<'PY'
import json
import sys

log_path, target_path = sys.argv[1:3]
with open(target_path, "r", encoding="utf-8") as file:
    target = json.load(file)

window_id = str(target.get("windowID"))
bad_lines = []
for line in open(log_path, "r", encoding="utf-8", errors="replace"):
    if f"windowID={window_id}" not in line:
        continue
    if "event=windowActivation.finderTab.noSelectableHost" in line:
        bad_lines.append(line.strip())
    elif "event=windowActivation.finderTab.hostMissing" in line:
        bad_lines.append(line.strip())
    elif "event=windowActivation.activate.finderTabResult" in line and "activated=false" in line:
        bad_lines.append(line.strip())
    elif "event=quickSwitch.activation.commit.result" in line and "result=activationFailed" in line:
        bad_lines.append(line.strip())

if bad_lines:
    print("Finder activation log contains failure markers for clicked target", file=sys.stderr)
    print(json.dumps({
        "targetWindowID": target.get("windowID"),
        "hasAttributedSpace": target.get("hasAttributedSpace"),
        "snapshotSpaceIDs": target.get("snapshotSpaceIDs"),
        "lines": bad_lines[-8:],
    }, indent=2, ensure_ascii=False), file=sys.stderr)
    sys.exit(7)
PY
}

mkdir -p "$REPORT_DIR"
stop_current_aligner
"$SCRIPT_DIR/package-app.sh" >&2

SNAPSHOT_JSON="$REPORT_DIR/snapshot.json"
SNAPSHOT_STDERR="$REPORT_DIR/snapshot.stderr.log"
SNAPSHOT_DEV_LOG="$REPORT_DIR/snapshot-dev.log"
INITIAL_REPORT="$REPORT_DIR/initial-report.json"
INITIAL_APP_LOG="$REPORT_DIR/initial-app.log"
TARGETS_JSON="$REPORT_DIR/targets.json"

SNAPSHOT_LOG_OFFSET="$(dev_log_size)"
run_snapshot_dump "$SNAPSHOT_JSON" "$SNAPSHOT_STDERR"
sleep 0.4
extract_dev_log_since "$SNAPSHOT_LOG_OFFSET" "$SNAPSHOT_DEV_LOG"
ATTRIBUTED_IDS="$(extract_attributed_ids "$SNAPSHOT_DEV_LOG")"

run_report "$INITIAL_REPORT" "$INITIAL_APP_LOG"
eval "$(select_targets "$SNAPSHOT_JSON" "$INITIAL_REPORT" "$ATTRIBUTED_IDS" "$TARGETS_JSON")"

for ((target_index = 0; target_index < TARGET_COUNT; target_index++)); do
  TARGET_JSON="$REPORT_DIR/target-$target_index.json"
  CLICK_REPORT="$REPORT_DIR/click-report-$target_index.json"
  CLICK_APP_LOG="$REPORT_DIR/click-app-$target_index.log"
  CLICK_DEV_LOG="$REPORT_DIR/click-dev-$target_index.log"
  FOCUSED_JSON="$REPORT_DIR/focused-finder-$target_index.json"

  eval "$(target_at_index "$TARGETS_JSON" "$target_index" "$TARGET_JSON")"
  CLICK_LOG_OFFSET="$(dev_log_size)"
  run_click "$TARGET_WINDOW_ID" "$CLICK_REPORT" "$CLICK_APP_LOG"
  sleep 0.8
  extract_dev_log_since "$CLICK_LOG_OFFSET" "$CLICK_DEV_LOG"
  focused_finder_window_report "$FOCUSED_JSON"

  assert_click_report "$CLICK_REPORT" "$TARGET_JSON"
  assert_focused_finder_title "$TARGET_JSON" "$FOCUSED_JSON"
  assert_no_finder_activation_failure_log "$CLICK_DEV_LOG" "$TARGET_JSON"
done

stop_current_aligner

cat <<EOF
Round01 Finder tabs live QA passed
Log directory: $REPORT_DIR
Covered:
- Finder CG-only tab/page records are clicked even when Space attribution is unavailable.
- Quick Switch clicks target exact Finder tab/page windowIDs.
- Finder focused window title matches each clicked card after activation.
- Finder activation logs contain no hostMissing/noSelectableHost/activationFailed for clicked targets.
- Multiple Finder tab/page targets are exercised in one run to catch intermittent host mismatch.
EOF