using Phantasma.Tomb.Compilers;

public class MyCompiler 
{
	static void Main(string[] args)
	{
		var sourceFileName = args[0];
		var sourceCode = File.ReadAllText(sourceFilePath);

		var compiler = new TombLangCompiler();	// You could also use SolidityCompiler or your own custom compiler class
		var modules = compiler.Process(sourceCode);

		// This will generate 3 files for each compiled module
		foreach (var module in modules)
		{
			File.WriteAllText(module.Name + ".asm", module.asm);
			File.WriteAllBytes(module.Name + ".pvm", module.script);
			File.WriteAllBytes(module.Name + ".abi",  module.abi.ToByteArray());
		}
	}
}

...
throw "something happened";
...
}

...
import CustomContract; // by doing this, we can now call any public method of CustomContract 

// the sintax is the same as other contract method calls, eg: CustomContract.doSomething(1234);
...
}

...
import MyContracts.CustomContract; // this will search for a .abi file in a folder called MyContracts (within all possible libray path folders specified in the compiler args)
...
}

contract test {
	public sum(a:number, b:number):number
	{
		return a + b;
	}
}

contract test {
	public isEvenAndPositive(n:number):bool
	{
        local cond1:bool  = n>0;
        local cond2: bool = (n%2) == 0;

		if (cond1 && cond2)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

contract test {
    public check(x:number): string {
        switch (x) {
            case 0: return "zero";
            case 1: return "one";
            case 2: return "two";
            default: return "other";
        }
	}
}

const MY_CONST_X : number = 10; // constants can be declared globally (all scripts / contracts in file can use them)

contract test {
	const MY_CONST_Y : number = 20; // constants can be declared inside a contract / script (only visible there)

    public calculate(): number 
	{
		return MY_CONST_X + MY_CONST_Y;
	}
}

contract test {
	global counter: number;

	constructor(owner:address)
	{
		counter = 0;
	}

	public increment()
	{
		if (counter < 0){
			throw "invalid state";
		}
		counter += 1;
	}
}

contract test {
	import Runtime;
	import Map;

	global counters: storage_map<address, number>;

	public increment(from:address)
	{
		Runtime.expect(Runtime.isWitness(from), "witness failed");
		local temp: number;
		temp = counters.get(from);
		temp += 1;
		counters.set(from, temp);
	}
}

contract test {
	global val: string;

	constructor(owner:address)
	{
		val = "hello";
		val += " world";
	}

	public getLength():number
	{
		return val.length();
	}
}

contract test {
	global val: decimal<4>; // the number between <> is the number of decimal places

	constructor(owner:address)
	{
		val = 2.1425;
	}

	public getValue():number
	{
		return val; // this will return 21425, which is the previous value in fixed point format
	}

	public getDecimals():number
	{
		return val.decimals(); // this returns 4 as result
	}

	public sum(other:decimal<4>):number
	{
		return val + other;
	}

}

token BOO {
	property name: string = "BOO"; //placeHolder for compiler reasons
}

contract test {
	global val: decimal<$BOO_DECIMALS>; // using a macro here instead of a hardcoded decimal

	// all rest is similar
}

// NOTE - like other custom types, it is declared outside the scope of a contract
enum MyEnum { A = 0, B = 1, C = 2}
// if the numbers are sequential, it is ok to ommit them, eg:
//enum MyEnum { A, B, C}

contract test {
	global state: MyEnum;

	constructor(owner:address)
	{
		state = MyEnum.B;
	}

	public getValue():MyEnum
	{
		return state;
	}
}

contract test {
	import Map;
	global my_state: storage_map<address, number>;

	constructor(owner:address)
	{
		my_state.set(owner, 42);
	}

	public getState(target:address):number
	{
		return my_state.get(target);
	}
}

contract test {
	import Array;
	public getStrings(): array<string> {
        local result:array<string> = {"A", "B", "C"};
        return result;
    }
}

contract test {
	import Array;

	public toUpper(s:string):string
	{
		local my_array: array<number>;

		// extract chars from string into an array
		my_array = s.toArray();

		local length :number = Array.length(my_array);
		local idx :number = 0;

		while (idx < length) {
			local ch : number = my_array[idx];

			if (ch >= 97) {
				if (ch <= 122) {
					my_array[idx] = ch - 32;
				}
			}

			idx += 1;
		}

		// convert the array back into a unicode string
		local result:string = String.fromArray(my_array); 
		return result;
	}
}

contract test {
	import Time;
	import Hash;
	import String;
	import Address;

	public convertTimeToNumber(x:timestamp):number
	{
		return Time.toNumber(x);
	}

	public convertHashToString(x:hash):string
	{
		return Hash.toString(x);
	}
	
	public convertStringToNumber(x:string):number
	{
		return String.toNumber(x);
	}
	
	public convertAddressToString(x:address):string
	{
		return Address.toString(x);
	}
	
}

contract test {
	import Random;
	import Hash;
	import Runtime;

	global my_state: number;

	public mutateState():number
	{
        // use the current transaction hash to provide a random seed. This makes the result deterministic during node consensus
        // 	optionally we can use other value, depending on your needs, eg: Random.seed(16676869); 
        local tx_hash:hash = Runtime.transactionHash();
        local mySeed:number = tx_hash.toNumber();
		Random.seed(mySeed);
		my_state = Random.generate() % 10; // Use modulus operator to constrain the random number to a specific range
		return my_state;
	}
}

contract test {
	import Runtime;
	import Token;

	public paySomething(from:address, quantity:number)
	{
		Runtime.expect(Runtime.isWitness(from), "witness failed");

		local price: number = 10;
		price *= quantity;

		local thisAddr:address = $THIS_ADDRESS;
		Token.transfer(from, thisAddr, "SOUL", price);

		// TODO after payment give something to 'from' address
	}
}

contract test {
	import Runtime;
	import Token;

	public paySomething(from:address, amount:number, symbol:string,price:number)
	{
		Runtime.expect(Runtime.isWitness(from), "witness failed");

		local flags:TokenFlags = Token.getFlags(symbol);
    if (flags.isSet(TokenFlags.Fungible)) {
			local thisAddr:address = $THIS_ADDRESS;
			Token.transfer(from, thisAddr, "SOUL", price);
		}
	}
}

contract test {
	import Runtime;

	public doSomething(from:address)  {
		Runtime.expect(from.isUser(), "expected user address"); // makes sure the address is of 'user' type
		Runtime.expect(Runtime.isWitness(from), "invalid witness"); // makes sure the transaction was signed by 'from' address
		Runtime.expect(Runtime.gasTarget() == $THIS_ADDRESS, "invalid donation"); // makes sure the transaction fees are donated to this contract

		// actually do something after passing all validation
	}
}

contract test {
	import Call; //alternative method to call another method
	private sum(a:number, b:number): number {
		return a + b;
	}

	public calculatePrice(x:number): number
	{
		local price: number = 10;
		price = this.sum(price, x); // here we use 'this' for calling another method
		//price = Call.method<number>(sum,price,x); //alternative way to call the method
		return price;
	}
}

script startup {

	import Call;

	code(target:address) {
		local temp:number = 50000;
		Call.contract("Stake", "Unstake", target, temp);
	}
}

token GHOST {
	property name: string = "GHOST"; //placeHolder for compiler reasons
}

script deploy {

	import Token;
	import Module;

	code() {
		local maxSupply:number = 50000;
		local decimals:number = 1;
		local flags:TokenFlags = TokenFlags.None;
		Token.create(@P2KAkQRrL62zYvb5198CHBLiKHKr4bJvAG7aXwV69rtbeSz, "GHOST",  "Ghost Token", maxSupply, decimals, flags, Module.getScript(GHOST),  Module.getABI(GHOST));
	}
}

struct my_rom_data {
	name:string;
	counter:number;
}

script token_minter {

	import Token;
	import NFT;

	code(source:address, target:address) {
		local rom_data:my_rom_data = Struct.my_rom_data("hello", 123);
		NFT.mint(source, target, "LOL", rom_data, "ram_can_be_anything",0);
	}
}

script startup {
	code() {

		local temp: string ="";
		asm {
			LOAD $temp "hello"
		}
	}
}

contract test {
	import Token;
	import Runtime;

	event MyPayment:number = "{address} paid {data}"; // here we use a short-form description

	public paySomething(from:address, x:number)
	{
		Runtime.expect(Runtime.isWitness(from), "witness failed");

		local price: number = 10;
		local thisAddr:address = $THIS_ADDRESS;
		Token.transfer(from, thisAddr, "SOUL", price);

		emit MyPayment(from, price);
	}
}

description payment_event {

	code(from:address, amount:number): string {
		local result:string = "";
		result += from;
		result += " paid ";
		result += amount;
		return result;
	}
}

contract test {
	event MyPayment:number = payment_event; // here we use a short-form declaration

	// everything else would be same as previous example
}

struct my_event_data {
	amount:number;
	symbol:string;
}

description payment_event {

	code(from:address, data:my_event_data): string {
		local result:string = "";
		result += from;
		result += " paid ";
		result += data.amount;
		result += " ";
		result += data.symbol;
		return result;
	}
}

contract test {
	event MyPayment:my_event_data = payment_event; // here we use a short-form declaration

	// everything else would be same as previous examples
}

contract test {

	trigger onReceive(from:address,to:address,symbol:string, amount:number)
	{
		if (symbol != "KCAL") {
			throw "can't receive asset: " + symbol;
		}

		return;
	}
}

contract test {

	import Call;

	trigger onReceive(from:address,to:address, symbol:string, amount:number)
	{
		if (symbol != "SOUL") {
			Call.contract<none>("Swap", "SwapTokens", from, symbol, "SOUL", amount);
		}

		return;
	}
}

contract test {

	import Runtime;
	import Map;
	import Call;

	global _counter:number;

	global _callMap: storage_map<address,method>;

	constructor(owner:address)
	{
		_counter = 0;
	}

  private incCounter(target:address) {
		_counter += 1;
	}

	private subCounter(target:address) {
		_counter -= 1;
	}

	public registerUser(from:address, amount:number)
	{
		local target: method;

		if (amount > 10) {
			target = Call.method<method>(incCounter,from);
		}
		else {
			target = Call.method<method>(subCounter,from);
		}

		_callMap.set(from, target);
	}
}

contract test {
	// this method returns an array of strings (could also be numbers, structs, etc)
    public getStrings(): string* {
         return "hello";
         return "world";
         return;
    }
}

contract test {
    public calculate():string {
         local a = "hello ";
         local b = "world";
        return a + b;
    }
}

contract test {
	import Time;
	import Task;

	global victory:bool;
	global deadline:timestamp;

	constructor(owner:address) {
		victory = false;
		time = Time.now() + time.hours(2);
		Task.start(checkResult, owner, 0, TaskFrequency.Always, 999);
	}

	task checkResult()  {
		if (victory) {
			break;
		}

		local now: timestamp = Time.now();

		if (time >= deadline) {
			break;
		}

		continue;
	}

	public win(from:address)
	{
		victory = true;
	}
}

contract test {
	import Runtime;
	import List;
	import Call;

	global owners: storage_list<address>;

	constructor(owner:address)
	{
		owners.add(owner);
	}

	private validateSignatures() {
		local index:number = 0;
		local count:number = owners.count();

		while (index < count) {
			local addr:address = owners.get(index);
			if (!Runtime.isWitness(addr)) {
				throw "missing signature of "+addr;
			}
		}
	}

	public isOwner(target:address):bool {
		local index:number = 0;
		local count:number = owners.count();

		while (index < count) {
			local addr:address = owners.get(index);
			if (addr == target) {
				return true;
			}
		}

		return false;
	}


	public addOwner(target:address) {

		Runtime.expect(!this.isOwner(target), "already is owner");
		this.validateSignatures();
		owners.add(target);
	}


	trigger onSend(from:address, to:address, symbol:string,amount:number){
		this.validateSignatures();
	}
}

token DOG { // this defines the token symbol as DOG
	import Runtime;

	property name:string = "Dog Token";

	property isFungible: bool = true;

	property isDivisible: bool = true;
	property decimals:number = 8; // required only if isDivisible is true

	property isTransferable: bool = true;
	property isBurnable: bool = true;

	property isFinite: bool = false;
	//property maxSupply: number = 1000000; // required only if isFinite is true

	global _admin: address;

	constructor(owner:address)	{
		_admin = owner;
	}

	// allows the token to be upgraded later, remove this trigger if you want a imutable fungible token
	trigger onUpgrade(from:address)
	{
		Runtime.expect(Runtime.isWitness(_admin), "witness failed");
		return;
	}

	// its possible to also add more triggers, custom methods etc
}

struct luchador_rom
{
	genes:bytes;
	name:string;
}

struct luchador_ram
{
	experience:number;
	level:number;
}

struct item_rom
{
	kind:number;
	quality:number;
}

struct item_ram
{
	power:number;
	level:number;
}

token NACHO {
	import NFT;

	global _owner: address;

	const LUCHADOR_SERIES: number = 1;
	const LUCHADOR_SUPPLY: number = 100000;

	const ITEM_SERIES: number = 2;
	const ITEM_SUPPLY: number = 500000;

	property name: string = "Nachomen";

	property isBurnable: bool = true;
	property isFinite: bool = true;
	property isFungible: bool = false;
	property maxSupply: number = LUCHADOR_SUPPLY + ITEM_SUPPLY;

	nft luchador<luchador_rom, luchador_ram> {

		property name: string {
			return _ROM.name;
		}

		property description: string {
			return "Luchador with level " + _RAM.level;
		}

		property imageURL: string {
			return "https://nacho.men/img/luchador/"+ _tokenID;
		}

		property infoURL: string {
			return "https://nacho.men/api/luchador/"+ _tokenID;
		}
	}

	nft item<item_rom, item_ram> {

		property name: string {
			local rom_kind: number = _ROM.kind;
			switch(rom_kind)
			{
				case 1: return "Potion";
				case 2: return "Gloves";
				default: return "Item #" + _ROM.kind;
			}
		}

		property description: string {
			return "Item level " + _RAM.level;
		}

		property imageURL: string {
			return "https://nacho.men/img/item/"+ _tokenID;
		}

		property infoURL: string {
			return "https://nacho.men/api/item/"+ _tokenID;
		}
	}

	constructor (addr:address) {
		_owner = addr;
		// at least one token series must exist, here we create 2 series
		// they don't have to be created in the constructor though, can be created later
		NFT.createSeries(_owner, $THIS_SYMBOL, LUCHADOR_SERIES, LUCHADOR_SUPPLY, TokenSeries.Unique, luchador);
		NFT.createSeries(_owner, $THIS_SYMBOL, ITEM_SERIES, ITEM_SUPPLY, TokenSeries.Unique, item);
	}
}

contract test {

import NFT;
import Array;

public getOwnedList(from:address) : array<number> {
	local symbol: string = "MYTOK";
    local result: array<number> = NFT.getOwnerships(from, symbol);
    return result;
    }
}

contract test {

import NFT;
import Array;

public getFirstInfusedToken(infusedTokenID: number) : Infusion {
    local nfts: array<Infusion> = NFT.getInfusions("MYTOK", infusedTokenID);

    local first: Infusion = nfts[0];

    return first;
    }
}

token BOO {
	property name: string = "BOO"; //placeHolder for compiler reasons
}

contract simple_contract {
	constructor (addr:address) {
		// ...
	}
}

contract my_test {
	import Runtime;
	import Token;

	public transferBoos(quantity:number)
	{
		// The line below showcases 3 different compiler macros.
		// $SIMPLE_CONTRACT_ADDRESS => This macro is the address of the simple_contract declared previously.
		// $THIS_ADDRESS => This macro is the address of the contract currently executing (my_test contract).
		// $BOO_SYMBOL => This macro is the symbol of the BOO token (the string "BOO") 
		Token.transfer($SIMPLE_CONTRACT_ADDRESS, $THIS_ADDRESS, $BOO_SYMBOL, quantity);
	}
}

contract test {

	import Map;
	import Storage;
	import Call;

	global counters: storage_map<number, number>;

	private getContractCount(tokenId:number):number {
		local count:number = Call.interop<none>("Map.Get",  "OTHERCONTRACT", "_storageMap", tokenId, $TYPE_OF(number));
		return count;

	}

	public updateCount(tokenID:number) {
		local contractCounter:number = this.getContractCount(tokenID);
		contractCounter += 1;
		counters.set(tokenID, contractCounter);
	}

	public getCount(tokenID:number):number {
		local temp:number = counters.get(tokenID);
		return temp;
	}
}

contract test {
	register myReg : number;

	private mutate():number
	{
		myReg = myReg + 1;
	}

	public fetch():number
	{
		myReg = 1;
		this.mutate();
		return myReg;
	}
}