import {
  BadRequestException,
  Body,
  Controller,
  Inject,
  Post,
  Req,
  UseGuards,
} from "@nestjs/common";
import { AuthGuard } from "@nestjs/passport";
import { AdminService } from "src/admin/admin.service";
import { AuthRequest } from "src/common/interfaces";
import {
  transactionQuery,
  transactionSubmitter,
} from "src/common/provider/web3/signer";
import { InternalCustodialService } from "src/shared/custodial/internalCustodial.service";
import { UserService } from "src/user/user.service";
import { QueryBlockchainDto } from "./dtos/query-transaction.dto";
import { TransactionDto } from "./dtos/submit-transaction.dto";
import { getContractByName } from "src/common/provider";

@UseGuards(AuthGuard("jwt"))
@Controller("/api/v1/transaction")
export class TransactionController {
  @Inject(AdminService)
  private readonly adminService: AdminService;
  @Inject(UserService)
  private readonly userService: UserService;
  @Inject(InternalCustodialService)
  private readonly internalInternalCustodialService: InternalCustodialService;

  @Post("/submit")
  async submitTx(
    @Req() request: AuthRequest,
    @Body() transactionDto: TransactionDto,
  ) {
    const { role, email } = request.user;
    const user =
      role === "admin"
        ? await this.adminService.findByEmail(email)
        : (
            await this.userService.findUsersByFilter({
              email: email,
            })
          )[0];
    if (!user) {
      throw new BadRequestException(`No user exist with email ${email}`);
    }
    if (
      !user.wallets.find(
        (wallet) =>
          wallet.address.toLowerCase() ===
          transactionDto.submitterAddress.toLowerCase(),
      )
    ) {
      throw new BadRequestException(
        `No user don't have address ${transactionDto.submitterAddress}`,
      );
    }

    try {
      const custody = await this.internalInternalCustodialService.findOne(
        user.wallets[0].address,
      );
      const contractAddress =
        transactionDto.contractAddress ||
        getContractByName[transactionDto.contractName].address;
      return await transactionSubmitter({
        signerKey: custody.privateKey,
        contractAddress,
        contractName: transactionDto.contractName,
        transactionName: transactionDto.transactionName,
        args: transactionDto.args,
      });
    } catch (e) {
      throw new Error("Blockchain Tx Failed");
    }
  }

  @Post("/query")
  async queryTx(@Body() transactionDto: QueryBlockchainDto) {
    const contractAddress =
      transactionDto.contractAddress ||
      getContractByName[transactionDto.contractName].address;
    const queryResult = await transactionQuery({
      contractAddress,
      contractName: transactionDto.contractName,
      queryName: transactionDto.queryName,
      args: transactionDto.args,
    });
    return { queryResult: queryResult.toString() };
  }
}