/**
 * Hardhat 风格的部署与测试脚本（TypeScript）
 */
interface HardhatRuntime {
  network: { name: string; config: object };
  ethers: {
    getSigners(): Promise<{ address: string; provider: any }[]>;
    getContractFactory(name: string): Promise<any>;
  };
  run(task: string, args: object): Promise<any>;
}

// 模拟 hardhat run 的部署任务
async function deployToken(hre: HardhatRuntime) {
  const [deployer] = await hre.ethers.getSigners();
  console.log("Deploying with:", deployer.address);
  
  const Token = await hre.ethers.getContractFactory("ERC20Token");
  const token = await Token.deploy("MockToken", "MTK", 1000000n);
  // 在 Hardhat 网络中，部署即挖到区块
  console.log("Token deployed to:", token.address);
  return token;
}

// 测试结构：beforeEach + fixture 模式
class HardhatTestSuite {
  private async fixture(): Promise<{ token: MockToken; owner: string; user: string }> {
    const token = await deployToken(this.hre);
    const [owner, user] = (await this.hre.ethers.getSigners()).map(s => s.address);
    return { token, owner, user };
  }
  
  async testTransfer() {
    const { token, owner, user } = await this.fixture();
    const tx = await token.transfer(user, 100n);
    const receipt = await tx.wait();
    
    const balance = await token.balanceOf(user);
    console.assert(balance === 100n, "Transfer failed");
    console.log("Gas used:", receipt.gasUsed);
  }
}

// 模拟 HRE
const hre: HardhatRuntime = {
  network: { name: "hardhat", config: {} },
  ethers: {
    async getSigners() {
      return [
        { address: "0xDeployer...", provider: null },
        { address: "0xUser1...", provider: null },
        { address: "0xUser2...", provider: null },
      ];
    },
    async getContractFactory(name: string) {
      return {
        async deploy(...args: any[]) {
          return { address: "0xToken...", async transfer(to: string, amt: bigint) {
            return { wait: async () => ({ gasUsed: 52000n }) };
          }, async balanceOf(addr: string) { return 100n; }};
        }
      };
    }
  },
  async run(task, args) { return; }
};

new HardhatTestSuite(hre).testTransfer().then(() => console.log("Hardhat test passed"));

// Foundry 测试示例（Solidity 语法）
contract FoundryTest is Test {
    MockToken token;
    
    function setUp() public {
        token = new MockToken(1000000e18);
    }
    
    // 模糊测试：Foundry 自动生成 256 个随机值
    function testFuzzTransfer(address to, uint256 amount) public {
        vm.assume(to != address(0)); // 过滤无效输入
        vm.assume(amount <= token.balanceOf(address(this)));
        
        token.transfer(to, amount);
        assertEq(token.balanceOf(to), amount);
    }
    
    // 不变式测试
    function invariantTotalSupply() public {
        assertEq(token.totalSupply(), 1000000e18);
    }
}

/**
 * 模拟 Foundry 模糊测试引擎的核心逻辑
 */
interface FuzzCase {
  inputs: (bigint | string | boolean)[];
  failed: boolean;
  error?: string;
}

class FuzzEngine {
  private seed: number;
  
  constructor(seed: number = 42) { this.seed = seed; }
  
  private randomBigInt(max: bigint = 2n**256n - 1n): bigint {
    this.seed = (this.seed * 16807 + 0) % 2147483647;
    return BigInt(this.seed) % max;
  }
  
  private randomAddress(): string {
    return "0x" + Array(40).fill(0).map(() => 
      (this.randomBigInt(16n) as unknown as number).toString(16)
    ).join("");
  }
  
  fuzz<E>(
    cases: number,
    testFn: (inputs: (bigint | string)[]) => void,
    invariants: { filter: (inputs: (bigint | string)[]) => boolean }[],
  ): FuzzCase[] {
    const results: FuzzCase[] = [];
    for (let i = 0; i < cases; i++) {
      const inputs: (bigint | string)[] = [
        this.randomAddress(),
        this.randomBigInt(1000000n),
      ];
      
      // 应用不变式过滤器
      const valid = invariants.every(inv => inv.filter(inputs));
      if (!valid) { i--; continue; }
      
      try {
        testFn(inputs);
        results.push({ inputs, failed: false });
      } catch (e) {
        results.push({ inputs, failed: true, error: String(e) });
      }
    }
    return results;
  }
  
  // 最小化反例（shrinking）
  shrink(failure: FuzzCase, testFn: any, invariants: any): FuzzCase {
    // 尝试减小输入值，寻找最小失败案例
    let [addr, amount] = failure.inputs;
    let shrunk = [addr, (amount as bigint) / 2n];
    try {
      testFn(shrunk);
      return failure; // 无法缩小
    } catch {
      return { ...failure, inputs: shrunk };
    }
  }
}

// 模拟 fuzzing ERC20 transfer
const fuzzer = new FuzzEngine(42);
const results = fuzzer.fuzz(
  100,
  ([to, amount]) => {
    if (to === "0x" + "0".repeat(40)) throw new Error("Zero address not allowed");
    if ((amount as bigint) > 1000000n) throw new Error("Exceeds balance");
    // 正常逻辑
  },
  [{ filter: ([to, amount]) => (amount as bigint) <= 1000000n }],
);

const failures = results.filter(r => r.failed);
console.log(`Fuzzed 100 cases, ${failures.length} failures`);
if (failures.length > 0) {
  console.log("First failure:", failures[0].error, "inputs:", failures[0].inputs);
}