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

export const EINDEX : U64 = u64("131072");
export const ELENGTH : U64 = u64("131073");
export const MAX_SIZE : U64 = u64("1024");
export const WORD_SIZE : U64 = u64("1");


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

  ];
  static fields: FieldDeclType[] = [
  { name: "length", typeTag: AtomicTypeTag.U64 },
  { name: "bit_field", typeTag: new VectorTag(AtomicTypeTag.Bool) }];

  length: U64;
  bit_field: boolean[];

  constructor(proto: any, public typeTag: TypeTag) {
    this.length = proto['length'] as U64;
    this.bit_field = proto['bit_field'] as boolean[];
  }

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

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

}
export function is_index_set_ (
  bitvector: BitVector,
  bit_index: U64,
  $c: AptosDataCache,
): boolean {
  if (!($.copy(bit_index)).lt(Vector.length_(bitvector.bit_field, $c, [AtomicTypeTag.Bool]))) {
    throw $.abortCode($.copy(EINDEX));
  }
  return $.copy(Vector.borrow_(bitvector.bit_field, $.copy(bit_index), $c, [AtomicTypeTag.Bool]));
}

export function length_ (
  bitvector: BitVector,
  $c: AptosDataCache,
): U64 {
  return Vector.length_(bitvector.bit_field, $c, [AtomicTypeTag.Bool]);
}

export function longest_set_sequence_starting_at_ (
  bitvector: BitVector,
  start_index: U64,
  $c: AptosDataCache,
): U64 {
  let index;
  if (!($.copy(start_index)).lt($.copy(bitvector.length))) {
    throw $.abortCode($.copy(EINDEX));
  }
  index = $.copy(start_index);
  while (($.copy(index)).lt($.copy(bitvector.length))) {
    {
      if (!is_index_set_(bitvector, $.copy(index), $c)) {
        break;
      }
      else{
      }
      index = ($.copy(index)).add(u64("1"));
    }

  }return ($.copy(index)).sub($.copy(start_index));
}

export function new___ (
  length: U64,
  $c: AptosDataCache,
): BitVector {
  let bit_field, counter;
  if (!($.copy(length)).gt(u64("0"))) {
    throw $.abortCode($.copy(ELENGTH));
  }
  if (!($.copy(length)).lt($.copy(MAX_SIZE))) {
    throw $.abortCode($.copy(ELENGTH));
  }
  counter = u64("0");
  bit_field = Vector.empty_($c, [AtomicTypeTag.Bool]);
  while (true) {
    {
      ;
    }
    if (!(($.copy(counter)).lt($.copy(length)))) break;
    {
      Vector.push_back_(bit_field, false, $c, [AtomicTypeTag.Bool]);
      counter = ($.copy(counter)).add(u64("1"));
    }

  };
  return new BitVector({ length: $.copy(length), bit_field: $.copy(bit_field) }, new SimpleStructTag(BitVector));
}

export function set_ (
  bitvector: BitVector,
  bit_index: U64,
  $c: AptosDataCache,
): void {
  let x;
  if (!($.copy(bit_index)).lt(Vector.length_(bitvector.bit_field, $c, [AtomicTypeTag.Bool]))) {
    throw $.abortCode($.copy(EINDEX));
  }
  x = Vector.borrow_mut_(bitvector.bit_field, $.copy(bit_index), $c, [AtomicTypeTag.Bool]);
  $.set(x, true);
  return;
}

export function shift_left_ (
  bitvector: BitVector,
  amount: U64,
  $c: AptosDataCache,
): void {
  let temp$2, temp$3, elem, i, i__1, len;
  if (($.copy(amount)).ge($.copy(bitvector.length))) {
    len = Vector.length_(bitvector.bit_field, $c, [AtomicTypeTag.Bool]);
    i = u64("0");
    while (($.copy(i)).lt($.copy(len))) {
      {
        elem = Vector.borrow_mut_(bitvector.bit_field, $.copy(i), $c, [AtomicTypeTag.Bool]);
        $.set(elem, false);
        i = ($.copy(i)).add(u64("1"));
      }

    }}
  else{
    i__1 = $.copy(amount);
    while (($.copy(i__1)).lt($.copy(bitvector.length))) {
      {
        [temp$2, temp$3] = [bitvector, $.copy(i__1)];
        if (is_index_set_(temp$2, temp$3, $c)) {
          set_(bitvector, ($.copy(i__1)).sub($.copy(amount)), $c);
        }
        else{
          unset_(bitvector, ($.copy(i__1)).sub($.copy(amount)), $c);
        }
        i__1 = ($.copy(i__1)).add(u64("1"));
      }

    }i__1 = ($.copy(bitvector.length)).sub($.copy(amount));
    while (($.copy(i__1)).lt($.copy(bitvector.length))) {
      {
        unset_(bitvector, $.copy(i__1), $c);
        i__1 = ($.copy(i__1)).add(u64("1"));
      }

    }}
  return;
}

export function unset_ (
  bitvector: BitVector,
  bit_index: U64,
  $c: AptosDataCache,
): void {
  let x;
  if (!($.copy(bit_index)).lt(Vector.length_(bitvector.bit_field, $c, [AtomicTypeTag.Bool]))) {
    throw $.abortCode($.copy(EINDEX));
  }
  x = Vector.borrow_mut_(bitvector.bit_field, $.copy(bit_index), $c, [AtomicTypeTag.Bool]);
  $.set(x, false);
  return;
}

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