import {
  solCatAccountsCoder,
  v2AccountsCoder,
  AccountName,
  FlexibleVaultData,
  FlexibleVaultDataV2,
  LockupVaultData,
  LockupVaultDataV2,
  LockupStakingAccountData,
  LockupStakingAccountDataV2,
  ConfigData,
  ConfigDataV2
} from "../types";

/**
 * Static abstract class definition to parse entities.
 * @category Parsable
 */
export interface ParsableEntity<T> {
  /**
   * Parse account data
   *
   * @param accountData Buffer data for the entity
   * @returns Parsed entity
   */
  parse: (usingV2: boolean, accountData: Buffer | undefined | null) => T | null;
}

/**
 * Class decorator to define an interface with static methods
 * Reference: https://github.com/Microsoft/TypeScript/issues/13462#issuecomment-295685298
 */
function staticImplements<T>() {
  return <U extends T>(constructor: U) => {
    constructor;
  };
}

function parseAnchorAccount(usingV2: boolean, accountName: AccountName, data: Buffer) {
  const coder = usingV2 ? v2AccountsCoder : solCatAccountsCoder;
  const discriminator = coder.accountDiscriminator(accountName);
  if (discriminator.compare(data.subarray(0, 8))) {
    console.error("incorrect account name during parsing");
    return null;
  }

  try {
    return coder.decode(accountName, data);
  } catch (_e) {
    console.error("unknown account name during parsing");
    return null;
  }
}

// YOUR ACCOUNTS
@staticImplements<ParsableEntity<ConfigData | ConfigDataV2>>()
export class ParsableConfig {
  private constructor() { }

  public static parse(usingV2: boolean, data: Buffer | undefined | null): ConfigData | ConfigDataV2 | null {
    if (!data) {
      return null;
    }

    try {
      return parseAnchorAccount(usingV2, AccountName.Config, data);
    } catch (e) {
      console.error(`error while parsing Config: ${e}`);
      return null;
    }
  }
}

@staticImplements<ParsableEntity<FlexibleVaultData | FlexibleVaultDataV2>>()
export class ParsableFlexibleVault {
  private constructor() { }

  public static parse(usingV2: boolean, data: Buffer | undefined | null): FlexibleVaultData | FlexibleVaultDataV2 | null {
    if (!data) {
      return null;
    }

    try {
      return parseAnchorAccount(usingV2, AccountName.FlexibleVault, data);
    } catch (e) {
      console.error(`error while parsing Flexible Vault: ${e}`);
      return null;
    }
  }
}

@staticImplements<ParsableEntity<LockupVaultData | LockupVaultDataV2>>()
export class ParsableLockupVault {
  private constructor() { }

  public static parse(usingV2: boolean, data: Buffer | undefined | null): LockupVaultData | LockupVaultDataV2 | null {
    if (!data) {
      return null;
    }

    try {
      return parseAnchorAccount(usingV2, AccountName.LockupVault, data);
    } catch (e) {
      console.error(`error while parsing Lockup Vault: ${e}`);
      return null;
    }
  }
}

@staticImplements<ParsableEntity<LockupStakingAccountData | LockupStakingAccountDataV2>>()
export class ParsableLockupStakingAccount {
  private constructor() { }

  public static parse(usingV2: boolean, data: Buffer | undefined | null): LockupStakingAccountData | LockupStakingAccountDataV2 | null {
    if (!data) {
      return null;
    }

    try {
      return parseAnchorAccount(usingV2, AccountName.LockupStakingAccount, data);
    } catch (e) {
      console.error(`error while parsing Lockup Staking Account: ${e}`);
      return null;
    }
  }
}