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 Reconfiguration from "./reconfiguration";
import * as Storage_gas from "./storage_gas";
import * as String from "./string";
import * as System_addresses from "./system_addresses";
import * as Util from "./util";
import * as Vector from "./vector";
export const packageName = "AptosFramework";
export const moduleAddress = new HexString("0x1");
export const moduleName = "gas_schedule";

export const EINVALID_GAS_FEATURE_VERSION : U64 = u64("2");
export const EINVALID_GAS_SCHEDULE : U64 = u64("1");


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

  ];
  static fields: FieldDeclType[] = [
  { name: "key", typeTag: new StructTag(new HexString("0x1"), "string", "String", []) },
  { name: "val", typeTag: AtomicTypeTag.U64 }];

  key: String.String;
  val: U64;

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

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "entries", typeTag: new VectorTag(new StructTag(new HexString("0x1"), "gas_schedule", "GasEntry", [])) }];

  entries: GasEntry[];

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

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "feature_version", typeTag: AtomicTypeTag.U64 },
  { name: "entries", typeTag: new VectorTag(new StructTag(new HexString("0x1"), "gas_schedule", "GasEntry", [])) }];

  feature_version: U64;
  entries: GasEntry[];

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

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

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

}
export function initialize_ (
  aptos_framework: HexString,
  gas_schedule_blob: U8[],
  $c: AptosDataCache,
): void {
  let gas_schedule;
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  if (!!Vector.is_empty_(gas_schedule_blob, $c, [AtomicTypeTag.U8])) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_GAS_SCHEDULE), $c));
  }
  gas_schedule = Util.from_bytes_($.copy(gas_schedule_blob), $c, [new SimpleStructTag(GasScheduleV2)]);
  $c.move_to(new SimpleStructTag(GasScheduleV2), aptos_framework, $.copy(gas_schedule));
  return;
}

export function set_gas_schedule_ (
  aptos_framework: HexString,
  gas_schedule_blob: U8[],
  $c: AptosDataCache,
): void {
  let gas_schedule, new_gas_schedule, new_gas_schedule__1;
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  if (!!Vector.is_empty_(gas_schedule_blob, $c, [AtomicTypeTag.U8])) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_GAS_SCHEDULE), $c));
  }
  if ($c.exists(new SimpleStructTag(GasScheduleV2), new HexString("0x1"))) {
    gas_schedule = $c.borrow_global_mut<GasScheduleV2>(new SimpleStructTag(GasScheduleV2), new HexString("0x1"));
    new_gas_schedule = Util.from_bytes_($.copy(gas_schedule_blob), $c, [new SimpleStructTag(GasScheduleV2)]);
    if (!($.copy(new_gas_schedule.feature_version)).ge($.copy(gas_schedule.feature_version))) {
      throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_GAS_FEATURE_VERSION), $c));
    }
    $.set(gas_schedule, $.copy(new_gas_schedule));
  }
  else{
    if ($c.exists(new SimpleStructTag(GasSchedule), new HexString("0x1"))) {
      $c.move_from<GasSchedule>(new SimpleStructTag(GasSchedule), new HexString("0x1"));
    }
    else{
    }
    new_gas_schedule__1 = Util.from_bytes_($.copy(gas_schedule_blob), $c, [new SimpleStructTag(GasScheduleV2)]);
    $c.move_to(new SimpleStructTag(GasScheduleV2), aptos_framework, $.copy(new_gas_schedule__1));
  }
  Reconfiguration.reconfigure_($c);
  return;
}

export function set_storage_gas_config_ (
  aptos_framework: HexString,
  config: Storage_gas.StorageGasConfig,
  $c: AptosDataCache,
): void {
  Storage_gas.set_config_(aptos_framework, $.copy(config), $c);
  Reconfiguration.reconfigure_($c);
  return;
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser("0x1::gas_schedule::GasEntry", GasEntry.GasEntryParser);
  repo.addParser("0x1::gas_schedule::GasSchedule", GasSchedule.GasScheduleParser);
  repo.addParser("0x1::gas_schedule::GasScheduleV2", GasScheduleV2.GasScheduleV2Parser);
}
export class App {
  constructor(
    public client: AptosClient,
    public repo: AptosParserRepo,
    public cache: AptosLocalCache,
  ) {
  }
  get moduleAddress() {{ return moduleAddress; }}
  get moduleName() {{ return moduleName; }}
  get GasEntry() { return GasEntry; }
  get GasSchedule() { return GasSchedule; }
  async loadGasSchedule(
    owner: HexString,
    loadFull=true,
    fillCache=true,
  ) {
    const val = await GasSchedule.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;
  }
  get GasScheduleV2() { return GasScheduleV2; }
  async loadGasScheduleV2(
    owner: HexString,
    loadFull=true,
    fillCache=true,
  ) {
    const val = await GasScheduleV2.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;
  }
}