@Inject
Web3j web3j;

@ApplicationScoped
public class Web3jClientProducer {

	private volatile Web3jConfiguration config;

	void initialize(Web3jConfiguration config) {
		this.config = config;
	}

	@Singleton
	@Produces
	public Web3j web3j() {
		return Web3j.build(new HttpService(config.url));
	}
}

@ConfigRoot(phase = ConfigPhase.RUN_TIME)
public class Web3jConfiguration {
	/**
	 * Web3j URL to use.
	 */
	@ConfigItem
	public String url;
}

@Recorder
public class Web3jRecorder {

	public void update(BeanContainer beanContainer, Web3jConfiguration configuration) {
		Web3jClientProducer producer = beanContainer.instance(Web3jClientProducer.class);
		producer.initialize(configuration);
	}

}

class QuarkusWeb3jClientProcessor {

	private static final String FEATURE = "web3j-client";

	@BuildStep
	void build(BuildProducer<FeatureBuildItem> featureProducer,
			BuildProducer<AdditionalBeanBuildItem> additionalBeanProducer,
			BuildProducer<BeanContainerListenerBuildItem> containerListenerProducer) {

		featureProducer.produce(new FeatureBuildItem(FEATURE));

		additionalBeanProducer.produce(AdditionalBeanBuildItem.unremovableOf(Web3jClientProducer.class));
	}

	@BuildStep
	@Record(ExecutionTime.RUNTIME_INIT)
	void configureProducer(Web3jRecorder recorder, BeanContainerBuildItem beanContainerBuildItem,
			Web3jConfiguration configuration) {
		recorder.update(beanContainerBuildItem.getValue(), configuration);
	}

}

public class QuarkusWeb3jClientTest {
	@RegisterExtension
	static final QuarkusUnitTest config = new QuarkusUnitTest()
			.setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class))
			.withConfigurationResource("application.properties");

	@Inject
	Web3jConfiguration web3j;

	@Test
	public void checkUrlIsLoaded() {
		assertEquals(web3j.url, "http://localhost:8545");
	}
}

@ApplicationScoped
public class LotteryService {

	private static final Logger LOGGER = Logger.getLogger(LotteryService.class);

	@Inject
	Web3j web3j;
	@Inject
	LotteryProperties config;

	private Map<String, String> lotteryByOwner = new ConcurrentHashMap<>();

	public BigDecimal getBalance(String owner) throws IOException {
		BigInteger wei = web3j.ethGetBalance(lotteryByOwner.get(owner), DefaultBlockParameterName.LATEST).send()
				.getBalance();
		return Convert.fromWei(wei.toString(), Unit.ETHER);
	}

	public void join(String owner, String account, BigDecimal ethers) throws Exception {
		Lottery lottery = loadContract(owner, account);
		TransactionReceipt tx = lottery.enter(Convert.toWei(ethers, Unit.ETHER).toBigInteger()).send();
		tx.getLogs().forEach(LOGGER::info);
	}

	public String deployLottery(String owner) throws Exception {
		LOGGER.info("Deploying Lottery...");
		Lottery contract = Lottery.deploy(web3j, txManager(owner), config.gas()).send();
		LOGGER.info("Deployed new contract with address: " + contract.getContractAddress());
		lotteryByOwner.put(owner, contract.getContractAddress());
		return contract.getContractAddress();
	}

	@SuppressWarnings("unchecked")
	public List<String> getPlayers(String owner) throws Exception {
		Lottery lottery = loadContractFromOwner(owner);
		List<String> players = lottery.getPlayers().send();
		return players;
	}

	public String pickWinner(String owner) throws Exception {
		Lottery lottery = loadContractFromOwner(owner);
		lottery.pickWinner().send();
		lotteryByOwner.remove(owner);
		return lottery.getWinner().send();
	}

	private Lottery loadContractFromOwner(String owner) {
		return loadContract(owner, owner);
	}

	private Lottery loadContract(String owner, String accountAddress) {
		return Lottery.load(lotteryByOwner.get(owner), web3j, txManager(accountAddress), config.gas());
	}

	private TransactionManager txManager(String address) {
		return new ClientTransactionManager(web3j, address);
	}
}

@ConfigProperties(prefix = "lottery.contract")
public class LotteryProperties {
	private BigInteger gasPrice;
	private BigInteger gasLimit;

	// getters and setters

	@Transient
	public StaticGasProvider gas() {
		return new StaticGasProvider(gasPrice, gasLimit);
	}
}

@Path("/lottery")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Tags(value = @Tag(name = "lottery", description = "All the Lottery methods"))
public class OwnerResource {

	@Inject
	LotteryService service;

	@POST
	@Path("/{owner}")
	@Operation(summary = "Deploy a new Lottery ")
	@APIResponses(value = { @APIResponse(responseCode = "200", description = "Return the lottery account") })
	public Account deploy(@Parameter(description = "Owner account", required = true) @PathParam("owner") String owner)
			throws Exception {
		Account account = new Account();
		account.setAccount(service.deployLottery(owner));
		return account;
	}

	@GET
	@Path("/{owner}/balance")
	@Operation(summary = "Get the balance of the Lottery contract")
	@APIResponses(value = { @APIResponse(responseCode = "200", description = "Return the lottery balance") })
	public Quantity getBalance(
			@Parameter(description = "Owner account", required = true) @PathParam("owner") String owner)
			throws Exception {
		Quantity quantity = new Quantity();
		quantity.setEthers(service.getBalance(owner));
		return quantity;
	}

	@POST
	@Path("/{owner}/finish")
	@Operation(summary = "Finish the Lottery and pick a winner")
	@APIResponses(value = {
			@APIResponse(responseCode = "200", description = "Return the winner account", content = @Content(schema = @Schema(implementation = Account.class))) })
	public Account pickWinner(
			@Parameter(description = "Owner account", required = true) @PathParam("owner") String owner)
			throws Exception {
		Account winner = new Account();
		winner.setAccount(service.pickWinner(owner));
		return winner;
	}

	@GET
	@Path("/{owner}/players")
	@Operation(summary = "Return all the players in the lottery")
	@APIResponses(value = { @APIResponse(responseCode = "200", description = "Return the list of players") })
	public List<String> getPlayers(
			@Parameter(description = "Owner account", required = true) @PathParam("owner") String owner)
			throws Exception {
		return service.getPlayers(owner);
	}

	@POST
	@Path("/{owner}/players/{account}")
	@Consumes(MediaType.APPLICATION_JSON)
	@Operation(summary = "Join a new player in the lottery")
	public void joinLottery(@Parameter(description = "Owner account", required = true) @PathParam("owner") String owner,
			@Parameter(description = "Player account", required = true) @PathParam("account") String account,
			@Parameter(description = "Quantity", required = true) Quantity quantity) throws Exception {
		service.join(owner, account, quantity.getEthers());
	}
}

public class GanacheTestResource implements QuarkusTestResourceLifecycleManager {

	public static final String URL_PROPERTY = "quarkus.web3j.url";
	private static final int PORT = 8545;
	private static final Logger LOGGER = LoggerFactory.getLogger(GanacheTestResource.class);

	private final GenericContainer<?> resource;

	@SuppressWarnings("resource")
	public GanacheTestResource() {
    resource = new GenericContainer<>("trufflesuite/ganache-cli")
        .withExposedPorts(PORT)
        .withCommand("--accounts 10")
        .withLogConsumer(new Slf4jLogConsumer(LOGGER))
				.waitingFor(Wait.forLogMessage(".*Listening on 0.0.0.0.*", 1));
	}

	@Override
	public Map<String, String> start() {
		resource.start();
		return Collections.singletonMap(URL_PROPERTY, getNodeUrl());
	}

	@Override
	public void stop() {
		resource.stop();
	}

	private String getNodeUrl() {
		return String.format("http://localhost:%s", resource.getMappedPort(PORT));
	}

}

@QuarkusTest
@QuarkusTestResource(GanacheTestResource.class)
public class OwnerResourceTest {

	private static final String OWNER_PATH = "/lottery/%s";

	@Inject
	Web3j web3j;

	private String owner;
	private Iterator<String> availableAccounts;
	private Response response;

	@BeforeEach
	public void setup() throws IOException {
		RestAssured.defaultParser = Parser.JSON;
		List<String> accounts = web3j.ethAccounts().send().getAccounts();
		owner = accounts.get(0);
		List<String> players = new ArrayList<>(accounts.size() - 1);
		for (int index = 1; index < accounts.size(); index++) {
			players.add(accounts.get(index));
		}

		availableAccounts = players.iterator();
	}

	@Test
	public void testDeploy() {
		whenDeployLottery();
		thenReturnsOk();
	}

	@Test
	public void testNoPlayers() {
		givenLottery();
		whenGetPlayers();
		thenPlayersIsEmpty();
	}

	@Test
	public void testJoinPlayers() {
		givenLottery();
		String newPlayer = whenJoinNewPlayer(2.0);
		whenGetPlayers();
		thenPlayerIsFound(newPlayer);
	}

	@Test
	public void testBalance() {
		givenLottery();
		givenPlayerInLotteryWithEther(2.0);
		whenGetBalance();
		thenBalanceIs(2.0);
	}

	@Test
	public void testPickWinner() {
		givenLottery();
		String player = givenPlayerInLotteryWithEther(2.0);
		whenPickWinner();
		thenWinnerIs(player);
	}

	// given, when, then methods

}