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

  public renounceOwnership = {
    async sendTransactionAsync(
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as NewsroomMultisigProxy;
      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 transferOwnership = {
    async sendTransactionAsync(
      _newOwner: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as NewsroomMultisigProxy;
      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 setName = {
    async sendTransactionAsync(
      newName: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as NewsroomMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).setName.sendTransactionAsync(
              newName,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).setName.getRaw(
        newName,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public addRole = {
    async sendTransactionAsync(
      who: string,
      role: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as NewsroomMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).addRole.sendTransactionAsync(
              who,
              role,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).addRole.getRaw(
        who,
        role,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public addEditor = {
    async sendTransactionAsync(
      who: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as NewsroomMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).addEditor.sendTransactionAsync(
              who,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).addEditor.getRaw(
        who,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public removeRole = {
    async sendTransactionAsync(
      who: string,
      role: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as NewsroomMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).removeRole.sendTransactionAsync(
              who,
              role,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).removeRole.getRaw(
        who,
        role,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public publishContent = {
    async sendTransactionAsync(
      contentUri: string,
      contentHash: string,
      author: string,
      signature: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as NewsroomMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).publishContent.sendTransactionAsync(
              contentUri,
              contentHash,
              author,
              signature,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).publishContent.getRaw(
        contentUri,
        contentHash,
        author,
        signature,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public updateRevision = {
    async sendTransactionAsync(
      contentId: BigNumber,
      contentUri: string,
      contentHash: string,
      signature: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as NewsroomMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).updateRevision.sendTransactionAsync(
              contentId,
              contentUri,
              contentHash,
              signature,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).updateRevision.getRaw(
        contentId,
        contentUri,
        contentHash,
        signature,
        {...txData, gas: 0},
      );
      return self.createProxyTransaction(
        (await self.multisig.submitTransaction(
          self.instance.address,
          self.ethApi.toBigNumber(0),
          raw.data!,
        )).txHash,
      );
    },
  };
  public signRevision = {
    async sendTransactionAsync(
      contentId: BigNumber,
      revisionId: BigNumber,
      author: string,
      signature: string,
      txData: TransactionConfig = {},
    ): Promise<MultisigProxyTransaction> {
      const self = this as NewsroomMultisigProxy;
      if (!isDefined(self.multisig)) {
        try {
          const tx = await (self.instance as any).signRevision.sendTransactionAsync(
              contentId,
              revisionId,
              author,
              signature,
              txData,
          )
          return createTwoStepSimple(
            self.ethApi,
            tx,
          );
        } catch (err) {
          return Promise.reject(err)
        }
      }
      const raw = await (self.instance as any).signRevision.getRaw(
        contentId,
        revisionId,
        author,
        signature,
        {...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"]);
  }
  }