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 Simple_map from "./simple_map";
import * as Vector from "./vector";
export const packageName = "AptosStdlib";
export const moduleAddress = new HexString("0x1");
export const moduleName = "pool_u64";

export const EINSUFFICIENT_SHARES : U64 = u64("4");
export const EPOOL_IS_NOT_EMPTY : U64 = u64("3");
export const EPOOL_TOTAL_COINS_OVERFLOW : U64 = u64("6");
export const EPOOL_TOTAL_SHARES_OVERFLOW : U64 = u64("7");
export const ESHAREHOLDER_NOT_FOUND : U64 = u64("1");
export const ESHAREHOLDER_SHARES_OVERFLOW : U64 = u64("5");
export const ETOO_MANY_SHAREHOLDERS : U64 = u64("2");
export const MAX_U64 : U64 = u64("18446744073709551615");


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

  ];
  static fields: FieldDeclType[] = [
  { name: "shareholders_limit", typeTag: AtomicTypeTag.U64 },
  { name: "total_coins", typeTag: AtomicTypeTag.U64 },
  { name: "total_shares", typeTag: AtomicTypeTag.U64 },
  { name: "shares", typeTag: new StructTag(new HexString("0x1"), "simple_map", "SimpleMap", [AtomicTypeTag.Address, AtomicTypeTag.U64]) },
  { name: "shareholders", typeTag: new VectorTag(AtomicTypeTag.Address) },
  { name: "scaling_factor", typeTag: AtomicTypeTag.U64 }];

  shareholders_limit: U64;
  total_coins: U64;
  total_shares: U64;
  shares: Simple_map.SimpleMap;
  shareholders: HexString[];
  scaling_factor: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.shareholders_limit = proto['shareholders_limit'] as U64;
    this.total_coins = proto['total_coins'] as U64;
    this.total_shares = proto['total_shares'] as U64;
    this.shares = proto['shares'] as Simple_map.SimpleMap;
    this.shareholders = proto['shareholders'] as HexString[];
    this.scaling_factor = proto['scaling_factor'] as U64;
  }

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

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

}
export function add_shares_ (
  pool: Pool,
  shareholder: HexString,
  new_shares: U64,
  $c: AptosDataCache,
): U64 {
  let temp$1, temp$2, temp$3, temp$4, current_shares, existing_shares;
  [temp$1, temp$2] = [pool, $.copy(shareholder)];
  if (contains_(temp$1, temp$2, $c)) {
    existing_shares = Simple_map.borrow_mut_(pool.shares, shareholder, $c, [AtomicTypeTag.Address, AtomicTypeTag.U64]);
    current_shares = $.copy(existing_shares);
    if (!(($.copy(MAX_U64)).sub($.copy(current_shares))).ge($.copy(new_shares))) {
      throw $.abortCode(Error.invalid_argument_($.copy(ESHAREHOLDER_SHARES_OVERFLOW), $c));
    }
    $.set(existing_shares, ($.copy(current_shares)).add($.copy(new_shares)));
    temp$4 = $.copy(existing_shares);
  }
  else{
    if (($.copy(new_shares)).gt(u64("0"))) {
      if (!(Vector.length_(pool.shareholders, $c, [AtomicTypeTag.Address])).lt($.copy(pool.shareholders_limit))) {
        throw $.abortCode(Error.invalid_state_($.copy(ETOO_MANY_SHAREHOLDERS), $c));
      }
      Vector.push_back_(pool.shareholders, $.copy(shareholder), $c, [AtomicTypeTag.Address]);
      Simple_map.add_(pool.shares, $.copy(shareholder), $.copy(new_shares), $c, [AtomicTypeTag.Address, AtomicTypeTag.U64]);
      temp$3 = $.copy(new_shares);
    }
    else{
      temp$3 = $.copy(new_shares);
    }
    temp$4 = temp$3;
  }
  return temp$4;
}

export function amount_to_shares_ (
  pool: Pool,
  coins_amount: U64,
  $c: AptosDataCache,
): U64 {
  return amount_to_shares_with_total_coins_(pool, $.copy(coins_amount), $.copy(pool.total_coins), $c);
}

export function amount_to_shares_with_total_coins_ (
  pool: Pool,
  coins_amount: U64,
  total_coins: U64,
  $c: AptosDataCache,
): U64 {
  let temp$1, temp$2;
  if (($.copy(pool.total_coins)).eq((u64("0")))) {
    temp$1 = true;
  }
  else{
    temp$1 = ($.copy(pool.total_shares)).eq((u64("0")));
  }
  if (temp$1) {
    temp$2 = ($.copy(coins_amount)).mul($.copy(pool.scaling_factor));
  }
  else{
    temp$2 = multiply_then_divide_(pool, $.copy(coins_amount), $.copy(pool.total_shares), $.copy(total_coins), $c);
  }
  return temp$2;
}

export function balance_ (
  pool: Pool,
  shareholder: HexString,
  $c: AptosDataCache,
): U64 {
  let num_shares;
  num_shares = shares_(pool, $.copy(shareholder), $c);
  return shares_to_amount_(pool, $.copy(num_shares), $c);
}

export function buy_in_ (
  pool: Pool,
  shareholder: HexString,
  coins_amount: U64,
  $c: AptosDataCache,
): U64 {
  let temp$1, temp$2, new_shares;
  if (($.copy(coins_amount)).eq((u64("0")))) {
    return u64("0");
  }
  else{
  }
  [temp$1, temp$2] = [pool, $.copy(coins_amount)];
  new_shares = amount_to_shares_(temp$1, temp$2, $c);
  if (!(($.copy(MAX_U64)).sub($.copy(pool.total_coins))).ge($.copy(coins_amount))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EPOOL_TOTAL_COINS_OVERFLOW), $c));
  }
  if (!(($.copy(MAX_U64)).sub($.copy(pool.total_shares))).ge($.copy(new_shares))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EPOOL_TOTAL_COINS_OVERFLOW), $c));
  }
  pool.total_coins = ($.copy(pool.total_coins)).add($.copy(coins_amount));
  pool.total_shares = ($.copy(pool.total_shares)).add($.copy(new_shares));
  add_shares_(pool, $.copy(shareholder), $.copy(new_shares), $c);
  return $.copy(new_shares);
}

export function contains_ (
  pool: Pool,
  shareholder: HexString,
  $c: AptosDataCache,
): boolean {
  return Simple_map.contains_key_(pool.shares, shareholder, $c, [AtomicTypeTag.Address, AtomicTypeTag.U64]);
}

export function create_ (
  shareholders_limit: U64,
  $c: AptosDataCache,
): Pool {
  return create_with_scaling_factor_($.copy(shareholders_limit), u64("1"), $c);
}

export function create_with_scaling_factor_ (
  shareholders_limit: U64,
  scaling_factor: U64,
  $c: AptosDataCache,
): Pool {
  return new Pool({ shareholders_limit: $.copy(shareholders_limit), total_coins: u64("0"), total_shares: u64("0"), shares: Simple_map.create_($c, [AtomicTypeTag.Address, AtomicTypeTag.U64]), shareholders: Vector.empty_($c, [AtomicTypeTag.Address]), scaling_factor: $.copy(scaling_factor) }, new SimpleStructTag(Pool));
}

export function deduct_shares_ (
  pool: Pool,
  shareholder: HexString,
  num_shares: U64,
  $c: AptosDataCache,
): U64 {
  let temp$1, temp$2, temp$3, temp$4, existing_shares, remaining_shares, shareholder_index;
  [temp$1, temp$2] = [pool, $.copy(shareholder)];
  if (!contains_(temp$1, temp$2, $c)) {
    throw $.abortCode(Error.invalid_argument_($.copy(ESHAREHOLDER_NOT_FOUND), $c));
  }
  [temp$3, temp$4] = [pool, $.copy(shareholder)];
  if (!(shares_(temp$3, temp$4, $c)).ge($.copy(num_shares))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINSUFFICIENT_SHARES), $c));
  }
  existing_shares = Simple_map.borrow_mut_(pool.shares, shareholder, $c, [AtomicTypeTag.Address, AtomicTypeTag.U64]);
  $.set(existing_shares, ($.copy(existing_shares)).sub($.copy(num_shares)));
  remaining_shares = $.copy(existing_shares);
  if (($.copy(remaining_shares)).eq((u64("0")))) {
    [, shareholder_index] = Vector.index_of_(pool.shareholders, shareholder, $c, [AtomicTypeTag.Address]);
    Vector.remove_(pool.shareholders, $.copy(shareholder_index), $c, [AtomicTypeTag.Address]);
    Simple_map.remove_(pool.shares, shareholder, $c, [AtomicTypeTag.Address, AtomicTypeTag.U64]);
  }
  else{
  }
  return $.copy(remaining_shares);
}

export function destroy_empty_ (
  pool: Pool,
  $c: AptosDataCache,
): void {
  if (!($.copy(pool.total_coins)).eq((u64("0")))) {
    throw $.abortCode(Error.invalid_state_($.copy(EPOOL_IS_NOT_EMPTY), $c));
  }
  pool;
  return;
}

export function multiply_then_divide_ (
  _pool: Pool,
  x: U64,
  y: U64,
  z: U64,
  $c: AptosDataCache,
): U64 {
  let result;
  result = ((to_u128_($.copy(x), $c)).mul(to_u128_($.copy(y), $c))).div(to_u128_($.copy(z), $c));
  return u64($.copy(result));
}

export function redeem_shares_ (
  pool: Pool,
  shareholder: HexString,
  shares_to_redeem: U64,
  $c: AptosDataCache,
): U64 {
  let temp$1, temp$2, temp$3, temp$4, temp$5, temp$6, redeemed_coins;
  [temp$1, temp$2] = [pool, $.copy(shareholder)];
  if (!contains_(temp$1, temp$2, $c)) {
    throw $.abortCode(Error.invalid_argument_($.copy(ESHAREHOLDER_NOT_FOUND), $c));
  }
  [temp$3, temp$4] = [pool, $.copy(shareholder)];
  if (!(shares_(temp$3, temp$4, $c)).ge($.copy(shares_to_redeem))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINSUFFICIENT_SHARES), $c));
  }
  if (($.copy(shares_to_redeem)).eq((u64("0")))) {
    return u64("0");
  }
  else{
  }
  [temp$5, temp$6] = [pool, $.copy(shares_to_redeem)];
  redeemed_coins = shares_to_amount_(temp$5, temp$6, $c);
  pool.total_coins = ($.copy(pool.total_coins)).sub($.copy(redeemed_coins));
  pool.total_shares = ($.copy(pool.total_shares)).sub($.copy(shares_to_redeem));
  deduct_shares_(pool, $.copy(shareholder), $.copy(shares_to_redeem), $c);
  return $.copy(redeemed_coins);
}

export function shareholders_ (
  pool: Pool,
  $c: AptosDataCache,
): HexString[] {
  return $.copy(pool.shareholders);
}

export function shareholders_count_ (
  pool: Pool,
  $c: AptosDataCache,
): U64 {
  return Vector.length_(pool.shareholders, $c, [AtomicTypeTag.Address]);
}

export function shares_ (
  pool: Pool,
  shareholder: HexString,
  $c: AptosDataCache,
): U64 {
  let temp$1;
  if (contains_(pool, $.copy(shareholder), $c)) {
    temp$1 = $.copy(Simple_map.borrow_(pool.shares, shareholder, $c, [AtomicTypeTag.Address, AtomicTypeTag.U64]));
  }
  else{
    temp$1 = u64("0");
  }
  return temp$1;
}

export function shares_to_amount_ (
  pool: Pool,
  shares: U64,
  $c: AptosDataCache,
): U64 {
  return shares_to_amount_with_total_coins_(pool, $.copy(shares), $.copy(pool.total_coins), $c);
}

export function shares_to_amount_with_total_coins_ (
  pool: Pool,
  shares: U64,
  total_coins: U64,
  $c: AptosDataCache,
): U64 {
  let temp$1, temp$2;
  if (($.copy(pool.total_coins)).eq((u64("0")))) {
    temp$1 = true;
  }
  else{
    temp$1 = ($.copy(pool.total_shares)).eq((u64("0")));
  }
  if (temp$1) {
    temp$2 = u64("0");
  }
  else{
    temp$2 = multiply_then_divide_(pool, $.copy(shares), $.copy(total_coins), $.copy(pool.total_shares), $c);
  }
  return temp$2;
}

export function to_u128_ (
  num: U64,
  $c: AptosDataCache,
): U128 {
  return u128($.copy(num));
}

export function total_coins_ (
  pool: Pool,
  $c: AptosDataCache,
): U64 {
  return $.copy(pool.total_coins);
}

export function total_shares_ (
  pool: Pool,
  $c: AptosDataCache,
): U64 {
  return $.copy(pool.total_shares);
}

export function transfer_shares_ (
  pool: Pool,
  shareholder_1: HexString,
  shareholder_2: HexString,
  shares_to_transfer: U64,
  $c: AptosDataCache,
): void {
  let temp$1, temp$2, temp$3, temp$4;
  [temp$1, temp$2] = [pool, $.copy(shareholder_1)];
  if (!contains_(temp$1, temp$2, $c)) {
    throw $.abortCode(Error.invalid_argument_($.copy(ESHAREHOLDER_NOT_FOUND), $c));
  }
  [temp$3, temp$4] = [pool, $.copy(shareholder_1)];
  if (!(shares_(temp$3, temp$4, $c)).ge($.copy(shares_to_transfer))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINSUFFICIENT_SHARES), $c));
  }
  if (($.copy(shares_to_transfer)).eq((u64("0")))) {
    return;
  }
  else{
  }
  deduct_shares_(pool, $.copy(shareholder_1), $.copy(shares_to_transfer), $c);
  add_shares_(pool, $.copy(shareholder_2), $.copy(shares_to_transfer), $c);
  return;
}

export function update_total_coins_ (
  pool: Pool,
  new_total_coins: U64,
  $c: AptosDataCache,
): void {
  pool.total_coins = $.copy(new_total_coins);
  return;
}

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