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 Coin from './coin';
import * as Error from './error';
import * as Signer from './signer';
import * as String from './string';
export const packageName = 'AptosFramework';
export const moduleAddress = new HexString('0x1');
export const moduleName = 'managed_coin';

export const ENO_CAPABILITIES: U64 = u64('1');

export class Capabilities {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'Capabilities';
  static typeParameters: TypeParamDeclType[] = [{ name: 'CoinType', isPhantom: true }];
  static fields: FieldDeclType[] = [
    {
      name: 'burn_cap',
      typeTag: new StructTag(new HexString('0x1'), 'coin', 'BurnCapability', [new $.TypeParamIdx(0)])
    },
    {
      name: 'freeze_cap',
      typeTag: new StructTag(new HexString('0x1'), 'coin', 'FreezeCapability', [new $.TypeParamIdx(0)])
    },
    {
      name: 'mint_cap',
      typeTag: new StructTag(new HexString('0x1'), 'coin', 'MintCapability', [new $.TypeParamIdx(0)])
    }
  ];

  burn_cap: Coin.BurnCapability;
  freeze_cap: Coin.FreezeCapability;
  mint_cap: Coin.MintCapability;

  constructor(proto: any, public typeTag: TypeTag) {
    this.burn_cap = proto['burn_cap'] as Coin.BurnCapability;
    this.freeze_cap = proto['freeze_cap'] as Coin.FreezeCapability;
    this.mint_cap = proto['mint_cap'] as Coin.MintCapability;
  }

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

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, Capabilities, typeParams);
    return result as unknown as Capabilities;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, Capabilities, typeParams);
    await result.loadFullState(app);
    return result as unknown as Capabilities;
  }
  static makeTag($p: TypeTag[]): StructTag {
    return new StructTag(moduleAddress, moduleName, 'Capabilities', $p);
  }
  async loadFullState(app: $.AppType) {
    await this.burn_cap.loadFullState(app);
    await this.freeze_cap.loadFullState(app);
    await this.mint_cap.loadFullState(app);
    this.__app = app;
  }
}
export function burn_(account: HexString, amount: U64, $c: AptosDataCache, $p: TypeTag[] /* <CoinType>*/): void {
  let account_addr, capabilities, to_burn;
  account_addr = Signer.address_of_(account, $c);
  if (!$c.exists(new SimpleStructTag(Capabilities, [$p[0]]), $.copy(account_addr))) {
    throw $.abortCode(Error.not_found_($.copy(ENO_CAPABILITIES), $c));
  }
  capabilities = $c.borrow_global<Capabilities>(new SimpleStructTag(Capabilities, [$p[0]]), $.copy(account_addr));
  to_burn = Coin.withdraw_(account, $.copy(amount), $c, [$p[0]]);
  Coin.burn_(to_burn, capabilities.burn_cap, $c, [$p[0]]);
  return;
}

export function buildPayload_burn(
  amount: U64,
  $p: TypeTag[] /* <CoinType>*/,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = $p.map((t) => $.getTypeTagFullname(t));
  return $.buildPayload(new HexString('0x1'), 'managed_coin', 'burn', typeParamStrings, [amount], isJSON);
}
export function initialize_(
  account: HexString,
  name: U8[],
  symbol: U8[],
  decimals: U8,
  monitor_supply: boolean,
  $c: AptosDataCache,
  $p: TypeTag[] /* <CoinType>*/
): void {
  let burn_cap, freeze_cap, mint_cap;
  [burn_cap, freeze_cap, mint_cap] = Coin.initialize_(
    account,
    String.utf8_($.copy(name), $c),
    String.utf8_($.copy(symbol), $c),
    $.copy(decimals),
    monitor_supply,
    $c,
    [$p[0]]
  );
  $c.move_to(
    new SimpleStructTag(Capabilities, [$p[0]]),
    account,
    new Capabilities(
      { burn_cap: $.copy(burn_cap), freeze_cap: $.copy(freeze_cap), mint_cap: $.copy(mint_cap) },
      new SimpleStructTag(Capabilities, [$p[0]])
    )
  );
  return;
}

export function buildPayload_initialize(
  name: U8[],
  symbol: U8[],
  decimals: U8,
  monitor_supply: boolean,
  $p: TypeTag[] /* <CoinType>*/,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = $p.map((t) => $.getTypeTagFullname(t));
  return $.buildPayload(
    new HexString('0x1'),
    'managed_coin',
    'initialize',
    typeParamStrings,
    [name, symbol, decimals, monitor_supply],
    isJSON
  );
}
export function mint_(
  account: HexString,
  dst_addr: HexString,
  amount: U64,
  $c: AptosDataCache,
  $p: TypeTag[] /* <CoinType>*/
): void {
  let account_addr, capabilities, coins_minted;
  account_addr = Signer.address_of_(account, $c);
  if (!$c.exists(new SimpleStructTag(Capabilities, [$p[0]]), $.copy(account_addr))) {
    throw $.abortCode(Error.not_found_($.copy(ENO_CAPABILITIES), $c));
  }
  capabilities = $c.borrow_global<Capabilities>(new SimpleStructTag(Capabilities, [$p[0]]), $.copy(account_addr));
  coins_minted = Coin.mint_($.copy(amount), capabilities.mint_cap, $c, [$p[0]]);
  Coin.deposit_($.copy(dst_addr), coins_minted, $c, [$p[0]]);
  return;
}

export function buildPayload_mint(
  dst_addr: HexString,
  amount: U64,
  $p: TypeTag[] /* <CoinType>*/,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = $p.map((t) => $.getTypeTagFullname(t));
  return $.buildPayload(new HexString('0x1'), 'managed_coin', 'mint', typeParamStrings, [dst_addr, amount], isJSON);
}
export function register_(account: HexString, $c: AptosDataCache, $p: TypeTag[] /* <CoinType>*/): void {
  Coin.register_(account, $c, [$p[0]]);
  return;
}

export function buildPayload_register(
  $p: TypeTag[] /* <CoinType>*/,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = $p.map((t) => $.getTypeTagFullname(t));
  return $.buildPayload(new HexString('0x1'), 'managed_coin', 'register', typeParamStrings, [], isJSON);
}
export function loadParsers(repo: AptosParserRepo) {
  repo.addParser('0x1::managed_coin::Capabilities', Capabilities.CapabilitiesParser);
}
export class App {
  constructor(public client: AptosClient, public repo: AptosParserRepo, public cache: AptosLocalCache) {}
  get moduleAddress() {
    {
      return moduleAddress;
    }
  }
  get moduleName() {
    {
      return moduleName;
    }
  }
  get Capabilities() {
    return Capabilities;
  }
  async loadCapabilities(owner: HexString, $p: TypeTag[] /* <CoinType> */, loadFull = true, fillCache = true) {
    const val = await Capabilities.load(this.repo, this.client, owner, $p);
    if (loadFull) {
      await val.loadFullState(this);
    }
    if (fillCache) {
      this.cache.set(val.typeTag, owner, val);
    }
    return val;
  }
  payload_burn(
    amount: U64,
    $p: TypeTag[] /* <CoinType>*/,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_burn(amount, $p, isJSON);
  }
  async burn(
    _account: AptosAccount,
    amount: U64,
    $p: TypeTag[] /* <CoinType>*/,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_burn(amount, $p, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_initialize(
    name: U8[],
    symbol: U8[],
    decimals: U8,
    monitor_supply: boolean,
    $p: TypeTag[] /* <CoinType>*/,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_initialize(name, symbol, decimals, monitor_supply, $p, isJSON);
  }
  async initialize(
    _account: AptosAccount,
    name: U8[],
    symbol: U8[],
    decimals: U8,
    monitor_supply: boolean,
    $p: TypeTag[] /* <CoinType>*/,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_initialize(name, symbol, decimals, monitor_supply, $p, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_mint(
    dst_addr: HexString,
    amount: U64,
    $p: TypeTag[] /* <CoinType>*/,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_mint(dst_addr, amount, $p, isJSON);
  }
  async mint(
    _account: AptosAccount,
    dst_addr: HexString,
    amount: U64,
    $p: TypeTag[] /* <CoinType>*/,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_mint(dst_addr, amount, $p, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_register(
    $p: TypeTag[] /* <CoinType>*/,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_register($p, isJSON);
  }
  async register(_account: AptosAccount, $p: TypeTag[] /* <CoinType>*/, option?: OptionTransaction, _isJSON = false) {
    const payload__ = buildPayload_register($p, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
}