import * as $ from "@manahippo/move-to-ts";
import {AptosDataCache, AptosParserRepo, DummyCache, AptosLocalCache} from "@manahippo/move-to-ts";
import {U8, U64, U128} from "@manahippo/move-to-ts";
import {u8, u64, u128} from "@manahippo/move-to-ts";
import {TypeParamDeclType, FieldDeclType} from "@manahippo/move-to-ts";
import {AtomicTypeTag, StructTag, TypeTag, VectorTag, SimpleStructTag} from "@manahippo/move-to-ts";
import {OptionTransaction} from "@manahippo/move-to-ts";
import {HexString, AptosClient, AptosAccount, TxnBuilderTypes, Types} from "aptos";
import * as Account from "./account";
import * as Bcs from "./bcs";
import * as Error from "./error";
import * as Event from "./event";
import * as From_bcs from "./from_bcs";
import * as Option from "./option";
import * as Signer from "./signer";
import * as Simple_map from "./simple_map";
import * as String from "./string";
import * as Table from "./table";
import * as Timestamp from "./timestamp";
import * as Transaction_context from "./transaction_context";
import * as Type_info from "./type_info";
import * as Vector from "./vector";
export const packageName = "AptosFramework";
export const moduleAddress = new HexString("0x1");
export const moduleName = "voting";

export const EINVALID_MIN_VOTE_THRESHOLD : U64 = u64("7");
export const EPROPOSAL_ALREADY_RESOLVED : U64 = u64("3");
export const EPROPOSAL_CANNOT_BE_RESOLVED : U64 = u64("2");
export const EPROPOSAL_EMPTY_EXECUTION_HASH : U64 = u64("4");
export const EPROPOSAL_EXECUTION_HASH_NOT_MATCHING : U64 = u64("1");
export const EPROPOSAL_VOTING_ALREADY_ENDED : U64 = u64("5");
export const ERESOLUTION_CANNOT_BE_ATOMIC : U64 = u64("8");
export const EVOTING_FORUM_ALREADY_REGISTERED : U64 = u64("6");
export const PROPOSAL_STATE_FAILED : U64 = u64("3");
export const PROPOSAL_STATE_PENDING : U64 = u64("0");
export const PROPOSAL_STATE_SUCCEEDED : U64 = u64("1");
export const RESOLVABLE_TIME_METADATA_KEY : U8[] = [u8("82"), u8("69"), u8("83"), u8("79"), u8("76"), u8("86"), u8("65"), u8("66"), u8("76"), u8("69"), u8("95"), u8("84"), u8("73"), u8("77"), u8("69"), u8("95"), u8("77"), u8("69"), u8("84"), u8("65"), u8("68"), u8("65"), u8("84"), u8("65"), u8("95"), u8("75"), u8("69"), u8("89")];


export class CreateProposalEvent 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "CreateProposalEvent";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "proposal_id", typeTag: AtomicTypeTag.U64 },
  { name: "early_resolution_vote_threshold", typeTag: new StructTag(new HexString("0x1"), "option", "Option", [AtomicTypeTag.U128]) },
  { name: "execution_hash", typeTag: new VectorTag(AtomicTypeTag.U8) },
  { name: "expiration_secs", typeTag: AtomicTypeTag.U64 },
  { name: "metadata", typeTag: new StructTag(new HexString("0x1"), "simple_map", "SimpleMap", [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)]) },
  { name: "min_vote_threshold", typeTag: AtomicTypeTag.U128 }];

  proposal_id: U64;
  early_resolution_vote_threshold: Option.Option;
  execution_hash: U8[];
  expiration_secs: U64;
  metadata: Simple_map.SimpleMap;
  min_vote_threshold: U128;

  constructor(proto: any, public typeTag: TypeTag) {
    this.proposal_id = proto['proposal_id'] as U64;
    this.early_resolution_vote_threshold = proto['early_resolution_vote_threshold'] as Option.Option;
    this.execution_hash = proto['execution_hash'] as U8[];
    this.expiration_secs = proto['expiration_secs'] as U64;
    this.metadata = proto['metadata'] as Simple_map.SimpleMap;
    this.min_vote_threshold = proto['min_vote_threshold'] as U128;
  }

  static CreateProposalEventParser(data:any, typeTag: TypeTag, repo: AptosParserRepo) : CreateProposalEvent {
    const proto = $.parseStructProto(data, typeTag, repo, CreateProposalEvent);
    return new CreateProposalEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "CreateProposalEvent", []);
  }
  async loadFullState(app: $.AppType) {
    await this.early_resolution_vote_threshold.loadFullState(app);
    await this.metadata.loadFullState(app);
    this.__app = app;
  }

}

export class Proposal 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "Proposal";
  static typeParameters: TypeParamDeclType[] = [
    { name: "ProposalType", isPhantom: false }
  ];
  static fields: FieldDeclType[] = [
  { name: "proposer", typeTag: AtomicTypeTag.Address },
  { name: "execution_content", typeTag: new StructTag(new HexString("0x1"), "option", "Option", [new $.TypeParamIdx(0)]) },
  { name: "metadata", typeTag: new StructTag(new HexString("0x1"), "simple_map", "SimpleMap", [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)]) },
  { name: "creation_time_secs", typeTag: AtomicTypeTag.U64 },
  { name: "execution_hash", typeTag: new VectorTag(AtomicTypeTag.U8) },
  { name: "min_vote_threshold", typeTag: AtomicTypeTag.U128 },
  { name: "expiration_secs", typeTag: AtomicTypeTag.U64 },
  { name: "early_resolution_vote_threshold", typeTag: new StructTag(new HexString("0x1"), "option", "Option", [AtomicTypeTag.U128]) },
  { name: "yes_votes", typeTag: AtomicTypeTag.U128 },
  { name: "no_votes", typeTag: AtomicTypeTag.U128 },
  { name: "is_resolved", typeTag: AtomicTypeTag.Bool },
  { name: "resolution_time_secs", typeTag: AtomicTypeTag.U64 }];

  proposer: HexString;
  execution_content: Option.Option;
  metadata: Simple_map.SimpleMap;
  creation_time_secs: U64;
  execution_hash: U8[];
  min_vote_threshold: U128;
  expiration_secs: U64;
  early_resolution_vote_threshold: Option.Option;
  yes_votes: U128;
  no_votes: U128;
  is_resolved: boolean;
  resolution_time_secs: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.proposer = proto['proposer'] as HexString;
    this.execution_content = proto['execution_content'] as Option.Option;
    this.metadata = proto['metadata'] as Simple_map.SimpleMap;
    this.creation_time_secs = proto['creation_time_secs'] as U64;
    this.execution_hash = proto['execution_hash'] as U8[];
    this.min_vote_threshold = proto['min_vote_threshold'] as U128;
    this.expiration_secs = proto['expiration_secs'] as U64;
    this.early_resolution_vote_threshold = proto['early_resolution_vote_threshold'] as Option.Option;
    this.yes_votes = proto['yes_votes'] as U128;
    this.no_votes = proto['no_votes'] as U128;
    this.is_resolved = proto['is_resolved'] as boolean;
    this.resolution_time_secs = proto['resolution_time_secs'] as U64;
  }

  static ProposalParser(data:any, typeTag: TypeTag, repo: AptosParserRepo) : Proposal {
    const proto = $.parseStructProto(data, typeTag, repo, Proposal);
    return new Proposal(proto, typeTag);
  }

  static makeTag($p: TypeTag[]): StructTag {
    return new StructTag(moduleAddress, moduleName, "Proposal", $p);
  }
  async loadFullState(app: $.AppType) {
    await this.execution_content.loadFullState(app);
    await this.metadata.loadFullState(app);
    await this.early_resolution_vote_threshold.loadFullState(app);
    this.__app = app;
  }

}

export class RegisterForumEvent 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "RegisterForumEvent";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "hosting_account", typeTag: AtomicTypeTag.Address },
  { name: "proposal_type_info", typeTag: new StructTag(new HexString("0x1"), "type_info", "TypeInfo", []) }];

  hosting_account: HexString;
  proposal_type_info: Type_info.TypeInfo;

  constructor(proto: any, public typeTag: TypeTag) {
    this.hosting_account = proto['hosting_account'] as HexString;
    this.proposal_type_info = proto['proposal_type_info'] as Type_info.TypeInfo;
  }

  static RegisterForumEventParser(data:any, typeTag: TypeTag, repo: AptosParserRepo) : RegisterForumEvent {
    const proto = $.parseStructProto(data, typeTag, repo, RegisterForumEvent);
    return new RegisterForumEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "RegisterForumEvent", []);
  }
  async loadFullState(app: $.AppType) {
    await this.proposal_type_info.loadFullState(app);
    this.__app = app;
  }

}

export class ResolveProposal 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "ResolveProposal";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "proposal_id", typeTag: AtomicTypeTag.U64 },
  { name: "yes_votes", typeTag: AtomicTypeTag.U128 },
  { name: "no_votes", typeTag: AtomicTypeTag.U128 },
  { name: "resolved_early", typeTag: AtomicTypeTag.Bool }];

  proposal_id: U64;
  yes_votes: U128;
  no_votes: U128;
  resolved_early: boolean;

  constructor(proto: any, public typeTag: TypeTag) {
    this.proposal_id = proto['proposal_id'] as U64;
    this.yes_votes = proto['yes_votes'] as U128;
    this.no_votes = proto['no_votes'] as U128;
    this.resolved_early = proto['resolved_early'] as boolean;
  }

  static ResolveProposalParser(data:any, typeTag: TypeTag, repo: AptosParserRepo) : ResolveProposal {
    const proto = $.parseStructProto(data, typeTag, repo, ResolveProposal);
    return new ResolveProposal(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "ResolveProposal", []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }

}

export class VoteEvent 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "VoteEvent";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "proposal_id", typeTag: AtomicTypeTag.U64 },
  { name: "num_votes", typeTag: AtomicTypeTag.U64 }];

  proposal_id: U64;
  num_votes: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.proposal_id = proto['proposal_id'] as U64;
    this.num_votes = proto['num_votes'] as U64;
  }

  static VoteEventParser(data:any, typeTag: TypeTag, repo: AptosParserRepo) : VoteEvent {
    const proto = $.parseStructProto(data, typeTag, repo, VoteEvent);
    return new VoteEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "VoteEvent", []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }

}

export class VotingEvents 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "VotingEvents";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "create_proposal_events", typeTag: new StructTag(new HexString("0x1"), "event", "EventHandle", [new StructTag(new HexString("0x1"), "voting", "CreateProposalEvent", [])]) },
  { name: "register_forum_events", typeTag: new StructTag(new HexString("0x1"), "event", "EventHandle", [new StructTag(new HexString("0x1"), "voting", "RegisterForumEvent", [])]) },
  { name: "resolve_proposal_events", typeTag: new StructTag(new HexString("0x1"), "event", "EventHandle", [new StructTag(new HexString("0x1"), "voting", "ResolveProposal", [])]) },
  { name: "vote_events", typeTag: new StructTag(new HexString("0x1"), "event", "EventHandle", [new StructTag(new HexString("0x1"), "voting", "VoteEvent", [])]) }];

  create_proposal_events: Event.EventHandle;
  register_forum_events: Event.EventHandle;
  resolve_proposal_events: Event.EventHandle;
  vote_events: Event.EventHandle;

  constructor(proto: any, public typeTag: TypeTag) {
    this.create_proposal_events = proto['create_proposal_events'] as Event.EventHandle;
    this.register_forum_events = proto['register_forum_events'] as Event.EventHandle;
    this.resolve_proposal_events = proto['resolve_proposal_events'] as Event.EventHandle;
    this.vote_events = proto['vote_events'] as Event.EventHandle;
  }

  static VotingEventsParser(data:any, typeTag: TypeTag, repo: AptosParserRepo) : VotingEvents {
    const proto = $.parseStructProto(data, typeTag, repo, VotingEvents);
    return new VotingEvents(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "VotingEvents", []);
  }
  async loadFullState(app: $.AppType) {
    await this.create_proposal_events.loadFullState(app);
    await this.register_forum_events.loadFullState(app);
    await this.resolve_proposal_events.loadFullState(app);
    await this.vote_events.loadFullState(app);
    this.__app = app;
  }

}

export class VotingForum 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "VotingForum";
  static typeParameters: TypeParamDeclType[] = [
    { name: "ProposalType", isPhantom: false }
  ];
  static fields: FieldDeclType[] = [
  { name: "proposals", typeTag: new StructTag(new HexString("0x1"), "table", "Table", [AtomicTypeTag.U64, new StructTag(new HexString("0x1"), "voting", "Proposal", [new $.TypeParamIdx(0)])]) },
  { name: "events", typeTag: new StructTag(new HexString("0x1"), "voting", "VotingEvents", []) },
  { name: "next_proposal_id", typeTag: AtomicTypeTag.U64 }];

  proposals: Table.Table;
  events: VotingEvents;
  next_proposal_id: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.proposals = proto['proposals'] as Table.Table;
    this.events = proto['events'] as VotingEvents;
    this.next_proposal_id = proto['next_proposal_id'] as U64;
  }

  static VotingForumParser(data:any, typeTag: TypeTag, repo: AptosParserRepo) : VotingForum {
    const proto = $.parseStructProto(data, typeTag, repo, VotingForum);
    return new VotingForum(proto, typeTag);
  }

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, VotingForum, typeParams);
    return result as unknown as VotingForum;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, VotingForum, typeParams);
    await result.loadFullState(app)
    return result as unknown as VotingForum;
  }
  static makeTag($p: TypeTag[]): StructTag {
    return new StructTag(moduleAddress, moduleName, "VotingForum", $p);
  }
  async loadFullState(app: $.AppType) {
    await this.proposals.loadFullState(app);
    await this.events.loadFullState(app);
    this.__app = app;
  }

}
export function can_be_resolved_early_ (
  proposal: Proposal,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): boolean {
  let temp$1, early_resolution_threshold;
  if (Option.is_some_(proposal.early_resolution_vote_threshold, $c, [AtomicTypeTag.U128])) {
    early_resolution_threshold = $.copy(Option.borrow_(proposal.early_resolution_vote_threshold, $c, [AtomicTypeTag.U128]));
    if (($.copy(proposal.yes_votes)).ge($.copy(early_resolution_threshold))) {
      temp$1 = true;
    }
    else{
      temp$1 = ($.copy(proposal.no_votes)).ge($.copy(early_resolution_threshold));
    }
    if (temp$1) {
      return true;
    }
    else{
    }
  }
  else{
  }
  return false;
}

export function create_proposal_ (
  proposer: HexString,
  voting_forum_address: HexString,
  execution_content: any,
  execution_hash: U8[],
  min_vote_threshold: U128,
  expiration_secs: U64,
  early_resolution_vote_threshold: Option.Option,
  metadata: Simple_map.SimpleMap,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): U64 {
  let temp$1, temp$10, temp$11, temp$12, temp$13, temp$14, temp$2, temp$3, temp$4, temp$5, temp$6, temp$7, temp$8, temp$9, proposal_id, voting_forum;
  if (Option.is_some_(early_resolution_vote_threshold, $c, [AtomicTypeTag.U128])) {
    if (!($.copy(min_vote_threshold)).le($.copy(Option.borrow_(early_resolution_vote_threshold, $c, [AtomicTypeTag.U128])))) {
      throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_MIN_VOTE_THRESHOLD), $c));
    }
  }
  else{
  }
  if (!(Vector.length_(execution_hash, $c, [AtomicTypeTag.U8])).gt(u64("0"))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EPROPOSAL_EMPTY_EXECUTION_HASH), $c));
  }
  voting_forum = $c.borrow_global_mut<VotingForum>(new SimpleStructTag(VotingForum, [$p[0]]), $.copy(voting_forum_address));
  proposal_id = $.copy(voting_forum.next_proposal_id);
  voting_forum.next_proposal_id = ($.copy(voting_forum.next_proposal_id)).add(u64("1"));
  temp$14 = voting_forum.proposals;
  temp$13 = $.copy(proposal_id);
  temp$1 = $.copy(proposer);
  temp$2 = Timestamp.now_seconds_($c);
  temp$3 = Option.some_(execution_content, $c, [$p[0]]);
  temp$4 = $.copy(execution_hash);
  temp$5 = $.copy(metadata);
  temp$6 = $.copy(min_vote_threshold);
  temp$7 = $.copy(expiration_secs);
  temp$8 = $.copy(early_resolution_vote_threshold);
  temp$9 = u128("0");
  temp$10 = u128("0");
  temp$11 = false;
  temp$12 = u64("0");
  Table.add_(temp$14, temp$13, new Proposal({ proposer: temp$1, execution_content: temp$3, metadata: temp$5, creation_time_secs: temp$2, execution_hash: temp$4, min_vote_threshold: temp$6, expiration_secs: temp$7, early_resolution_vote_threshold: temp$8, yes_votes: temp$9, no_votes: temp$10, is_resolved: temp$11, resolution_time_secs: temp$12 }, new SimpleStructTag(Proposal, [$p[0]])), $c, [AtomicTypeTag.U64, new SimpleStructTag(Proposal, [$p[0]])]);
  Event.emit_event_(voting_forum.events.create_proposal_events, new CreateProposalEvent({ proposal_id: $.copy(proposal_id), early_resolution_vote_threshold: $.copy(early_resolution_vote_threshold), execution_hash: $.copy(execution_hash), expiration_secs: $.copy(expiration_secs), metadata: $.copy(metadata), min_vote_threshold: $.copy(min_vote_threshold) }, new SimpleStructTag(CreateProposalEvent)), $c, [new SimpleStructTag(CreateProposalEvent)]);
  return $.copy(proposal_id);
}

export function get_execution_hash_ (
  voting_forum_address: HexString,
  proposal_id: U64,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): U8[] {
  let proposal, voting_forum;
  voting_forum = $c.borrow_global_mut<VotingForum>(new SimpleStructTag(VotingForum, [$p[0]]), $.copy(voting_forum_address));
  proposal = Table.borrow_mut_(voting_forum.proposals, $.copy(proposal_id), $c, [AtomicTypeTag.U64, new SimpleStructTag(Proposal, [$p[0]])]);
  return $.copy(proposal.execution_hash);
}

export function get_proposal_expiration_secs_ (
  voting_forum_address: HexString,
  proposal_id: U64,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): U64 {
  let proposal, voting_forum;
  voting_forum = $c.borrow_global_mut<VotingForum>(new SimpleStructTag(VotingForum, [$p[0]]), $.copy(voting_forum_address));
  proposal = Table.borrow_mut_(voting_forum.proposals, $.copy(proposal_id), $c, [AtomicTypeTag.U64, new SimpleStructTag(Proposal, [$p[0]])]);
  return $.copy(proposal.expiration_secs);
}

export function get_proposal_state_ (
  voting_forum_address: HexString,
  proposal_id: U64,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): U64 {
  let temp$1, temp$2, temp$3, no_votes, proposal, voting_forum, yes_votes;
  if (is_voting_closed_($.copy(voting_forum_address), $.copy(proposal_id), $c, [$p[0]])) {
    voting_forum = $c.borrow_global<VotingForum>(new SimpleStructTag(VotingForum, [$p[0]]), $.copy(voting_forum_address));
    proposal = Table.borrow_(voting_forum.proposals, $.copy(proposal_id), $c, [AtomicTypeTag.U64, new SimpleStructTag(Proposal, [$p[0]])]);
    yes_votes = $.copy(proposal.yes_votes);
    no_votes = $.copy(proposal.no_votes);
    if (($.copy(yes_votes)).gt($.copy(no_votes))) {
      temp$1 = (($.copy(yes_votes)).add($.copy(no_votes))).ge($.copy(proposal.min_vote_threshold));
    }
    else{
      temp$1 = false;
    }
    if (temp$1) {
      temp$2 = $.copy(PROPOSAL_STATE_SUCCEEDED);
    }
    else{
      temp$2 = $.copy(PROPOSAL_STATE_FAILED);
    }
    temp$3 = temp$2;
  }
  else{
    temp$3 = $.copy(PROPOSAL_STATE_PENDING);
  }
  return temp$3;
}

export function is_resolved_ (
  voting_forum_address: HexString,
  proposal_id: U64,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): boolean {
  let proposal, voting_forum;
  voting_forum = $c.borrow_global_mut<VotingForum>(new SimpleStructTag(VotingForum, [$p[0]]), $.copy(voting_forum_address));
  proposal = Table.borrow_mut_(voting_forum.proposals, $.copy(proposal_id), $c, [AtomicTypeTag.U64, new SimpleStructTag(Proposal, [$p[0]])]);
  return $.copy(proposal.is_resolved);
}

export function is_voting_closed_ (
  voting_forum_address: HexString,
  proposal_id: U64,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): boolean {
  let temp$1, proposal, voting_forum;
  voting_forum = $c.borrow_global_mut<VotingForum>(new SimpleStructTag(VotingForum, [$p[0]]), $.copy(voting_forum_address));
  proposal = Table.borrow_mut_(voting_forum.proposals, $.copy(proposal_id), $c, [AtomicTypeTag.U64, new SimpleStructTag(Proposal, [$p[0]])]);
  if (can_be_resolved_early_(proposal, $c, [$p[0]])) {
    temp$1 = true;
  }
  else{
    temp$1 = is_voting_period_over_(proposal, $c, [$p[0]]);
  }
  return temp$1;
}

export function is_voting_period_over_ (
  proposal: Proposal,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): boolean {
  return (Timestamp.now_seconds_($c)).gt($.copy(proposal.expiration_secs));
}

export function register_ (
  account: HexString,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): void {
  let temp$1, temp$2, temp$3, addr, voting_forum;
  addr = Signer.address_of_(account, $c);
  if (!!$c.exists(new SimpleStructTag(VotingForum, [$p[0]]), $.copy(addr))) {
    throw $.abortCode(Error.already_exists_($.copy(EVOTING_FORUM_ALREADY_REGISTERED), $c));
  }
  temp$1 = u64("0");
  temp$2 = Table.new___($c, [AtomicTypeTag.U64, new SimpleStructTag(Proposal, [$p[0]])]);
  temp$3 = new VotingEvents({ create_proposal_events: Account.new_event_handle_(account, $c, [new SimpleStructTag(CreateProposalEvent)]), register_forum_events: Account.new_event_handle_(account, $c, [new SimpleStructTag(RegisterForumEvent)]), resolve_proposal_events: Account.new_event_handle_(account, $c, [new SimpleStructTag(ResolveProposal)]), vote_events: Account.new_event_handle_(account, $c, [new SimpleStructTag(VoteEvent)]) }, new SimpleStructTag(VotingEvents));
  voting_forum = new VotingForum({ proposals: temp$2, events: temp$3, next_proposal_id: temp$1 }, new SimpleStructTag(VotingForum, [$p[0]]));
  Event.emit_event_(voting_forum.events.register_forum_events, new RegisterForumEvent({ hosting_account: $.copy(addr), proposal_type_info: Type_info.type_of_($c, [$p[0]]) }, new SimpleStructTag(RegisterForumEvent)), $c, [new SimpleStructTag(RegisterForumEvent)]);
  $c.move_to(new SimpleStructTag(VotingForum, [$p[0]]), account, voting_forum);
  return;
}

export function resolve_ (
  voting_forum_address: HexString,
  proposal_id: U64,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): any {
  let temp$1, temp$2, proposal, proposal_state, resolvable_time, resolved_early, voting_forum;
  proposal_state = get_proposal_state_($.copy(voting_forum_address), $.copy(proposal_id), $c, [$p[0]]);
  if (!($.copy(proposal_state)).eq(($.copy(PROPOSAL_STATE_SUCCEEDED)))) {
    throw $.abortCode(Error.invalid_state_($.copy(EPROPOSAL_CANNOT_BE_RESOLVED), $c));
  }
  voting_forum = $c.borrow_global_mut<VotingForum>(new SimpleStructTag(VotingForum, [$p[0]]), $.copy(voting_forum_address));
  proposal = Table.borrow_mut_(voting_forum.proposals, $.copy(proposal_id), $c, [AtomicTypeTag.U64, new SimpleStructTag(Proposal, [$p[0]])]);
  if (!!$.copy(proposal.is_resolved)) {
    throw $.abortCode(Error.invalid_state_($.copy(EPROPOSAL_ALREADY_RESOLVED), $c));
  }
  temp$2 = proposal.metadata;
  temp$1 = String.utf8_($.copy(RESOLVABLE_TIME_METADATA_KEY), $c);
  resolvable_time = From_bcs.to_u64_($.copy(Simple_map.borrow_(temp$2, temp$1, $c, [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)])), $c);
  if (!(Timestamp.now_seconds_($c)).gt($.copy(resolvable_time))) {
    throw $.abortCode(Error.invalid_state_($.copy(ERESOLUTION_CANNOT_BE_ATOMIC), $c));
  }
  resolved_early = can_be_resolved_early_(proposal, $c, [$p[0]]);
  proposal.is_resolved = true;
  proposal.resolution_time_secs = Timestamp.now_seconds_($c);
  if (!$.veq(Transaction_context.get_script_hash_($c), $.copy(proposal.execution_hash))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EPROPOSAL_EXECUTION_HASH_NOT_MATCHING), $c));
  }
  Event.emit_event_(voting_forum.events.resolve_proposal_events, new ResolveProposal({ proposal_id: $.copy(proposal_id), yes_votes: $.copy(proposal.yes_votes), no_votes: $.copy(proposal.no_votes), resolved_early: resolved_early }, new SimpleStructTag(ResolveProposal)), $c, [new SimpleStructTag(ResolveProposal)]);
  return Option.extract_(proposal.execution_content, $c, [$p[0]]);
}

export function vote_ (
  _proof: any,
  voting_forum_address: HexString,
  proposal_id: U64,
  num_votes: U64,
  should_pass: boolean,
  $c: AptosDataCache,
  $p: TypeTag[], /* <ProposalType>*/
): void {
  let temp$1, key, proposal, timestamp_secs_bytes, voting_forum;
  voting_forum = $c.borrow_global_mut<VotingForum>(new SimpleStructTag(VotingForum, [$p[0]]), $.copy(voting_forum_address));
  proposal = Table.borrow_mut_(voting_forum.proposals, $.copy(proposal_id), $c, [AtomicTypeTag.U64, new SimpleStructTag(Proposal, [$p[0]])]);
  if (!!is_voting_period_over_(proposal, $c, [$p[0]])) {
    throw $.abortCode(Error.invalid_state_($.copy(EPROPOSAL_VOTING_ALREADY_ENDED), $c));
  }
  if (!!$.copy(proposal.is_resolved)) {
    throw $.abortCode(Error.invalid_state_($.copy(EPROPOSAL_ALREADY_RESOLVED), $c));
  }
  if (should_pass) {
    proposal.yes_votes = ($.copy(proposal.yes_votes)).add(u128($.copy(num_votes)));
  }
  else{
    proposal.no_votes = ($.copy(proposal.no_votes)).add(u128($.copy(num_votes)));
  }
  temp$1 = Timestamp.now_seconds_($c);
  timestamp_secs_bytes = Bcs.to_bytes_(temp$1, $c, [AtomicTypeTag.U64]);
  key = String.utf8_($.copy(RESOLVABLE_TIME_METADATA_KEY), $c);
  if (Simple_map.contains_key_(proposal.metadata, key, $c, [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)])) {
    $.set(Simple_map.borrow_mut_(proposal.metadata, key, $c, [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)]), $.copy(timestamp_secs_bytes));
  }
  else{
    Simple_map.add_(proposal.metadata, $.copy(key), $.copy(timestamp_secs_bytes), $c, [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)]);
  }
  Event.emit_event_(voting_forum.events.vote_events, new VoteEvent({ proposal_id: $.copy(proposal_id), num_votes: $.copy(num_votes) }, new SimpleStructTag(VoteEvent)), $c, [new SimpleStructTag(VoteEvent)]);
  return;
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser("0x1::voting::CreateProposalEvent", CreateProposalEvent.CreateProposalEventParser);
  repo.addParser("0x1::voting::Proposal", Proposal.ProposalParser);
  repo.addParser("0x1::voting::RegisterForumEvent", RegisterForumEvent.RegisterForumEventParser);
  repo.addParser("0x1::voting::ResolveProposal", ResolveProposal.ResolveProposalParser);
  repo.addParser("0x1::voting::VoteEvent", VoteEvent.VoteEventParser);
  repo.addParser("0x1::voting::VotingEvents", VotingEvents.VotingEventsParser);
  repo.addParser("0x1::voting::VotingForum", VotingForum.VotingForumParser);
}
export class App {
  constructor(
    public client: AptosClient,
    public repo: AptosParserRepo,
    public cache: AptosLocalCache,
  ) {
  }
  get moduleAddress() {{ return moduleAddress; }}
  get moduleName() {{ return moduleName; }}
  get CreateProposalEvent() { return CreateProposalEvent; }
  get Proposal() { return Proposal; }
  get RegisterForumEvent() { return RegisterForumEvent; }
  get ResolveProposal() { return ResolveProposal; }
  get VoteEvent() { return VoteEvent; }
  get VotingEvents() { return VotingEvents; }
  get VotingForum() { return VotingForum; }
  async loadVotingForum(
    owner: HexString,
    $p: TypeTag[], /* <ProposalType> */
    loadFull=true,
    fillCache=true,
  ) {
    const val = await VotingForum.load(this.repo, this.client, owner, $p);
    if (loadFull) {
      await val.loadFullState(this);
    }
    if (fillCache) {
      this.cache.set(val.typeTag, owner, val);
    }
    return val;
  }
}