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

import { IEvmContractVerificationData, IExtraData } from '../utils/interfaces';
import { ContractStatus} from '../utils/enums';
import { EvmAccount } from './evmAccount';
import { EvmBlock } from './evmBlock';
import { EvmReceipt } from './evmReceipt';
import { EvmToken } from './evmToken';
import { EvmTokenEvent } from './evmTokenEvent';
import { EvmTransaction } from './evmTransaction';

@Table({ timestamps: true })
export class EvmContract extends Model<EvmContract> {
  @Index({
    name: 'evmContract-address-index',
    using: 'HASH',
    unique: true,
  })
  @Column({ type: DataType.STRING })
  address: string;

  @Column({
    type: DataType.ENUM({ values: Object.values(ContractStatus) }),
    defaultValue: ContractStatus.CREATED,
    allowNull: false,
  })
  status: ContractStatus;

  @Column(DataType.STRING(128))
  title: string;

  @Column({ type: DataType.JSONB, allowNull: true, defaultValue: null })
  abi: IExtraData[];

  @Column(DataType.TEXT)
  byteCode: string;

  @Column(DataType.TEXT)
  sourceCode: string;

  @Column(DataType.TEXT)
  securityAudit: string;

  @Column(DataType.STRING)
  swarmSource: string;

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

  // relations M-1
  @Index({
    name: 'evmContract-EvmAccount-index',
    using: 'HASH',
  })
  @ForeignKey(() => EvmAccount)
  @Column(DataType.INTEGER)
  deploymentEvmAccountId: number;

  @ForeignKey(() => EvmBlock)
  @Column(DataType.INTEGER)
  deploymentEvmBlockHeight: number;

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

  @ForeignKey(() => EvmReceipt)
  @Column(DataType.INTEGER)
  deploymentEvmReceiptId: number;

  @BelongsTo(() => EvmAccount, {
    foreignKey: 'deploymentEvmAccountId',
    constraints: false,
  })
  deploymentAccount: EvmAccount;

  @BelongsTo(() => EvmBlock, {
    foreignKey: 'deploymentEvmBlockHeight',
    constraints: false,
  })
  deploymentEvmBlock: EvmBlock;

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

  @BelongsTo(() => EvmReceipt, {
    foreignKey: 'deploymentEvmReceiptId',
    constraints: false,
  })
  deploymentEvmReceipt: EvmReceipt;

  // relations 1-1
  @ForeignKey(() => EvmAccount)
  @Column(DataType.INTEGER)
  evmAccountId: number;

  @BelongsTo(() => EvmAccount, 'evmAccountId') evmAccount: EvmAccount;

  @HasOne(() => EvmToken, { foreignKey: 'evmContractId' })
  evmToken: EvmToken;

  // relations 1-M
  @HasMany(() => EvmReceipt, { foreignKey: 'evmContractId' })
  evmReceipts: EvmReceipt[];

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

  @Column(DataType.BOOLEAN)
  parse_abi: boolean;
}