export class Crawler {
  private chain: Chain;
  private provider: ethers.JsonRpcProvider;
  private contract: ethers.Contract;
  private lastProcessedBlock: number;
  private blockHashes: Map<number, string>;
  private readonly BATCH_SIZE: number;
  private readonly REORG_DEPTH: number;
  private readonly MIN_CONFIRMATIONS: number;
  private readonly RESTART_DELAY: number;

  constructor(chainId: ChainId) {
    if (!chains[chainId]) {
      throw new Error(`Chain ${chainId} not configured`);
    }

    this.chain = chains[chainId];
    this.provider = new ethers.JsonRpcProvider(this.chain.rpcUrl);
    this.contract = new ethers.Contract(
      this.chain.contracts.dex.address,
      this.chain.contracts.dex.abi,
      this.provider
    );

    this.lastProcessedBlock = 0;
    this.blockHashes = new Map();

    // Chain-specific configs
    this.BATCH_SIZE = this.chain.config.batchSize;
    this.REORG_DEPTH = this.chain.config.reorgDepth;
    this.MIN_CONFIRMATIONS = this.chain.config.minConfirmations;
    this.RESTART_DELAY = this.chain.config.restartDelay;
  }

  private async loadLastProcessedBlock(): Promise<number> {
    const blockInfo = await Block.findOne({ chain: this.chain.name });
    if (blockInfo) {
      return blockInfo.lastProcessedBlock;
    }

    // If no block info exists, create initial entry
    const startBlock = this.chain.contracts.dex.startBlock;
    await Block.create({
      chain: this.chain.name,
      lastProcessedBlock: startBlock,
      updatedAt: new Date(),
    });
    return startBlock;
  }

  private async updateLastProcessedBlock(blockNumber: number): Promise<void> {
    await Block.findOneAndUpdate(
      { chain: this.chain.name },
      {
        lastProcessedBlock: blockNumber,
        updatedAt: new Date(),
      },
      { upsert: true }
    );
    this.lastProcessedBlock = blockNumber;
  }

  private async getBlockHash(blockNumber: number): Promise<string | null> {
    try {
      const block = await this.provider.getBlock(blockNumber);
      return block?.hash ?? null;
    } catch (err) {
      console.error(`❌ Block ${blockNumber} fetch failed:`, err);
      return null;
    }
  }

  private async checkForReorg(latestBlock: number): Promise<number | null> {
    if (this.lastProcessedBlock < latestBlock - this.REORG_DEPTH) {
      return null;
    }

    const checks: Promise<number | null>[] = [];
    for (let i = 1; i <= this.REORG_DEPTH; i++) {
      checks.push(
        this.getBlockHash(this.lastProcessedBlock - i).then((currentHash) => {
          const storedHash = this.blockHashes.get(this.lastProcessedBlock - i);
          if (storedHash && currentHash && storedHash !== currentHash) {
            console.warn(
              `⚠️ Reorg detected at block ${this.lastProcessedBlock - i}`
            );
            return this.lastProcessedBlock - i;
          }
          return null;
        })
      );
    }

    const results = await Promise.all(checks);
    return results.find((block) => block !== null) ?? null;
  }

  private async handleReorg(reorgBlock: number): Promise<void> {
    await Promise.all([
      Transaction.deleteMany({
        chain: this.chain.name,
        blockNumber: { $gte: reorgBlock },
      }),
      Block.findOneAndUpdate(
        { chain: this.chain.name },
        { lastProcessedBlock: reorgBlock }
      ),
    ]);
  }

  private async fetchAndStoreEvents(
    fromBlock: number,
    toBlock: number,
    latestBlock: number
  ): Promise<void> {
    try {
      console.log(`📡 Fetching events: blocks ${fromBlock} → ${toBlock}`);

      const reorgThreshold = latestBlock - this.REORG_DEPTH;

      const [depositEvents, withdrawEvents] = await Promise.all([
        this.contract.queryFilter("Deposit", fromBlock, toBlock) as Promise<
          ethers.EventLog[]
        >,
        this.contract.queryFilter("Withdrawal", fromBlock, toBlock) as Promise<
          ethers.EventLog[]
        >,
      ]);

      // Get block hashes for all blocks in the batch to avoid reorgs
      const blockHashesArray = await Promise.all(
        Array.from({ length: toBlock - fromBlock + 1 }, (_, i) => {
          const blockNumber = fromBlock + i;
          return blockNumber > reorgThreshold
            ? this.getBlockHash(blockNumber)
            : null;
        })
      );
      const transactions: ITransaction[] = [];

      for (const log of [...depositEvents, ...withdrawEvents]) {
        const { transactionHash, blockNumber } = log;
        const timestamp = new Date();

        if (
          log.fragment.name === "Deposit" ||
          log.fragment.name === "Withdraw"
        ) {
          const user = log.args[0];
          const amount = ethers.formatUnits(log.args[1], 18);
          const isDeposit = log.fragment.name === "Deposit";

          transactions.push({
            chain: this.chain.name,
            transactionHash,
            blockNumber,
            user,
            amount,
            type: isDeposit ? "deposit" : "withdraw",
            minConfirmationsRequired: this.MIN_CONFIRMATIONS,
            currentConfirmations: 0,
            isConfirmed: false,
            timestamp,
          } as ITransaction);
        }
      }

      if (transactions.length > 0) {
        await Transaction.insertMany(transactions, { ordered: false });
      }

      console.log(`✅ Saved ${transactions.length} transactions`);

      // Store only relevant block hashes
      blockHashesArray.forEach((hash, i) => {
        const blockNumber = fromBlock + i;
        if (hash) this.blockHashes.set(blockNumber, hash);
      });

      // Trim stored block hashes
      [...this.blockHashes.keys()].forEach((block) => {
        if (block < reorgThreshold) this.blockHashes.delete(block);
      });
    } catch (error) {
      console.error(`❌ Fetch error [${fromBlock} → ${toBlock}]:`, error);
      throw error;
    }
  }

  private async processConfirmations(latestBlock: number): Promise<void> {
    const pendingTransactions = await Transaction.find({
      chain: this.chain.name,
      isConfirmed: false,
    });

    const bulkOps: any[] = [];

    for (const tx of pendingTransactions) {
      const confirmations = latestBlock - tx.blockNumber;

      if (confirmations >= tx.minConfirmationsRequired) {
        bulkOps.push({
          updateOne: {
            filter: { _id: tx._id, transactionHash: tx.transactionHash },
            update: {
              isConfirmed: true,
              currentConfirmations: tx.minConfirmationsRequired,
            },
          },
        });

        if (tx.type === "deposit") {
          bulkOps.push({
            updateOne: {
              filter: { chain: this.chain.name, user: tx.user },
              update: { $inc: { balance: parseFloat(tx.amount) } },
              upsert: true,
            },
          });
        } else if (tx.type === "withdraw") {
          bulkOps.push({
            updateOne: {
              filter: { chain: this.chain.name, user: tx.user },
              update: {
                $pull: { pendingWithdraws: { hash: tx.transactionHash } },
              },
            },
          });
        }
      }
    }

    if (bulkOps.length > 0) {
      await Transaction.bulkWrite(bulkOps);
      console.log(`✅ Processed ${bulkOps.length} transactions`);
    }
  }

  private async crawl(): Promise<void> {
    try {
      const latestBlock = await this.provider.getBlockNumber();
      let fromBlock = await this.loadLastProcessedBlock();
      let toBlock = Math.min(fromBlock + this.BATCH_SIZE, latestBlock);

      const reorgBlock = await this.checkForReorg(latestBlock);
      if (reorgBlock) {
        await this.handleReorg(reorgBlock);
        fromBlock = reorgBlock;
      }

      while (fromBlock < latestBlock) {
        await this.fetchAndStoreEvents(fromBlock, toBlock, latestBlock);
        await this.updateLastProcessedBlock(toBlock);

        fromBlock = toBlock + 1;
        toBlock = Math.min(fromBlock + this.BATCH_SIZE, latestBlock);
      }

      await this.processConfirmations(latestBlock);
      setTimeout(() => this.crawl(), this.RESTART_DELAY);
    } catch (error) {
      console.error("❌ Critical crawler error:", error);
      setTimeout(() => this.crawl(), 5000);
    }
  }

  public async start(): Promise<void> {
    try {
      await mongoose.connect(String(process.env.DATABASE_URI));
      console.log(`✅ Connected to MongoDB for ${this.chain.name}`);
      await this.crawl();
    } catch (error) {
      console.error(
        `❌ Failed to start crawler for ${this.chain.name}:`,
        error
      );
    }
  }

export const chains = {
  1: {
    // Ethereum Mainnet
    name: "ethereum",
    rpcUrl: "https://mainnet.infura.io/v3/YOUR_INFURA_KEY",
    contracts: {
      dex: {
        address: "0xYourContractAddress",
        abi: [
          "event Deposit(address indexed user, uint256 amount)",
          "event Withdrawal(address indexed user, uint256 amount)",
        ],
        startBlock: 12345678,
      },
    },
    config: {
      batchSize: 1000,
      reorgDepth: 10,
      minConfirmations: 6,
      restartDelay: 5000,
    },
  },
};

import mongoose, { Document, Schema } from "mongoose";
import { ChainId } from "../config/chains";

export interface ITransaction extends Document {
  chain: ChainId;
  transactionHash: string;
  blockNumber: number;
  user: string;
  amount: string;
  type: "deposit" | "withdraw";
  minConfirmationsRequired: number;
  currentConfirmations: number;
  isConfirmed: boolean;
  timestamp: Date;
}

export interface IPendingWithdraw {
  hash: string;
  amount: number;
}

export interface IUserBalance extends Document {
  chain: ChainId;
  user: string;
  balance: number;
  pendingWithdraws: IPendingWithdraw[];
}

export interface IBlock extends Document {
  chain: ChainId;
  lastProcessedBlock: number;
  updatedAt: Date;
}

const transactionSchema = new Schema<ITransaction>({
  chain: { type: String, required: true, index: true },
  transactionHash: { type: String, required: true },
  blockNumber: { type: Number, required: true, index: true },
  user: { type: String, required: true },
  amount: { type: String, required: true },
  type: { type: String, enum: ["deposit", "withdraw"], required: true },
  minConfirmationsRequired: { type: Number, required: true },
  currentConfirmations: { type: Number, required: true },
  isConfirmed: { type: Boolean, required: true },
  timestamp: { type: Date, required: true },
});

const userBalanceSchema = new Schema<IUserBalance>({
  chain: { type: String, required: true, index: true },
  user: { type: String, required: true, index: true },
  balance: { type: Number, required: true, default: 0 },
  pendingWithdraws: [
    {
      hash: { type: String, required: true },
      amount: { type: Number, required: true },
    },
  ],
});

const blockSchema = new Schema<IBlock>({
  chain: { type: String, required: true, unique: true },
  lastProcessedBlock: { type: Number, required: true },
  updatedAt: { type: Date, required: true, default: Date.now },
});

export const Transaction = mongoose.model<ITransaction>(
  "Transaction",
  transactionSchema
);
export const UserBalance = mongoose.model<IUserBalance>(
  "UserBalance",
  userBalanceSchema
);
export const Block = mongoose.model<IBlock>("Block", blockSchema);

import { Crawler } from "./crawler.js";

const crawler = new Crawler(1); // Chain ID 1 cho Ethereum Mainnet
crawler.start();