/*
* 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 CVLTokenMultisigProxy 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<CVLTokenMultisigProxy> {
  const proxy = new CVLTokenMultisigProxy(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,
  ): CVLTokenMultisigProxy {
  const proxy = new CVLTokenMultisigProxy(ethApi, instance);
  // No call to `proxy.resolveMultisig`, `proxy.multisig` will remain undefined
  return proxy;
  }

  public approve = {
    async sendTransactionAsync(
      spender: string,
      value: BigNumber,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CVLTokenMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).approve.sendTransactionAsync(
              spender,
              value,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).approve.getRaw(
        spender,
        value,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public increaseAllowance = {
    async sendTransactionAsync(
      spender: string,
      addedValue: BigNumber,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CVLTokenMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).increaseAllowance.sendTransactionAsync(
              spender,
              addedValue,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).increaseAllowance.getRaw(
        spender,
        addedValue,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public renounceOwnership = {
    async sendTransactionAsync(
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CVLTokenMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).renounceOwnership.sendTransactionAsync(
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).renounceOwnership.getRaw(
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public decreaseAllowance = {
    async sendTransactionAsync(
      spender: string,
      subtractedValue: BigNumber,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CVLTokenMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).decreaseAllowance.sendTransactionAsync(
              spender,
              subtractedValue,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).decreaseAllowance.getRaw(
        spender,
        subtractedValue,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public transferOwnership = {
    async sendTransactionAsync(
      _newOwner: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CVLTokenMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).transferOwnership.sendTransactionAsync(
              _newOwner,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).transferOwnership.getRaw(
        _newOwner,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public changeController = {
    async sendTransactionAsync(
      _controller: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CVLTokenMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).changeController.sendTransactionAsync(
              _controller,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).changeController.getRaw(
        _controller,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public transfer = {
    async sendTransactionAsync(
      to: string,
      value: BigNumber,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CVLTokenMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).transfer.sendTransactionAsync(
              to,
              value,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).transfer.getRaw(
        to,
        value,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public transferFrom = {
    async sendTransactionAsync(
      from: string,
      to: string,
      value: BigNumber,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as CVLTokenMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).transferFrom.sendTransactionAsync(
              from,
              to,
              value,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).transferFrom.getRaw(
        from,
        to,
        value,
        {...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"]);
  }
  }