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 Error from './error';
import * as Signer from './signer';
import * as Vector from './vector';
export const packageName = 'MoveStdlib';
export const moduleAddress = new HexString('0x1');
export const moduleName = 'features';

export const CODE_DEPENDENCY_CHECK: U64 = u64('1');
export const EFRAMEWORK_SIGNER_NEEDED: U64 = u64('1');
export const TREAT_FRIEND_AS_PRIVATE: U64 = u64('2');

export class Features {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'Features';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [{ name: 'features', typeTag: new VectorTag(AtomicTypeTag.U8) }];

  features: U8[];

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

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

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, Features, typeParams);
    return result as unknown as Features;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, Features, typeParams);
    await result.loadFullState(app);
    return result as unknown as Features;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'Features', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}
export function change_feature_flags_(framework: HexString, enable: U64[], disable: U64[], $c: AptosDataCache): void {
  let features, i, i__1, n, n__2;
  if (!(Signer.address_of_(framework, $c).hex() === new HexString('0x1').hex())) {
    throw $.abortCode(Error.permission_denied_($.copy(EFRAMEWORK_SIGNER_NEEDED), $c));
  }
  if (!$c.exists(new SimpleStructTag(Features), new HexString('0x1'))) {
    $c.move_to(
      new SimpleStructTag(Features),
      framework,
      new Features({ features: [] as U8[] }, new SimpleStructTag(Features))
    );
  } else {
  }
  features = $c.borrow_global_mut<Features>(new SimpleStructTag(Features), new HexString('0x1')).features;
  i = u64('0');
  n = Vector.length_(enable, $c, [AtomicTypeTag.U64]);
  while ($.copy(i).lt($.copy(n))) {
    {
      set_(features, $.copy(Vector.borrow_(enable, $.copy(i), $c, [AtomicTypeTag.U64])), true, $c);
      i = $.copy(i).add(u64('1'));
    }
  }
  i__1 = u64('0');
  n__2 = Vector.length_(disable, $c, [AtomicTypeTag.U64]);
  while ($.copy(i__1).lt($.copy(n__2))) {
    {
      set_(features, $.copy(Vector.borrow_(disable, $.copy(i__1), $c, [AtomicTypeTag.U64])), false, $c);
      i__1 = $.copy(i__1).add(u64('1'));
    }
  }
  return;
}

export function code_dependency_check_enabled_($c: AptosDataCache): boolean {
  return is_enabled_($.copy(CODE_DEPENDENCY_CHECK), $c);
}

export function contains_(features: U8[], feature: U64, $c: AptosDataCache): boolean {
  let temp$1, bit_mask, byte_index;
  byte_index = $.copy(feature).div(u64('8'));
  bit_mask = u8('1').shl(u8($.copy(feature).mod(u64('8'))));
  if ($.copy(byte_index).lt(Vector.length_(features, $c, [AtomicTypeTag.U8]))) {
    temp$1 = $.copy(Vector.borrow_(features, $.copy(byte_index), $c, [AtomicTypeTag.U8]))
      .and($.copy(bit_mask))
      .neq(u8('0'));
  } else {
    temp$1 = false;
  }
  return temp$1;
}

export function is_enabled_(feature: U64, $c: AptosDataCache): boolean {
  let temp$1;
  if ($c.exists(new SimpleStructTag(Features), new HexString('0x1'))) {
    temp$1 = contains_(
      $c.borrow_global<Features>(new SimpleStructTag(Features), new HexString('0x1')).features,
      $.copy(feature),
      $c
    );
  } else {
    temp$1 = false;
  }
  return temp$1;
}

export function set_(features: U8[], feature: U64, include: boolean, $c: AptosDataCache): void {
  let bit_mask, byte_index, entry;
  byte_index = $.copy(feature).div(u64('8'));
  bit_mask = u8('1').shl(u8($.copy(feature).mod(u64('8'))));
  while (Vector.length_(features, $c, [AtomicTypeTag.U8]).le($.copy(byte_index))) {
    {
      Vector.push_back_(features, u8('0'), $c, [AtomicTypeTag.U8]);
    }
  }
  entry = Vector.borrow_mut_(features, $.copy(byte_index), $c, [AtomicTypeTag.U8]);
  if (include) {
    $.set(entry, $.copy(entry).or($.copy(bit_mask)));
  } else {
    $.set(entry, $.copy(entry).and(u8('255').xor($.copy(bit_mask))));
  }
  return;
}

export function treat_friend_as_private_($c: AptosDataCache): boolean {
  return is_enabled_($.copy(TREAT_FRIEND_AS_PRIVATE), $c);
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser('0x1::features::Features', Features.FeaturesParser);
}
export class App {
  constructor(public client: AptosClient, public repo: AptosParserRepo, public cache: AptosLocalCache) {}
  get moduleAddress() {
    {
      return moduleAddress;
    }
  }
  get moduleName() {
    {
      return moduleName;
    }
  }
  get Features() {
    return Features;
  }
  async loadFeatures(owner: HexString, loadFull = true, fillCache = true) {
    const val = await Features.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;
  }
}