//Declare an Event
event Deposit(address indexed _from, bytes32 indexed _id, uint _value);

//Emit an event
emit Deposit(msg.sender, _id, msg.value);

pragma solidity ^0.6.12;

contract StatefulContract {
    // sample event
    event SetMessage(address indexed from, string message);

    // the message we're storing
    string message;

    constructor(string memory message_) public {
        emit SetMessage(msg.sender, message_);
        message = message_;
    }

    function set_message(string memory message_) public {
        emit SetMessage(msg.sender, message_);
        message = message_;
    }

    // return a string
    function get_message() public view returns (string memory messageOut) {
        messageOut = message;
    }
}

async function main() {
	// deploy the contract to Hedera from bytecode
	const contractId = await deployContract();

	// query the contract's get_message function
	await queryGetMessage(contractId);

	// call the contract's set_message function
	await callSetMessage(contractId, "Hello again");

	// query the contract's get_message function
	await queryGetMessage(contractId);

	// call the contract's get_message function
	await callGetMessage(contractId);

	// get call events from a transaction record
	await getEventsFromRecord(contractId);

	// get contract events from a mirror node
	await getEventsFromMirror(contractId);
}

async function getEventsFromRecord(contractId) {
	console.log(`\nGetting event(s) from record`);

	// calling "set_message" with the current date/time to generate a new event
	const newMessage = new Date().toLocaleString();
	// generate function call with function name and parameters
	const functionCallAsUint8Array = encodeFunctionCall("set_message", [newMessage]);

	console.log(`Calling set_message to trigger new event`);
	// execute the transaction calling the set_message contract function
	const transaction = await new ContractExecuteTransaction()
		.setContractId(contractId)
		.setFunctionParameters(functionCallAsUint8Array)
		.setGas(100000)
		.execute(client);

	// a record contains the output of the function
	// as well as events, let's get events for this transaction
	const record = await transaction.getRecord(client);

	// query the contract's get_message function to witness update
	await queryGetMessage(contractId);

	// the events from the function call are in record.contractFunctionResult.logs.data
	// let's parse the logs using web3.js
	// there may be several log entries
	record.contractFunctionResult.logs.forEach((log) => {
		// convert the log.data (uint8Array) to a string
		let logStringHex = "0x".concat(Buffer.from(log.data).toString("hex"));

		// get topics from log
		let logTopics = [];
		log.topics.forEach((topic) => {
			logTopics.push("0x".concat(Buffer.from(topic).toString("hex")));
		});

		// decode the event data
		const event = decodeEvent("SetMessage", logStringHex, logTopics.slice(1));

		// output the from address stored in the event
		console.log(
			`Record event: from '${AccountId.fromSolidityAddress(event.from).toString()}' update to '${event.message}'`
		);
	});
}

async function queryGetMessage(contractId) {
    console.log(`\nget_message Query`);
    // generate function call with function name and parameters
    const functionCallAsUint8Array = encodeFunctionCall("get_message", []);

    // query the contract
    const contractCall = await new ContractCallQuery()
        .setContractId(contractId)
        .setFunctionParameters(functionCallAsUint8Array)
        .setQueryPayment(new Hbar(2))
        .setGas(100000)
        .execute(client);

    let results = decodeFunctionResult("get_message", contractCall.bytes);
    console.log(results);
}

function decodeFunctionResult(functionName, resultAsBytes) {
    const functionAbi = abi.find((func) => func.name === functionName);
    const functionParameters = functionAbi.outputs;
    const resultHex = "0x".concat(Buffer.from(resultAsBytes).toString("hex"));
    const result = web3.eth.abi.decodeParameters(functionParameters, resultHex);
    return result;
}

function encodeFunctionCall(functionName, parameters) {
    const functionAbi = abi.find((func) => func.name === functionName && func.type === "function");
    const encodedParametersHex = web3.eth.abi.encodeFunctionCall(functionAbi, parameters).slice(2);
    return Buffer.from(encodedParametersHex, "hex");
}

function decodeEvent(eventName, log, topics) {
    const eventAbi = abi.find((event) => event.name === eventName && event.type === "event");
    const decodedLog = web3.eth.abi.decodeLog(eventAbi.inputs, log, topics);
    return decodedLog;
}

async function getEventsFromMirror(contractId) {
	const delay = (ms) => new Promise((res) => setTimeout(res, ms));
	console.log(`\nGetting event(s) from mirror`);
	console.log(`Waiting 10s to allow transaction propagation to mirror`);
	await delay(10000);

	const url = `https://testnet.mirrornode.hedera.com/api/v1/contracts/${contractId.toString()}/results/logs?order=asc`;

	axios
		.get(url)
		.then(function (response) {
			const jsonResponse = response.data;

			jsonResponse.logs.forEach((log) => {
				// decode the event data
				const event = decodeEvent("SetMessage", log.data, log.topics.slice(1));

				// output the from address and message stored in the event
				console.log(
					`Mirror event(s): from '${AccountId.fromSolidityAddress(event.from).toString()}' update to '${event.message}'`
				);
			});
		})
		.catch(function (err) {
			console.error(err);
		});
}