import { Column, DataType, HasMany, Model, Table } from 'sequelize-typescript';

import { accountType } from '../utils/enums';
import { IAddressBlockingData, IAddressBook } from '../utils/interfaces';
import { Balance } from './balance';
import { Check } from './check';
import { Coin } from './coin';
import { MultisendTx } from './multisendTx';
import { Multisig } from './multisig';
import { MultisigSign } from './multisigSign';
import { MultisigTx } from './multisigTx';
import { Nft } from './nft';
import { NftReserve } from './nftReserve';
import { Reward } from './reward';
import { Stake } from './stake';
import { StakeNft } from './stakeNft';
import { SwapMultiple } from './swapMultiple';
import { Tx } from './tx';
import { Validator } from './validator';

@Table({
  defaultScope: {
    attributes: {
      exclude: ['blockingData'],
    },
  },
})
export class Address extends Model {
  @Column({ type: DataType.INTEGER, autoIncrement: true, primaryKey: true })
  id: number;

  @Column({ type: DataType.STRING, unique: true })
  address: string;

  @Column(DataType.ENUM({ values: Object.values(accountType) }))
  type: accountType;

  @Column({ type: DataType.JSONB, allowNull: true, defaultValue: null })
  addressBook: IAddressBook;

  @Column(DataType.INTEGER)
  nonce: number;

  @Column(DataType.INTEGER)
  txes: number;

  @Column({ type: DataType.ARRAY(DataType.INTEGER), allowNull: true, defaultValue: null })
  generatedWallets: number[];

  @Column({ type: DataType.JSONB, allowNull: true, defaultValue: null })
  blockingData: IAddressBlockingData;

  // associations
  @HasMany(() => Reward)
  rewards: Reward[];

  @HasMany(() => Balance)
  balances: Balance[];

  @HasMany(() => Stake)
  stakes: Stake[];

  @HasMany(() => StakeNft)
  stakeNfts: StakeNft[];

  @HasMany(() => Tx)
  txs: Tx[];

  @HasMany(() => Multisig, 'addressId')
  addressesMultisig: Multisig[];

  @HasMany(() => Multisig, 'creatorId')
  multisigs: Multisig[];

  @HasMany(() => NftReserve)
  nftsReserve: NftReserve[];

  @HasMany(() => Coin)
  coins: Coin[];

  @HasMany(() => Validator)
  rewardAddresses: Validator[];

  @HasMany(() => Check, 'issuerId')
  checkIssueries: Check[];

  @HasMany(() => Check, 'recipientId')
  checkResipients: Check[];

  @HasMany(() => MultisendTx)
  multisendTxes: MultisendTx[];

  @HasMany(() => MultisigTx)
  multisigTxes: MultisigTx[];

  @HasMany(() => Nft)
  nftModels: Nft[];

  @HasMany(() => MultisigSign)
  multisigSigns: MultisigSign[];

  @HasMany(() => SwapMultiple, 'senderId')
  swapsCreator: SwapMultiple[];

  @HasMany(() => SwapMultiple, 'fromId')
  swapsSender: SwapMultiple[];

  @HasMany(() => SwapMultiple, 'recipientId')
  swapsRecipient: SwapMultiple[];
}