/**
 * Contract Factory
 *
 * Creates typed contract instances for interacting with deployed smart contracts.
 */

import { Abi } from '@tevm/voltaire/Abi';
import { Address } from '@tevm/voltaire/Address';
import { Hex } from '@tevm/voltaire/Hex';
import * as TransactionHash from '@tevm/voltaire/TransactionHash';
// If you copied EventStream from this guide, import locally:
import { EventStream } from './EventStream.js';

class ContractFunctionNotFoundError extends Error {
  name = 'ContractFunctionNotFoundError';
  constructor(functionName) {
    super(`Function "${functionName}" not found in contract ABI`);
  }
}

class ContractEventNotFoundError extends Error {
  name = 'ContractEventNotFoundError';
  constructor(eventName) {
    super(`Event "${eventName}" not found in contract ABI`);
  }
}

class ContractReadError extends Error {
  name = 'ContractReadError';
  constructor(functionName, cause) {
    super(`Failed to read "${functionName}" from contract`);
    this.cause = cause;
  }
}

class ContractWriteError extends Error {
  name = 'ContractWriteError';
  constructor(functionName, cause) {
    super(`Failed to write "${functionName}" to contract`);
    this.cause = cause;
  }
}

export function Contract(options) {
  const { abi: abiItems, provider } = options;
  const address = Address.from(options.address);
  const abi = Abi(abiItems);
  const addressHex = Hex.fromBytes(address);

  // Read methods (view/pure) via eth_call
  const read = new Proxy({}, {
    get(_target, prop) {
      if (typeof prop !== 'string') return undefined;
      const functionName = prop;

      return async (...args) => {
        const fn = abi.getFunction(functionName);
        if (!fn || (fn.stateMutability !== 'view' && fn.stateMutability !== 'pure')) {
          throw new ContractFunctionNotFoundError(functionName);
        }

        try {
          const data = abi.encode(functionName, args);
          const result = await provider.request({
            method: 'eth_call',
            params: [{ to: addressHex, data: Hex.fromBytes(data) }, 'latest'],
          });
          const decoded = abi.decode(functionName, Hex.toBytes(result));
          return decoded.length === 1 ? decoded[0] : decoded;
        } catch (error) {
          if (error instanceof ContractFunctionNotFoundError) throw error;
          throw new ContractReadError(functionName, error);
        }
      };
    },
  });

  // Write methods (nonpayable/payable) via eth_sendTransaction
  const write = new Proxy({}, {
    get(_target, prop) {
      if (typeof prop !== 'string') return undefined;
      const functionName = prop;

      return async (...args) => {
        const fn = abi.getFunction(functionName);
        if (!fn || (fn.stateMutability !== 'nonpayable' && fn.stateMutability !== 'payable')) {
          throw new ContractFunctionNotFoundError(functionName);
        }

        try {
          const data = abi.encode(functionName, args);
          const txHash = await provider.request({
            method: 'eth_sendTransaction',
            params: [{ to: addressHex, data: Hex.fromBytes(data) }],
          });
          return TransactionHash.fromHex(txHash);
        } catch (error) {
          if (error instanceof ContractFunctionNotFoundError) throw error;
          throw new ContractWriteError(functionName, error);
        }
      };
    },
  });

  // Gas estimation via eth_estimateGas
  const estimateGas = new Proxy({}, {
    get(_target, prop) {
      if (typeof prop !== 'string') return undefined;
      const functionName = prop;

      return async (...args) => {
        const fn = abi.getFunction(functionName);
        if (!fn || (fn.stateMutability !== 'nonpayable' && fn.stateMutability !== 'payable')) {
          throw new ContractFunctionNotFoundError(functionName);
        }

        const data = abi.encode(functionName, args);
        const gasHex = await provider.request({
          method: 'eth_estimateGas',
          params: [{ to: addressHex, data: Hex.fromBytes(data) }],
        });
        return BigInt(gasHex);
      };
    },
  });

  // Events - returns EventStream instances
  const events = new Proxy({}, {
    get(_target, prop) {
      if (typeof prop !== 'string') return undefined;
      const eventName = prop;

      return (filter) => {
        const event = abi.getEvent(eventName);
        if (!event) throw new ContractEventNotFoundError(eventName);
        return EventStream({ provider, address, event, filter });
      };
    },
  });

  return { address, abi, read, write, estimateGas, events };
}