<?php
require_once "vendor/autoload.php";

use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
use Symfony\Component\DependencyInjection\Reference;

class Dependency {
	public static int $construction_count = 0;

	public function __construct() {
		++self::$construction_count;
	}
}

class Service {
	public function __construct(
		public readonly mixed $argument,
	) {}
}

function assert_construction_count(int $expected): void {
	assert(
		Dependency::$construction_count === $expected,
		sprintf('Construction count. Expected=%d, Actual=%d', $expected, Dependency::$construction_count)
	);
}

$container = new ContainerBuilder();
$container->register('dependency', Dependency::class);
$container->register('service', Service::class)
	->setArgument('$argument', new Reference('dependency'))
	->setLazy(true)
	->setPublic(true);

$container->compile();

// Dump and reconstruct the container.
$dumper = new PhpDumper($container);
file_put_contents('./container.php', $dumper->dump([
	'class' => 'DumpedContainer',
]));
include './container.php';
$container = new \DumpedContainer();

assert_construction_count(0);

// The service is lazy and will not yet be constructed.
$service = $container->get('service');
assert_construction_count(0);

// Cloning has no impact.
$first_cloned_service = clone $service;
$second_cloned_service = clone $service;
assert_construction_count(0);

// Construction of the first clone creates the clone and the internal argument.
$first_arg = $first_cloned_service->argument;
assert_construction_count(1);

// Construction of the second clone should only create the clone and reuse the dependency. Currently this fails and the dependency is constructed twice.
$second_arg = $second_cloned_service->argument;
assert_construction_count(1);
assert($first_arg === $second_arg);