#!/usr/bin/env python3

# To run this in headless mode, set the following environment variables:
# * SDL_VIDEODRIVER=dummy
# * SDL_AUDIODRIVER=dummy
#
# Also make sure to specify the correct paths to the ScummVM binary, demos, and records if they are not in the default locations.
# You can also change them via environment variables:
# * SCUMMVM_BIN - path to the ScummVM binary
# * GAMES_DIR - path to the games directory that are automatically registered before running tests - defaults to none and is skipped then.
#               it's assumed that you have already registered the games for playing back the event recorder files.
#
# Example usage:
#   SDL_VIDEODRIVER=dummy SDL_AUDIODRIVER=dummy SCUMMVM_BIN=./scummvm \
#   python3 devtools/run_event_recorder_tests.py --xunit-output=event_recorder_tests.xml \
#   --filter="*monkey*"


import os
import sys
import subprocess
import platform
import argparse
import time
import fnmatch
import re
import json
import xml.etree.ElementTree as ET
from pathlib import Path

def generate_xunit_report(results, output_file, total_time):
	testsuites = ET.Element("testsuites")
	testsuite = ET.SubElement(testsuites, "testsuite", name="EventRecorderTest", tests=str(len(results)), time=str(total_time))

	failures = 0
	skipped = 0
	for result in results:
		# XUnit format: classname="TestSuite", name="TestCase"
		testcase = ET.SubElement(testsuite, "testcase", name=result['test_case'], classname="EventRecorderTest", time=str(result['duration']))
		if result.get('skipped'):
			skipped += 1
			ET.SubElement(testcase, "skipped", message=result['message'])
		elif not result['success']:
			failures += 1
			failure = ET.SubElement(testcase, "failure", message=result['message'])
			failure.text = result.get('output', '')

	testsuite.set("failures", str(failures))
	testsuite.set("skipped", str(skipped))

	tree = ET.ElementTree(testsuites)
	try:
		tree.write(output_file, encoding="utf-8", xml_declaration=True)
		# print(f"XUnit report generated at: {output_file}")
	except Exception as e:
		print(f"Error writing XUnit report: {e}")

def main():
	parser = argparse.ArgumentParser(description="Run ScummVM Event Recorder tests.")
	parser.add_argument("--xunit-output", help="Path to generate XUnit XML report", default=None)
	parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output", default=False)
	parser.add_argument("--filter", help="Filter tests (glob pattern, e.g. *monkey*)", default="*")
	parser.add_argument("--list", action="store_true", help="List tests", default=False)
	args = parser.parse_args()

	# Configuration
	# Determine default binary name based on OS
	bin_name = "scummvm.exe" if platform.system() == "Windows" else "./scummvm"

	# Allow overriding via env vars
	# Default to looking in current directory
	scummvm_bin = os.getenv("SCUMMVM_BIN", bin_name)
	if os.getenv("GAMES_DIR", None):
		games_dir = Path(os.getenv("GAMES_DIR"))
	else:
		games_dir = None

	# Check if ScummVM exists
	if not Path(scummvm_bin).exists():
		print(f"Error: ScummVM binary not found at {scummvm_bin}")
		print("Please run this script from the root of the ScummVM source tree where the binary is built.")
		sys.exit(127)

	# Check if demos directory exists
	if games_dir is not None:
		if not games_dir.exists():
			print(f"Error: Games directory not found at {games_dir}")
			sys.exit(127)

		# Register games
		for game_path in sorted(games_dir.iterdir()):
			if not game_path.is_dir():
				continue

			try:
				detect_cmd = [
					str(scummvm_bin),
					"--add",
					f"--path={game_path}"
				]
				subprocess.run(detect_cmd, capture_output=True)
			except Exception as e:
				print(f"Error detecting games in {game_path}: {e}")
				continue

	# Get available engines
	available_engines = set()
	try:
		list_engines_cmd = [str(scummvm_bin), "--list-engines-json"]
		result = subprocess.run(list_engines_cmd, capture_output=True, text=True)
		if result.returncode == 0:
			try:
				engines_map = json.loads(result.stdout)
				available_engines = set(engines_map.keys())
			except json.JSONDecodeError:
				print(f"Warning: Failed to parse engines JSON. Output was:\n{result.stdout}")
		else:
			print(f"Warning: Failed to list engines: {result.stderr}")
	except Exception as e:
		print(f"Warning: Error executing ScummVM to list engines: {e}")

	# Collect tests
	test_cases = []
	try:
		list_cmd = [str(scummvm_bin), "--list-records-json"]
		result = subprocess.run(list_cmd, capture_output=True, text=True)
		if result.returncode != 0:
			print(f"Error listing records: {result.stderr}")
			sys.exit(1)
	except Exception as e:
		print(f"Error executing ScummVM to list records: {e}")
		sys.exit(1)

	try:
		json_output = result.stdout.strip()
		records_map = json.loads(json_output)
	except json.JSONDecodeError as e:
		print(f"Error parsing records JSON: {e}\nOutput was:\n{result.stdout}")
		sys.exit(1)

	for target, info in records_map.items():
		engine_id = info.get('engine')
		for record_file in info.get('records', []):
			# Test name: EventRecorderTest.<RecordFileName>
			# We use the filename as the test case name
			test_case_name = record_file
			full_test_name = f"EventRecorderTest.{test_case_name}"

			# Check filter
			# Match against full name or just the test case name
			if not fnmatch.fnmatch(full_test_name, args.filter) and not fnmatch.fnmatch(test_case_name, args.filter):
				continue

			test_cases.append({
				'full_name': full_test_name,
				'test_case': test_case_name,
				'record_file': record_file,
				'target': target,
				'engine_id': engine_id
			})

	if args.list:
		print("EventRecorderTest.")
		for test in test_cases:
			print(f"  {test['test_case']}")
		sys.exit(0)

	total_tests = len(test_cases)

	# Googletest compatible header
	print(f"[==========] {total_tests} tests from 1 test suite ran.")
	print(f"[----------] {total_tests} tests from EventRecorderTest")

	start_total_time = time.time()
	passed_tests = []
	failed_tests = []
	skipped_tests = []
	results_for_xunit = []

	for test in test_cases:
		print(f"[ RUN      ] {test['full_name']}")
		sys.stdout.flush()

		test_start_time = time.time()
		success = False
		message = ""
		output = ""

		if available_engines:
			engine_id = test.get('engine_id')
			if engine_id and engine_id not in available_engines:
				print(f"[  SKIPPED ] {test['full_name']} (Engine '{engine_id}' not available)")
				results_for_xunit.append({
					'name': test['full_name'],
					'test_case': test['test_case'],
					'success': False,
					'skipped': True,
					'duration': 0,
					'message': f"Engine '{engine_id}' not available",
					'output': ""
				})
				skipped_tests.append(test['full_name'])
				continue

		try:
			playback_cmd = [
				str(scummvm_bin),
				"--record-mode=fast_playback",
				f"--record-file-name={test['record_file']}",
				test['target']
			]

			# Run and capture output
			if args.verbose:
				print(f"Executing: {' '.join(playback_cmd)}")
			playback_result = subprocess.run(playback_cmd, capture_output=True, text=True)
			output = playback_result.stdout + "\n" + playback_result.stderr

			if args.verbose:
				if playback_result.stdout.strip():
					print(playback_result.stdout)
				if playback_result.stderr.strip():
					print(playback_result.stderr)

			if playback_result.returncode == 0:
				success = True
			else:
				success = False
				message = f"Exit Code: {playback_result.returncode}"

		except Exception as e:
			success = False
			message = str(e)
			output += f"\nException: {e}"

		duration_sec = time.time() - test_start_time
		duration_ms = int(duration_sec * 1000)

		results_for_xunit.append({
			'name': test['full_name'],
			'test_case': test['test_case'],
			'success': success,
			'duration': duration_sec,
			'message': message,
			'output': output
		})

		if success:
			print(f"[       OK ] {test['full_name']} ({duration_ms} ms)")
			passed_tests.append(test['full_name'])
		else:
			print(f"[  FAILED  ] {test['full_name']} ({duration_ms} ms)")
			failed_tests.append(test['full_name'])

	total_duration_sec = time.time() - start_total_time
	total_duration_ms = int(total_duration_sec * 1000)

	print(f"[----------] {total_tests} tests from EventRecorderTest ({total_duration_ms} ms total)")
	print(f"[==========] {total_tests} tests from 1 test suite ran. ({total_duration_ms} ms total)")
	print(f"[  PASSED  ] {len(passed_tests)} tests.")

	if args.xunit_output:
		generate_xunit_report(results_for_xunit, args.xunit_output, total_duration_sec)

	if failed_tests:
		print(f"[  FAILED  ] {len(failed_tests)} tests, listed below:")
		for failed in failed_tests:
			print(f"[  FAILED  ] {failed}")
		sys.exit(1)

	if skipped_tests:
		print(f"[  SKIPPED ] {len(skipped_tests)} tests.")
		for skipped in skipped_tests:
			print(f"[  SKIPPED ] {skipped}")

	if total_tests == 0:
		print("No tests were run.")
		sys.exit(0)

	sys.exit(0)

if __name__ == "__main__":
	main()