import {
  BelongsTo,
  BelongsToMany,
  Column,
  DataType,
  ForeignKey,
  HasMany,
  HasOne,
  Index,
  Model,
  Scopes,
  Table,
} from 'sequelize-typescript';

import { EvmAccountERC20TokenBalance } from './evmAccountERC20TokenBalance';
import { EvmAccountERC721TokenBalance } from './evmAccountERC721TokenBalance';
import { EvmAccountERC1155TokenBalance } from './evmAccountERC1155TokenBalance';
import { EvmBlock } from './evmBlock';
import { EvmContract } from './evmContract';
import { EvmToken } from './evmToken';
import { EvmTokenEvent } from './evmTokenEvent';
import { EvmTransaction } from './evmTransaction';

@Scopes(() => ({
  defaultScope: {
    attributes: {
      exclude: ['createdAt', 'updatedAt'],
    },
  },
}))
@Table
export class EvmAccount extends Model<EvmAccount> {
  @Index({
    name: 'evmAccount-address-index',
    using: 'HASH',
  })
  @Column({ type: DataType.STRING })
  address: string;

  // relations M-1
  @ForeignKey(() => EvmBlock)
  @Column(DataType.INTEGER)
  creationEvmBlockHeight: number;

  @ForeignKey(() => EvmTransaction)
  @Column(DataType.INTEGER)
  creationEvmTransactionId: number;

  @BelongsTo(() => EvmBlock, 'creationEvmBlockHeight') creationEvmBlock: EvmBlock;

  @BelongsTo(() => EvmTransaction, {
    foreignKey: 'creationEvmTransactionId',
    constraints: false,
  })
  creationEvmTransaction: EvmTransaction;

  // relations 1-M
  @HasMany(() => EvmTransaction, { foreignKey: 'fromAccountId' })
  evmTransactionsFrom: EvmTransaction[];

  @HasMany(() => EvmTransaction, { foreignKey: 'toAccountId' })
  evmTransactionsTo: EvmTransaction[];

  @HasMany(() => EvmContract, { foreignKey: 'deploymentEvmAccountId', constraints: false })
  deployedEvmContracts: EvmContract[];

  @HasMany(() => EvmTokenEvent, { foreignKey: 'fromAccountId' })
  evmTokenEventsFrom: EvmTokenEvent[];

  @HasMany(() => EvmTokenEvent, { foreignKey: 'toAccountId' })
  evmTokenEventsTo: EvmTokenEvent[];

  @HasMany(() => EvmTokenEvent, { foreignKey: 'operatorAccountId' })
  evmTokenEventsOperator: EvmTokenEvent[];

  @BelongsToMany(() => EvmToken, () => EvmAccountERC20TokenBalance)
  evmTokenBalances: EvmToken[];

  @HasMany(() => EvmAccountERC20TokenBalance)
  evmAccountERC20TokenBalances: EvmAccountERC20TokenBalance[];

  @HasMany(() => EvmAccountERC721TokenBalance)
  evmAccountERC721TokenBalances: EvmAccountERC721TokenBalance[];

  @HasMany(() => EvmAccountERC1155TokenBalance)
  evmAccountERC1155TokenBalances: EvmAccountERC1155TokenBalance[];

  // relations 1-1
  @HasOne(() => EvmContract, { foreignKey: 'deploymentEvmAccountId' })
  evmContract: EvmContract;
}