import Web3 from "web3";

if (Web3 === undefined) {
	Web3 = require('web3');
}

// TODO: Load these from json external source
const abis = {
	bancor: {
		'network':[
		],
		'contract_registry': [
    {
        "inputs": [
          {
            "internalType": "bytes32",
            "name": "_contractName",
            "type": "bytes32"
          }
        ],
        "name": "getAddress",
        "outputs": [
          {
            "internalType": "address",
            "name": "",
            "type": "address"
          }
        ],
        "stateMutability": "view",
        "type": "function",
        "constant": true
      }
  ],
	'converter_registry': [
	{
      "inputs": [],
      "name": "getConvertibleTokens",
      "outputs": [
        {
          "internalType": "address[]",
          "name": "",
          "type": "address[]"
        }
      ],
      "stateMutability": "view",
      "type": "function",
      "constant": true
    },
  ],
	},
	common: {
	'erc20': [
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "name": "balanceOf",
      "outputs": [
        {
          "internalType": "uint256",
          "name": "",
          "type": "uint256"
        }
      ],
      "stateMutability": "view",
      "type": "function",
      "constant": true
    },
    {
      "inputs": [],
      "name": "decimals",
      "outputs": [
        {
          "internalType": "uint8",
          "name": "",
          "type": "uint8"
        }
      ],
      "stateMutability": "view",
      "type": "function",
      "constant": true
    },
    {
      "inputs": [],
      "name": "name",
      "outputs": [
        {
          "internalType": "string",
          "name": "",
          "type": "string"
        }
      ],
      "stateMutability": "view",
      "type": "function",
      "constant": true
    },
    {
      "inputs": [],
      "name": "symbol",
      "outputs": [
        {
          "internalType": "string",
          "name": "",
          "type": "string"
        }
      ],
      "stateMutability": "view",
      "type": "function",
      "constant": true
    },
  ]
	}
};

const topics = {
	erc20: {
		'transfer': '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
		'convert': '0x7154b38b5dd31bb3122436a96d4e09aba5b323ae1fd580025fab55074334c095'
	}
};


function Token(address, name, symbol) {
	let self = this;
	self.address = address;
	self.name = name;
	self.symbol = symbol;
}

Token.prototype.toString = function() {
	let self = this;
	return 'Token: ' + self.name + ' (' + self.symbol + ')';
}

export function Registry(w3, address) {
	let self = this;
	self.w3 = w3;
	self.contracts = {
		'bancor_contract_registry': new self.w3.eth.Contract(abis.bancor['contract_registry'], address),
	};
	self.contracts_r = {};
	self.contracts_r[address] = self.contracts['bancor_contract_registry'];

	self.tokens = [];
	self.tokens_s = {};
	self.tokens_r = {};

	self.init = {
		network: [1, 3], // current index, target index
		tokens: [0, -1], // current index, target index
	}

	self.ontokensload= function(n) {
		console.debug('tokens loaded', n);
	}
	self.onregistryload= function() {
		console.debug('registry loaded');
	}
}

Registry.prototype.load = async function() {
	console.debug('loading registry');
	let self = this;

	const cr = self.contracts['bancor_contract_registry'];
	let crid_hex = self.w3.utils.toHex('BancorConverterRegistry');
	let shaid = self.w3.eth.abi.encodeParameter('bytes32', crid_hex)
	cr.methods.getAddress(shaid).call().then((address) => {
		self.contracts['bancor_converter_registry'] = new self.w3.eth.Contract(abis.bancor['converter_registry'], address);
		self.contracts_r[address] = self.contracts['bancor_converter_registry'];
		console.log('bancor converter registry', address);
		self.load_tokens();
		self.init.network[0]++;
		if (self.init.network[0] == self.init.network[1]) {
			self.onregistryload(self.init.network[0]);
		}
	});
	crid_hex = self.w3.utils.toHex('BancorNetwork');
	shaid = self.w3.eth.abi.encodeParameter('bytes32', crid_hex)
	cr.methods.getAddress(shaid).call().then((address) => {
		self.contracts['bancor_network'] = new self.w3.eth.Contract(abis.bancor['network'], address);
		self.contracts_r[address] = self.contracts['bancor_network'];
		console.log('bancor network', address);
		self.init.network[0]++;
		if (self.init.network[0] == self.init.network[1]) {
			self.onregistryload(self.init.network[0]);
		}
	});
};

Registry.prototype.load_tokens = async function() {
	console.debug('loading tokens');
	let self = this;
	const cr = self.contracts['bancor_converter_registry'];
	cr.methods.getConvertibleTokens().call().then(async (addresses) => {
		self.init.tokens[1] = addresses.length;
		for (const address of addresses) {
			await self.add_token(address);
			console.debug('l ', self.tokens.length, addresses.length);
			if (self.tokens.length === addresses.length) {
				// self.onload();
			}
		}
  });
};

Registry.prototype.add_token = async function(address) {
	let self = this;
	const ct = new self.w3.eth.Contract(abis.common['erc20'], address);
	const symbol = await ct.methods.symbol().call();
	const name = await ct.methods.name().call();
	const t = new Token(address, symbol, name);
	const ti = self.tokens.length;
	self.tokens.push(t);
	self.tokens[t.symbol] = self.tokens[ti];
	self.tokens_r[address] = self.tokens[ti];
	self.init.tokens[0]++;
	console.log('added token', t.toString(), ti, address);
	if (self.init.tokens[0] == self.init.tokens[1]) {
		self.ontokenload(self.init.tokens[0]);
	}
};

function Tx(block, tx_index, tx_hash, timestamp, success) {
	let self = this;

	self.block = block;
	self.txIndex = tx_index;
	self.txHash = tx_hash;
	self.timestamp = timestamp;
	self.success = success;
}

function Transfer(tx, token, from, to, value, timestamp, block, transaction) {
	let self = this;

	self.from = from;
	self.to = to;
	self.token = token;
	self.value = value;
	self.tx = tx;
}

function Conversion(tx, sourceToken, destinationToken, trader, fromValue, toValue) {
	let self = this;

	self.sourceToken = sourceToken;
	self.destinationToken = destinationToken;
	self.trader = trader;
	self.fromValue = fromValue;
	self.toValue = toValue;
	self.tx = tx;
}

export function TransactionHelper(w3, registry) {
	let self = this;

	self.registry = registry;
	self.w3 = w3;
	self.ontransfer = (t) => {
		console.debug('transfer ', t);
	}
	self.onconversion = (c) => {
		console.debug('convert ', c);
	}
}

TransactionHelper.prototype.processTokenTransactionLog = async function(success, t, log) {
	let self = this;

	if (log.topics[0] == topics.erc20['transfer']) {
		const block = await self.w3.eth.getBlock(log.blockNumber);
		const from = self.w3.utils.toChecksumAddress(log.topics[1].substring(26, 66));
		const to = self.w3.utils.toChecksumAddress(log.topics[2].substring(26, 66));
		const value = self.w3.utils.hexToNumber(log.data);
		const tx = new Tx(log.blockNumber, log.transactionIndex, log.transactionHash, block.timestamp, success);
		const transfer = new Transfer(tx, t, from, to, value);
		self.ontransfer(transfer);
	}
}

TransactionHelper.prototype.processConvertTransactionLog = async function(success, log) {
	let self = this;

	if (log.topics[0] == topics.erc20['convert']) {
		const block = await self.w3.eth.getBlock(log.blockNumber);
		const sourceToken_address = self.w3.utils.toChecksumAddress('0x' + log.topics[1].substring(26, 66));
		const sourceToken = self.registry.tokens_r[sourceToken_address];
		const destinationToken_address = self.w3.utils.toChecksumAddress('0x' + log.topics[2].substring(26, 66));
		const destinationToken = self.registry.tokens_r[destinationToken_address];
		const fromValue = self.w3.utils.hexToNumber(log.data.substring(0, 66));
		const toValue = self.w3.utils.hexToNumber('0x' + log.data.substring(66, 130));
		const trader = self.w3.utils.toChecksumAddress('0x' + log.data.substring(154));
		const tx = new Tx(log.blockNumber, log.transactionIndex, log.transactionHash, block.timestamp, success);
		const cv = new Conversion(tx, sourceToken, destinationToken, trader, fromValue, toValue);
		self.onconversion(cv);
	}
}

TransactionHelper.prototype.processReceipt = async function(r) {
	let self = this;

	const logs = r.logs;
	for (let i = 0; i < logs.length; i++) {
		const contract_address = logs[i].address;
		const t = self.registry.tokens_r[contract_address];
		if (t !== undefined) {
			self.processTokenTransactionLog(r.status, t, logs[i]);
		} else {
			if (self.registry.contracts_r[contract_address] !== undefined) {
				self.processConvertTransactionLog(r.status, logs[i]);
			}
		}
	}
}