import { TronWeb } from '../../tronweb.js';
import utils from '../../utils/index.js';
import { Method } from './method.js';
import { buildReadNamespace, buildWriteNamespace } from './readWrite.js';
// When the ABI itself defines a function named `read`/`write`, the legacy flat
// call surface must stay reachable as `contract.read(...)`/`contract.write(...)`.
// Wrap the legacy call in a Proxy whose property access and enumeration are
// served entirely by the namespace, so both surfaces share the one getter.
function wrapReservedNamespace(namespace, legacyCall) {
    if (typeof legacyCall !== 'function')
        return namespace;
    return new Proxy(legacyCall, {
        get: (_target, prop) => namespace[prop],
        has: (_target, prop) => prop in namespace,
        ownKeys: () => Reflect.ownKeys(namespace),
        getOwnPropertyDescriptor: (_target, prop) => Object.getOwnPropertyDescriptor(namespace, prop),
    });
}
export class Contract {
    tronWeb;
    abi;
    address;
    eventListener;
    bytecode;
    deployed;
    lastBlock;
    methods;
    methodInstances;
    props;
    _readNamespace;
    _writeNamespace;
    constructor(tronWeb, abi = [], address) {
        if (!tronWeb || !(tronWeb instanceof TronWeb))
            throw new Error('Expected instance of TronWeb');
        this.tronWeb = tronWeb;
        this.address = address;
        this.abi = abi;
        this.eventListener = false;
        this.bytecode = false;
        this.deployed = false;
        this.lastBlock = false;
        this.methods = Object.create(null);
        this.methodInstances = Object.create(null);
        this.props = [];
        if (utils.address.isAddress(address)) {
            this.deployed = true;
        }
        else {
            this.address = false;
        }
        this.loadAbi(abi);
    }
    /**
     * Type-safe read namespace:
     * every `view`/`pure` ABI function is callable as
     * `contract.read.fn([args], { from, value })` and resolves to the decoded
     * result directly. Rebuilt lazily whenever the contract ABI is replaced.
     */
    get read() {
        if (!this._readNamespace || this._readNamespace.abi !== this.abi) {
            this._readNamespace = {
                abi: this.abi,
                namespace: wrapReservedNamespace(buildReadNamespace(this), this.methods['read']),
            };
        }
        return this._readNamespace.namespace;
    }
    /**
     * Type-safe write namespace:
     * every state-changing ABI function is callable as
     * `contract.write.fn([args], { account, value, feeLimit, tokenId, tokenValue, permissionId })`,
     * signed with the instance's default private key, broadcast, and resolved to
     * the transaction ID. Rebuilt lazily whenever the contract ABI is replaced.
     */
    get write() {
        if (!this._writeNamespace || this._writeNamespace.abi !== this.abi) {
            this._writeNamespace = {
                abi: this.abi,
                namespace: wrapReservedNamespace(buildWriteNamespace(this), this.methods['write']),
            };
        }
        return this._writeNamespace.namespace;
    }
    hasProperty(property) {
        // eslint-disable-next-line no-prototype-builtins
        return this.hasOwnProperty(property) || this.__proto__.hasOwnProperty(property);
    }
    loadAbi(abi) {
        this.abi = abi;
        this.methods = Object.create(null);
        this.methodInstances = Object.create(null);
        this.props.forEach((prop) => delete this[prop]);
        abi.forEach((func) => {
            // Don't build a method for constructor function. That's handled through contract create.
            // Don't build a method for error function.
            if (!func.type || ['constructor', 'error'].includes(func.type.toLowerCase()))
                return;
            const method = new Method(this, func);
            const methodCall = method.onMethod.bind(method);
            const { name, functionSelector, signature } = method;
            const internalName = name;
            const internalFunctionSelector = functionSelector;
            const internalSignature = signature;
            this.methods[name] = methodCall;
            this.methods[functionSelector] = methodCall;
            this.methods[signature] = methodCall;
            this.methodInstances[internalName] = method;
            this.methodInstances[internalFunctionSelector] = method;
            this.methodInstances[internalSignature] = method;
            if (!this.hasProperty(name)) {
                this[name] = methodCall;
                this.props.push(name);
            }
            if (!this.hasProperty(functionSelector)) {
                this[functionSelector] = methodCall;
                this.props.push(functionSelector);
            }
            if (!this.hasProperty(signature)) {
                this[signature] = methodCall;
                this.props.push(signature);
            }
        });
    }
    decodeInput(data) {
        const methodName = data.substring(0, 8);
        const inputData = data.substring(8);
        if (!this.methodInstances[methodName])
            throw new Error('Contract method ' + methodName + ' not found');
        const methodInstance = this.methodInstances[methodName];
        return {
            name: methodInstance.name,
            params: this.methodInstances[methodName].decodeInput(inputData),
        };
    }
    async new(options, privateKey = this.tronWeb.defaultPrivateKey) {
        const address = this.tronWeb.address.fromPrivateKey(privateKey);
        const transaction = await this.tronWeb.transactionBuilder.createSmartContract(options, address);
        const signedTransaction = await this.tronWeb.trx.sign(transaction, privateKey);
        const contract = await this.tronWeb.trx.sendRawTransaction(signedTransaction);
        if (contract.code) {
            throw {
                error: contract.code,
                message: this.tronWeb.toUtf8(contract.message),
            };
        }
        await utils.sleep(3000);
        const abi = signedTransaction.raw_data.contract[0].parameter.value.new_contract.abi.entrys || [];
        return this.tronWeb.contract(abi, signedTransaction.contract_address);
    }
    async at(contractAddress) {
        try {
            const contract = await this.tronWeb.trx.getContract(contractAddress);
            if (!contract.contract_address) {
                throw new Error('Unknown error: ' + JSON.stringify(contract, null, 2));
            }
            this.address = contract.contract_address;
            this.bytecode = contract.bytecode;
            this.deployed = true;
            this.loadAbi(contract.abi ? (contract.abi.entrys ? contract.abi.entrys : []) : []);
            return this;
        }
        catch (ex) {
            if (ex.toString().includes('does not exist')) {
                throw new Error('Contract has not been deployed on the network');
            }
            throw new Error(ex);
        }
    }
}
export { Method } from './method.js';
export { buildReadNamespace, buildWriteNamespace } from './readWrite.js';
//# sourceMappingURL=index.js.map