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 Option from "./option";
import * as Vector from "./vector";
export const packageName = "MoveStdlib";
export const moduleAddress = new HexString("0x1");
export const moduleName = "string";

export const EINVALID_INDEX : U64 = u64("2");
export const EINVALID_UTF8 : U64 = u64("1");


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

  ];
  static fields: FieldDeclType[] = [
  { name: "bytes", typeTag: new VectorTag(AtomicTypeTag.U8) }];

  bytes: U8[];

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

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

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

}
export function append_ (
  s: String,
  r: String,
  $c: AptosDataCache,
): void {
  return Vector.append_(s.bytes, $.copy(r.bytes), $c, [AtomicTypeTag.U8]);
}

export function append_utf8_ (
  s: String,
  bytes: U8[],
  $c: AptosDataCache,
): void {
  return append_(s, utf8_($.copy(bytes), $c), $c);
}

export function bytes_ (
  s: String,
  $c: AptosDataCache,
): U8[] {
  return s.bytes;
}

export function index_of_ (
  s: String,
  r: String,
  $c: AptosDataCache,
): U64 {
  return internal_index_of_(s.bytes, r.bytes, $c);
}

export function insert_ (
  s: String,
  at: U64,
  o: String,
  $c: AptosDataCache,
): void {
  let temp$1, temp$2, temp$3, temp$4, temp$5, temp$6, temp$7, bytes, end, front, l;
  bytes = s.bytes;
  if (($.copy(at)).le(Vector.length_(bytes, $c, [AtomicTypeTag.U8]))) {
    temp$1 = internal_is_char_boundary_(bytes, $.copy(at), $c);
  }
  else{
    temp$1 = false;
  }
  if (!temp$1) {
    throw $.abortCode($.copy(EINVALID_INDEX));
  }
  l = length_(s, $c);
  [temp$2, temp$3, temp$4] = [s, u64("0"), $.copy(at)];
  front = sub_string_(temp$2, temp$3, temp$4, $c);
  [temp$5, temp$6, temp$7] = [s, $.copy(at), $.copy(l)];
  end = sub_string_(temp$5, temp$6, temp$7, $c);
  append_(front, $.copy(o), $c);
  append_(front, $.copy(end), $c);
  $.set(s, $.copy(front));
  return;
}

export function internal_check_utf8_ (
  v: U8[],
  $c: AptosDataCache,
): boolean {
  return $.std_string_internal_check_utf8(v, $c);

}
export function internal_index_of_ (
  v: U8[],
  r: U8[],
  $c: AptosDataCache,
): U64 {
  return $.std_string_internal_index_of(v, r, $c);

}
export function internal_is_char_boundary_ (
  v: U8[],
  i: U64,
  $c: AptosDataCache,
): boolean {
  return $.std_string_internal_is_char_boundary(v, i, $c);

}
export function internal_sub_string_ (
  v: U8[],
  i: U64,
  j: U64,
  $c: AptosDataCache,
): U8[] {
  return $.std_string_internal_sub_string(v, i, j, $c);

}
export function is_empty_ (
  s: String,
  $c: AptosDataCache,
): boolean {
  return Vector.is_empty_(s.bytes, $c, [AtomicTypeTag.U8]);
}

export function length_ (
  s: String,
  $c: AptosDataCache,
): U64 {
  return Vector.length_(s.bytes, $c, [AtomicTypeTag.U8]);
}

export function sub_string_ (
  s: String,
  i: U64,
  j: U64,
  $c: AptosDataCache,
): String {
  let temp$1, temp$2, temp$3, bytes, l;
  bytes = s.bytes;
  l = Vector.length_(bytes, $c, [AtomicTypeTag.U8]);
  if (($.copy(j)).le($.copy(l))) {
    temp$1 = ($.copy(i)).le($.copy(j));
  }
  else{
    temp$1 = false;
  }
  if (temp$1) {
    temp$2 = internal_is_char_boundary_(bytes, $.copy(i), $c);
  }
  else{
    temp$2 = false;
  }
  if (temp$2) {
    temp$3 = internal_is_char_boundary_(bytes, $.copy(j), $c);
  }
  else{
    temp$3 = false;
  }
  if (!temp$3) {
    throw $.abortCode($.copy(EINVALID_INDEX));
  }
  return new String({ bytes: internal_sub_string_(bytes, $.copy(i), $.copy(j), $c) }, new SimpleStructTag(String));
}

export function try_utf8_ (
  bytes: U8[],
  $c: AptosDataCache,
): Option.Option {
  let temp$1;
  if (internal_check_utf8_(bytes, $c)) {
    temp$1 = Option.some_(new String({ bytes: $.copy(bytes) }, new SimpleStructTag(String)), $c, [new SimpleStructTag(String)]);
  }
  else{
    temp$1 = Option.none_($c, [new SimpleStructTag(String)]);
  }
  return temp$1;
}

export function utf8_ (
  bytes: U8[],
  $c: AptosDataCache,
): String {
  if (!internal_check_utf8_(bytes, $c)) {
    throw $.abortCode($.copy(EINVALID_UTF8));
  }
  return new String({ bytes: $.copy(bytes) }, new SimpleStructTag(String));
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser("0x1::string::String", String.StringParser);
}
export class App {
  constructor(
    public client: AptosClient,
    public repo: AptosParserRepo,
    public cache: AptosLocalCache,
  ) {
  }
  get moduleAddress() {{ return moduleAddress; }}
  get moduleName() {{ return moduleName; }}
  get String() { return String; }
}