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 Code from './code';
import * as Coin from './coin';
import * as Error from './error';
import * as Signer from './signer';
import * as Simple_map from './simple_map';
import * as Vector from './vector';
export const packageName = 'AptosFramework';
export const moduleAddress = new HexString('0x1');
export const moduleName = 'resource_account';

export const ECONTAINER_NOT_PUBLISHED: U64 = u64('1');
export const ZERO_AUTH_KEY: U8[] = [
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0'),
  u8('0')
];

export class Container {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'Container';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    {
      name: 'store',
      typeTag: new StructTag(new HexString('0x1'), 'simple_map', 'SimpleMap', [
        AtomicTypeTag.Address,
        new StructTag(new HexString('0x1'), 'account', 'SignerCapability', [])
      ])
    }
  ];

  store: Simple_map.SimpleMap;

  constructor(proto: any, public typeTag: TypeTag) {
    this.store = proto['store'] as Simple_map.SimpleMap;
  }

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

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, Container, typeParams);
    return result as unknown as Container;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, Container, typeParams);
    await result.loadFullState(app);
    return result as unknown as Container;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'Container', []);
  }
  async loadFullState(app: $.AppType) {
    await this.store.loadFullState(app);
    this.__app = app;
  }
}
export function create_resource_account_(
  origin: HexString,
  seed: U8[],
  optional_auth_key: U8[],
  $c: AptosDataCache
): void {
  let resource, resource_signer_cap;
  [resource, resource_signer_cap] = Account.create_resource_account_(origin, $.copy(seed), $c);
  rotate_account_authentication_key_and_store_capability_(
    origin,
    resource,
    resource_signer_cap,
    $.copy(optional_auth_key),
    $c
  );
  return;
}

export function buildPayload_create_resource_account(
  seed: U8[],
  optional_auth_key: U8[],
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'resource_account',
    'create_resource_account',
    typeParamStrings,
    [seed, optional_auth_key],
    isJSON
  );
}
export function create_resource_account_and_fund_(
  origin: HexString,
  seed: U8[],
  optional_auth_key: U8[],
  fund_amount: U64,
  $c: AptosDataCache
): void {
  let resource, resource_signer_cap;
  [resource, resource_signer_cap] = Account.create_resource_account_(origin, $.copy(seed), $c);
  Coin.register_(resource, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
  Coin.transfer_(origin, Signer.address_of_(resource, $c), $.copy(fund_amount), $c, [
    new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
  ]);
  rotate_account_authentication_key_and_store_capability_(
    origin,
    resource,
    resource_signer_cap,
    $.copy(optional_auth_key),
    $c
  );
  return;
}

export function buildPayload_create_resource_account_and_fund(
  seed: U8[],
  optional_auth_key: U8[],
  fund_amount: U64,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'resource_account',
    'create_resource_account_and_fund',
    typeParamStrings,
    [seed, optional_auth_key, fund_amount],
    isJSON
  );
}
export function create_resource_account_and_publish_package_(
  origin: HexString,
  seed: U8[],
  metadata_serialized: U8[],
  code: U8[][],
  $c: AptosDataCache
): void {
  let resource, resource_signer_cap;
  [resource, resource_signer_cap] = Account.create_resource_account_(origin, $.copy(seed), $c);
  Code.publish_package_txn_(resource, $.copy(metadata_serialized), $.copy(code), $c);
  rotate_account_authentication_key_and_store_capability_(
    origin,
    resource,
    resource_signer_cap,
    $.copy(ZERO_AUTH_KEY),
    $c
  );
  return;
}

export function buildPayload_create_resource_account_and_publish_package(
  seed: U8[],
  metadata_serialized: U8[],
  code: U8[][],
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'resource_account',
    'create_resource_account_and_publish_package',
    typeParamStrings,
    [seed, metadata_serialized, code],
    isJSON
  );
}
export function retrieve_resource_account_cap_(
  resource: HexString,
  source_addr: HexString,
  $c: AptosDataCache
): Account.SignerCapability {
  let _resource_addr,
    container,
    container__1,
    empty_container,
    resource__2,
    resource_addr,
    resource_signer_cap,
    signer_cap;
  if (!$c.exists(new SimpleStructTag(Container), $.copy(source_addr))) {
    throw $.abortCode(Error.not_found_($.copy(ECONTAINER_NOT_PUBLISHED), $c));
  }
  resource_addr = Signer.address_of_(resource, $c);
  container = $c.borrow_global_mut<Container>(new SimpleStructTag(Container), $.copy(source_addr));
  [_resource_addr, signer_cap] = Simple_map.remove_(container.store, resource_addr, $c, [
    AtomicTypeTag.Address,
    new StructTag(new HexString('0x1'), 'account', 'SignerCapability', [])
  ]);
  [resource_signer_cap, empty_container] = [
    signer_cap,
    Simple_map.length_(container.store, $c, [
      AtomicTypeTag.Address,
      new StructTag(new HexString('0x1'), 'account', 'SignerCapability', [])
    ]).eq(u64('0'))
  ];
  if (empty_container) {
    container__1 = $c.move_from<Container>(new SimpleStructTag(Container), $.copy(source_addr));
    let { store: store } = container__1;
    Simple_map.destroy_empty_(store, $c, [
      AtomicTypeTag.Address,
      new StructTag(new HexString('0x1'), 'account', 'SignerCapability', [])
    ]);
  } else {
  }
  resource__2 = Account.create_signer_with_capability_(resource_signer_cap, $c);
  Account.rotate_authentication_key_internal_(resource__2, $.copy(ZERO_AUTH_KEY), $c);
  return resource_signer_cap;
}

export function rotate_account_authentication_key_and_store_capability_(
  origin: HexString,
  resource: HexString,
  resource_signer_cap: Account.SignerCapability,
  optional_auth_key: U8[],
  $c: AptosDataCache
): void {
  let temp$1, auth_key, container, origin_addr, resource_addr;
  origin_addr = Signer.address_of_(origin, $c);
  if (!$c.exists(new SimpleStructTag(Container), $.copy(origin_addr))) {
    $c.move_to(
      new SimpleStructTag(Container),
      origin,
      new Container(
        {
          store: Simple_map.create_($c, [
            AtomicTypeTag.Address,
            new StructTag(new HexString('0x1'), 'account', 'SignerCapability', [])
          ])
        },
        new SimpleStructTag(Container)
      )
    );
  } else {
  }
  container = $c.borrow_global_mut<Container>(new SimpleStructTag(Container), $.copy(origin_addr));
  resource_addr = Signer.address_of_(resource, $c);
  Simple_map.add_(container.store, $.copy(resource_addr), resource_signer_cap, $c, [
    AtomicTypeTag.Address,
    new StructTag(new HexString('0x1'), 'account', 'SignerCapability', [])
  ]);
  if (Vector.is_empty_(optional_auth_key, $c, [AtomicTypeTag.U8])) {
    temp$1 = Account.get_authentication_key_($.copy(origin_addr), $c);
  } else {
    temp$1 = $.copy(optional_auth_key);
  }
  auth_key = temp$1;
  Account.rotate_authentication_key_internal_(resource, $.copy(auth_key), $c);
  return;
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser('0x1::resource_account::Container', Container.ContainerParser);
}
export class App {
  constructor(public client: AptosClient, public repo: AptosParserRepo, public cache: AptosLocalCache) {}
  get moduleAddress() {
    {
      return moduleAddress;
    }
  }
  get moduleName() {
    {
      return moduleName;
    }
  }
  get Container() {
    return Container;
  }
  async loadContainer(owner: HexString, loadFull = true, fillCache = true) {
    const val = await Container.load(this.repo, this.client, owner, [] as TypeTag[]);
    if (loadFull) {
      await val.loadFullState(this);
    }
    if (fillCache) {
      this.cache.set(val.typeTag, owner, val);
    }
    return val;
  }
  payload_create_resource_account(
    seed: U8[],
    optional_auth_key: U8[],
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_create_resource_account(seed, optional_auth_key, isJSON);
  }
  async create_resource_account(
    _account: AptosAccount,
    seed: U8[],
    optional_auth_key: U8[],
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_create_resource_account(seed, optional_auth_key, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_create_resource_account_and_fund(
    seed: U8[],
    optional_auth_key: U8[],
    fund_amount: U64,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_create_resource_account_and_fund(seed, optional_auth_key, fund_amount, isJSON);
  }
  async create_resource_account_and_fund(
    _account: AptosAccount,
    seed: U8[],
    optional_auth_key: U8[],
    fund_amount: U64,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_create_resource_account_and_fund(seed, optional_auth_key, fund_amount, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_create_resource_account_and_publish_package(
    seed: U8[],
    metadata_serialized: U8[],
    code: U8[][],
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_create_resource_account_and_publish_package(seed, metadata_serialized, code, isJSON);
  }
  async create_resource_account_and_publish_package(
    _account: AptosAccount,
    seed: U8[],
    metadata_serialized: U8[],
    code: U8[][],
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_create_resource_account_and_publish_package(
      seed,
      metadata_serialized,
      code,
      _isJSON
    );
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
}