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

// Needed for the promisifed events, some contracts don't have events
// tslint:disable:no-unused-variable
import { DecodedLogEntryEvent, DecodedLogEntry, DecodedTransactionReceipt } from "@joincivil/typescript-types";
// tslint:enable:no-unused-variable
import "rxjs/add/operator/distinctUntilChanged";

import {Contract} from "web3-eth-contract";
import {TransactionConfig, TransactionConfig as SendOptions} from "web3-core";

import { bindNestedAll, isDefined, CivilErrors } from "@joincivil/utils";
import * as Debug from "debug";

import { EthAddress, TxHash } from "@joincivil/typescript-types";
import { streamifyEvent } from "../../../contracts/utils/contracts";
import { EthApi, currentNetwork } from "@joincivil/ethapi";
import { BaseContract } from "../../basecontract";
import { artifacts } from "../artifacts";


// 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;

const debug = Debug("civil:contracts:GovernmentContract");
export class GovernmentContract extends BaseContract {
// tslint:disable:member-ordering
public static async singletonTrusted(ethApi: EthApi): Promise<GovernmentContract|undefined> {
  if (!artifacts.Government.networks) {
  debug("Trying to get singleton from contract without any singleton data");
  return undefined;
  }
  const networkId = (await currentNetwork(ethApi)).toString();
  const networkData = artifacts.Government.networks[networkId];
  if (!networkData) {
  debug("Failed to find network data for network ID " + networkId + ". Supported networks: " +
  Object.keys(artifacts.Government.networks));
  return undefined;
  }
  return GovernmentContract.atUntrusted(ethApi, networkData.address);
  }
  public static atUntrusted(ethApi: EthApi, address: EthAddress): GovernmentContract {
    const contract = ethApi.getContractClass(artifacts.Government.abi, address);
    return new GovernmentContract(contract, ethApi);
  }
  // TODO(ritave): This code won't work with smart-contracts with library links
  // see [ch429] in Clubhouse
  public static deployTrusted = {
  async sendTransactionAsync(
  ethApi: EthApi,
  appellateAddr: string,
  governmentControllerAddr: string,
  plcrAddr: string,
  appealFeeAmount: BigNumber,
  requestAppealLength: BigNumber,
  judgeAppealLength: BigNumber,
  appealSupermajorityPercentage: BigNumber,
  appealChallengeVoteDispensationPct: BigNumber,
  pDeposit: BigNumber,
  pCommitStageLength: BigNumber,
  pRevealStageLength: BigNumber,
  constHash: string,
  constURI: string,
  options: SendOptions): Promise<string> {
    if (!options.gas) {
    options.gas = await GovernmentContract.deployTrusted
    .estimateGasAsync(
    ethApi,
    appellateAddr,
    governmentControllerAddr,
    plcrAddr,
    appealFeeAmount,
    requestAppealLength,
    judgeAppealLength,
    appealSupermajorityPercentage,
    appealChallengeVoteDispensationPct,
    pDeposit,
    pCommitStageLength,
    pRevealStageLength,
    constHash,
    constURI,
    );
    }
    if (!options.gasPrice) {
      options.gasPrice = (await ethApi.getGasPrice()).toString();
    }
    const clazz = ethApi.getContractClass(artifacts.Government.abi);


    return new Promise( (resolve, reject) => {
      /* There's a bug in Metamask, this callback should be called twice, first when the transaction
      * gets into mempool, and second when it's mined. But it's called only once, so we have to resolve
      * the contract on our own
      */
      const tx = clazz.deploy({data: artifacts.Government.bytecode, arguments: [appellateAddr,
governmentControllerAddr,
plcrAddr,
appealFeeAmount,
requestAppealLength,
judgeAppealLength,
appealSupermajorityPercentage,
appealChallengeVoteDispensationPct,
pDeposit,
pCommitStageLength,
pRevealStageLength,
constHash,
constURI,
]}).send(options);

      return tx.once("transactionHash", resolve)
    })


        },
        async estimateGasAsync(
        ethApi: EthApi,
        appellateAddr: string,
        governmentControllerAddr: string,
        plcrAddr: string,
        appealFeeAmount: BigNumber,
        requestAppealLength: BigNumber,
        judgeAppealLength: BigNumber,
        appealSupermajorityPercentage: BigNumber,
        appealChallengeVoteDispensationPct: BigNumber,
        pDeposit: BigNumber,
        pCommitStageLength: BigNumber,
        pRevealStageLength: BigNumber,
        constHash: string,
        constURI: string,
        ): Promise<number> {
          const clazz = ethApi.getContractClass(artifacts.Government.abi);
          const contractData = clazz.deploy({
            data: artifacts.Government.bytecode, 
            arguments: [appellateAddr,
governmentControllerAddr,
plcrAddr,
appealFeeAmount,
requestAppealLength,
judgeAppealLength,
appealSupermajorityPercentage,
appealChallengeVoteDispensationPct,
pDeposit,
pCommitStageLength,
pRevealStageLength,
constHash,
constURI,
]
          }).encodeABI();

          return ethApi.estimateGas({data: contractData});
          },
          };
// tslint:disable:variable-name
public PROCESSBY = {
  async callAsync(   ): Promise<BigNumber> {
    const self = this as GovernmentContract;
    return self.instance.methods.PROCESSBY().call();
  }
}
public proposals = {
  async callAsync(  index_0: string,
 ): Promise<
[BigNumber, string, BigNumber, BigNumber]> {
    const self = this as GovernmentContract;
    return self.instance.methods.proposals(index_0,
).call();
  }
}
public constitutionURI = {
  async callAsync(   ): Promise<string> {
    const self = this as GovernmentContract;
    return self.instance.methods.constitutionURI().call();
  }
}
public constitutionHash = {
  async callAsync(   ): Promise<string> {
    const self = this as GovernmentContract;
    return self.instance.methods.constitutionHash().call();
  }
}
public appellate = {
  async callAsync(   ): Promise<string> {
    const self = this as GovernmentContract;
    return self.instance.methods.appellate().call();
  }
}
public params = {
  async callAsync(  index_0: string,
 ): Promise<BigNumber> {
    const self = this as GovernmentContract;
    return self.instance.methods.params(index_0,
).call();
  }
}
public governmentController = {
  async callAsync(   ): Promise<string> {
    const self = this as GovernmentContract;
    return self.instance.methods.governmentController().call();
  }
}
public voting = {
  async callAsync(   ): Promise<string> {
    const self = this as GovernmentContract;
    return self.instance.methods.voting().call();
  }
}
public getAppellate = {
  async callAsync(   ): Promise<string> {
    const self = this as GovernmentContract;
    return self.instance.methods.getAppellate().call();
  }
}
public getGovernmentController = {
  async callAsync(   ): Promise<string> {
    const self = this as GovernmentContract;
    return self.instance.methods.getGovernmentController().call();
  }
}
public get = {
  async callAsync(  name: string,
 ): Promise<BigNumber> {
    const self = this as GovernmentContract;
    return self.instance.methods.get(name,
).call();
  }
}
public proposeReparameterization = {
  async sendTransactionAsync(
    _name: string,
    _value: BigNumber,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as GovernmentContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`proposeReparameterization(_name: string,
_value: BigNumber,
)`);
    debug("proposeReparameterization: txOptions:", txOptions);
    debug("proposeReparameterization: Sending with:",  _name,
_value,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.proposeReparameterization(_name,
_value,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("proposeReparameterization: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    _name: string,
    _value: BigNumber,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as GovernmentContract;
    const estimateGas = self.instance.methods.proposeReparameterization(_name,
_value,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("proposeReparameterization: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("proposeReparameterization: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    _name: string,
    _value: BigNumber,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as GovernmentContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.proposeReparameterization.estimateGasAsync(
      _name,
      _value,
      options,
      );
      }
      options.data = self.instance.methods.proposeReparameterization(_name,
_value,
).encodeABI();
      return options;
  },
};
public setNewConstitution = {
  async sendTransactionAsync(
    _newConstHash: string,
    _newConstURI: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as GovernmentContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`setNewConstitution(_newConstHash: string,
_newConstURI: string,
)`);
    debug("setNewConstitution: txOptions:", txOptions);
    debug("setNewConstitution: Sending with:",  _newConstHash,
_newConstURI,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.setNewConstitution(_newConstHash,
_newConstURI,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("setNewConstitution: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    _newConstHash: string,
    _newConstURI: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as GovernmentContract;
    const estimateGas = self.instance.methods.setNewConstitution(_newConstHash,
_newConstURI,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("setNewConstitution: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("setNewConstitution: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    _newConstHash: string,
    _newConstURI: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as GovernmentContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.setNewConstitution.estimateGasAsync(
      _newConstHash,
      _newConstURI,
      options,
      );
      }
      options.data = self.instance.methods.setNewConstitution(_newConstHash,
_newConstURI,
).encodeABI();
      return options;
  },
};
public processProposal = {
  async sendTransactionAsync(
    _propID: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as GovernmentContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`processProposal(_propID: string,
)`);
    debug("processProposal: txOptions:", txOptions);
    debug("processProposal: Sending with:",  _propID,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.processProposal(_propID,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("processProposal: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    _propID: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as GovernmentContract;
    const estimateGas = self.instance.methods.processProposal(_propID,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("processProposal: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("processProposal: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    _propID: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as GovernmentContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.processProposal.estimateGasAsync(
      _propID,
      options,
      );
      }
      options.data = self.instance.methods.processProposal(_propID,
).encodeABI();
      return options;
  },
};
public propExists = {
  async callAsync(  _propID: string,
 ): Promise<boolean> {
    const self = this as GovernmentContract;
    return self.instance.methods.propExists(_propID,
).call();
  }
}
public propCanBeResolved = {
  async callAsync(  _propID: string,
 ): Promise<boolean> {
    const self = this as GovernmentContract;
    return self.instance.methods.propCanBeResolved(_propID,
).call();
  }
}
public setAppellate = {
  async sendTransactionAsync(
    newAppellate: string,
    txData?: TransactionConfig,
  ): Promise<TxHash> {
    const self = this as GovernmentContract;
    const txOptions: TransactionConfig = { ...self.configuration.txDefaults, ...txData };
    debug(`setAppellate(newAppellate: string,
)`);
    debug("setAppellate: txOptions:", txOptions);
    debug("setAppellate: Sending with:",  newAppellate,
  );
    txOptions.to = self.instance.options.address;
    txOptions.data = self.instance.methods.setAppellate(newAppellate,
).encodeABI();

    if (!isDefined(txOptions.gas)) {
      txOptions.gas = await self.ethApi.estimateGas(txOptions);
    }
    if (!isDefined(txOptions.gasPrice)) {
      const gasPricePromise = self.ethApi.getGasPriceString()
      txOptions.gasPrice = (await gasPricePromise).toString(); 
      debug("setAppellate: new gas price: ", txOptions.gasPrice);
    }

    return self.ethApi.sendTransaction(txOptions)
  },
  async estimateGasAsync(
    newAppellate: string,
    txData?: TransactionConfig,
  ): Promise<number> {
    const self = this as GovernmentContract;
    const estimateGas = self.instance.methods.setAppellate(newAppellate,
).estimateGas

    try {
      const estimate = Math.floor(await estimateGas(txData) * self.configuration.estimationMultiplier);
      debug("setAppellate: Gas estimation:", estimate);
      return estimate;
    } catch (e) {
      debug("setAppellate: Gas estimation failed, only sensible error is EVM error", e);
      throw new Error(CivilErrors.EvmException);
    }
  },
  async getRaw(
    newAppellate: string,
    txData?: TransactionConfig,
  ): Promise<TransactionConfig> {
      const self = this as GovernmentContract;
      const options: TransactionConfig = {... txData};
      if (!isDefined(options.gas)) {
        options.gas = await self.setAppellate.estimateGasAsync(
      newAppellate,
      options,
      );
      }
      options.data = self.instance.methods.setAppellate(newAppellate,
).encodeABI();
      return options;
  },
};
public _AppellateSetStream = streamifyEvent<Government.Args._AppellateSet, Government.LogEvents._AppellateSet>
    (this.instance, "_AppellateSet");
public _ParameterSetStream = streamifyEvent<Government.Args._ParameterSet, Government.LogEvents._ParameterSet>
    (this.instance, "_ParameterSet");
public _GovtReparameterizationProposalStream = streamifyEvent<Government.Args._GovtReparameterizationProposal, Government.LogEvents._GovtReparameterizationProposal>
    (this.instance, "_GovtReparameterizationProposal");
public _ProposalPassedStream = streamifyEvent<Government.Args._ProposalPassed, Government.LogEvents._ProposalPassed>
    (this.instance, "_ProposalPassed");
public _ProposalExpiredStream = streamifyEvent<Government.Args._ProposalExpired, Government.LogEvents._ProposalExpired>
    (this.instance, "_ProposalExpired");
public _ProposalFailedStream = streamifyEvent<Government.Args._ProposalFailed, Government.LogEvents._ProposalFailed>
    (this.instance, "_ProposalFailed");
public _NewConstSetStream = streamifyEvent<Government.Args._NewConstSet, Government.LogEvents._NewConstSet>
    (this.instance, "_NewConstSet");
// tslint:enable:variable-name

private constructor(instance: Contract, ethApi: EthApi) {
super(instance, ethApi);
// Call methods access this instance while being in a sub-object, we're rebinding what
// "this" means for everything in this class, this also requires "noImplicitThis" to be false
bindNestedAll(this, ["constructor", "instance", "defaults", "ethApi"]);
}
// tslint:enable:member-ordering
}

// tslint:disable:no-namespace
export namespace Government {
  export enum Events {
    _AppellateSet = "_AppellateSet",
    _ParameterSet = "_ParameterSet",
    _GovtReparameterizationProposal = "_GovtReparameterizationProposal",
    _ProposalPassed = "_ProposalPassed",
    _ProposalExpired = "_ProposalExpired",
    _ProposalFailed = "_ProposalFailed",
    _NewConstSet = "_NewConstSet",
  }

  // tslint:disable:class-name
  export namespace Args {
    export interface _AppellateSet {
      newAppellate: string;
    }
    export interface _ParameterSet {
      name: string;
      value: BigNumber;
    }
    export interface _GovtReparameterizationProposal {
      name: string;
      value: BigNumber;
      propID: string;
      pollID: BigNumber;
    }
    export interface _ProposalPassed {
      propId: string;
      pollID: BigNumber;
    }
    export interface _ProposalExpired {
      propId: string;
      pollID: BigNumber;
    }
    export interface _ProposalFailed {
      propId: string;
      pollID: BigNumber;
    }
    export interface _NewConstSet {
      proposedHash: string;
      proposedURI: string;
    }
  }
  // tslint:enable:class-name

  export namespace Logs {
    export type _AppellateSet = DecodedLogEntry<Args._AppellateSet, Events._AppellateSet>;
    export type _ParameterSet = DecodedLogEntry<Args._ParameterSet, Events._ParameterSet>;
    export type _GovtReparameterizationProposal = DecodedLogEntry<Args._GovtReparameterizationProposal, Events._GovtReparameterizationProposal>;
    export type _ProposalPassed = DecodedLogEntry<Args._ProposalPassed, Events._ProposalPassed>;
    export type _ProposalExpired = DecodedLogEntry<Args._ProposalExpired, Events._ProposalExpired>;
    export type _ProposalFailed = DecodedLogEntry<Args._ProposalFailed, Events._ProposalFailed>;
    export type _NewConstSet = DecodedLogEntry<Args._NewConstSet, Events._NewConstSet>;

    export type All =
      Logs._AppellateSet |
      Logs._ParameterSet |
      Logs._GovtReparameterizationProposal |
      Logs._ProposalPassed |
      Logs._ProposalExpired |
      Logs._ProposalFailed |
      Logs._NewConstSet;
  }

  export namespace LogEvents {
    export type _AppellateSet = DecodedLogEntryEvent<Args._AppellateSet, Events._AppellateSet>;
    export type _ParameterSet = DecodedLogEntryEvent<Args._ParameterSet, Events._ParameterSet>;
    export type _GovtReparameterizationProposal = DecodedLogEntryEvent<Args._GovtReparameterizationProposal, Events._GovtReparameterizationProposal>;
    export type _ProposalPassed = DecodedLogEntryEvent<Args._ProposalPassed, Events._ProposalPassed>;
    export type _ProposalExpired = DecodedLogEntryEvent<Args._ProposalExpired, Events._ProposalExpired>;
    export type _ProposalFailed = DecodedLogEntryEvent<Args._ProposalFailed, Events._ProposalFailed>;
    export type _NewConstSet = DecodedLogEntryEvent<Args._NewConstSet, Events._NewConstSet>;

    export type All =
      LogEvents._AppellateSet |
      LogEvents._ParameterSet |
      LogEvents._GovtReparameterizationProposal |
      LogEvents._ProposalPassed |
      LogEvents._ProposalExpired |
      LogEvents._ProposalFailed |
      LogEvents._NewConstSet;
  }

  export type Receipt = DecodedTransactionReceipt<Logs.All>;
  export type EventReceipt = DecodedTransactionReceipt<LogEvents.All>;
}
// tslint:enable:no-namespace