/*
* This file is auto-generated using abi-gen. Any changes will be reverted
*/

/* tslint:disable:variable-name */

import { isDefined, bindNestedAll } from "@joincivil/utils";
import {TransactionConfig} from "web3-core";

import { createTwoStepSimple } from "../../utils/contracts";
import { BaseMultisigProxy, MultisigProxyTransaction } from "../../multisig/basemultisigproxy";
import { Contract as IContract } from "../../interfaces/contract";
import { EthApi } from "@joincivil/ethapi";
import { EthAddress } from "../../../types";

// hack(dankins): abi-gen things these are bignumber.js, but they are actually returned as strings
// https://github.com/0xProject/0x-monorepo/blob/development/packages/abi-gen/src/utils.ts#L64
type BigNumber = string;

// TODO(ritave): Abi-Gen doesn't support lowercase contractName so we can't
// import the Contract wrappers, we're using generics instead
// This means calls to instance are untyped inside are using (this: any) type
export class CivilTCRMultisigProxy extends BaseMultisigProxy {
/**
 * Creates a multisig wrapper around a contract
 * @param ethApi Web3 API
 * @param instance Contract we are wrapping
 * @param multisigAddress (optional) Address of multisig wallet - if not supplied, will check if contract is owned by a
 * multisig wallet and use that instead
 */
public static async create(
ethApi: EthApi,
instance: IContract,
multisigAddress?: EthAddress,
): Promise<CivilTCRMultisigProxy> {
  const proxy = new CivilTCRMultisigProxy(ethApi, instance);
  await proxy.resolveMultisig(multisigAddress);
  return proxy;
  }

  /**
   * Creates a wrapper around a contract with identical API to multisig wrapper, but all transactions are passed directly
   * to contract. Essentially just a helper for when we know multisig isn't needed and want a synchronous call.
   * @param ethApi Web3 API
   * @param instance Contract we are wrapping
   */
  public static createNonMultisig(
  ethApi: EthApi,
  instance: IContract,
  ): CivilTCRMultisigProxy {
  const proxy = new CivilTCRMultisigProxy(ethApi, instance);
  // No call to `proxy.resolveMultisig`, `proxy.multisig` will remain undefined
  return proxy;
  }

  public deposit = {
    async sendTransactionAsync(
      listingAddress: string,
      _amount: BigNumber,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).deposit.sendTransactionAsync(
              listingAddress,
              _amount,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).deposit.getRaw(
        listingAddress,
        _amount,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public claimRewards = {
    async sendTransactionAsync(
      _challengeIDs: BigNumber[],
      _salts: BigNumber[],
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).claimRewards.sendTransactionAsync(
              _challengeIDs,
              _salts,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).claimRewards.getRaw(
        _challengeIDs,
        _salts,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public exit = {
    async sendTransactionAsync(
      listingAddress: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).exit.sendTransactionAsync(
              listingAddress,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).exit.getRaw(
        listingAddress,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public withdraw = {
    async sendTransactionAsync(
      listingAddress: string,
      _amount: BigNumber,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).withdraw.sendTransactionAsync(
              listingAddress,
              _amount,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).withdraw.getRaw(
        listingAddress,
        _amount,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public updateStatuses = {
    async sendTransactionAsync(
      listingAddresses: string[],
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).updateStatuses.sendTransactionAsync(
              listingAddresses,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).updateStatuses.getRaw(
        listingAddresses,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public apply = {
    async sendTransactionAsync(
      listingAddress: string,
      amount: BigNumber,
      data: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).apply.sendTransactionAsync(
              listingAddress,
              amount,
              data,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).apply.getRaw(
        listingAddress,
        amount,
        data,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public requestAppeal = {
    async sendTransactionAsync(
      listingAddress: string,
      data: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).requestAppeal.sendTransactionAsync(
              listingAddress,
              data,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).requestAppeal.getRaw(
        listingAddress,
        data,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public grantAppeal = {
    async sendTransactionAsync(
      listingAddress: string,
      data: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).grantAppeal.sendTransactionAsync(
              listingAddress,
              data,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).grantAppeal.getRaw(
        listingAddress,
        data,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public transferGovernment = {
    async sendTransactionAsync(
      newGovernment: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).transferGovernment.sendTransactionAsync(
              newGovernment,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).transferGovernment.getRaw(
        newGovernment,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public updateStatus = {
    async sendTransactionAsync(
      listingAddress: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).updateStatus.sendTransactionAsync(
              listingAddress,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).updateStatus.getRaw(
        listingAddress,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public challenge = {
    async sendTransactionAsync(
      listingAddress: string,
      data: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).challenge.sendTransactionAsync(
              listingAddress,
              data,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).challenge.getRaw(
        listingAddress,
        data,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public challengeGrantedAppeal = {
    async sendTransactionAsync(
      listingAddress: string,
      data: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).challengeGrantedAppeal.sendTransactionAsync(
              listingAddress,
              data,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).challengeGrantedAppeal.getRaw(
        listingAddress,
        data,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public claimReward = {
    async sendTransactionAsync(
      _challengeID: BigNumber,
      _salt: BigNumber,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CivilTCRMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).claimReward.sendTransactionAsync(
              _challengeID,
              _salt,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).claimReward.getRaw(
        _challengeID,
        _salt,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };

  private constructor(
  ethApi: EthApi,
  instance: IContract,
  ) {
  super(ethApi, instance);
  bindNestedAll(this, ["constructor", "instance", "multisig", "ethApi"]);
  }
  }