import { getModelForClass, DocumentType, modelOptions, mongoose, prop, Severity } from '@typegoose/typegoose'
import { BlockChain } from 'chain/BlockChain'
import { dbconn } from 'decorators/dbconn'
import logger from 'logger/logger'
import { BaseModule } from './Base'

export enum TaskType {
  UNKNOW = 0,
  MINT_FT = 1,
  MINT_NFT = 2,
  TRANSFER_FT = 3,
  TRANSFER_NFT = 4,
  MINT_PRESALE_BOX = 5,
}

export enum ReqTaskStatus {
  NOTSTART = 0,
  PEDING = 1,
  WAIT_CONFIRM = 2,
  SUCCESS = 3,
  REVERT = 8,
  ERROR = 9,
}

@dbconn()
@modelOptions({
  schemaOptions: { collection: 'chain_request_task', timestamps: true },
  options: { allowMixed: Severity.ALLOW },
})
export class RequestTaskClass extends BaseModule {
  @prop({ required: true })
  public taskId!: string

  @prop({ required: true })
  public chainTaskId!: string

  @prop({ enum: TaskType, default: TaskType.UNKNOW })
  public taskType: TaskType

  @prop({ required: true, default: 0 })
  public tryCount: number

  @prop({ required: true, default: 0 })
  public maxTryCount: number
  /**
   * address: string
   */
  @prop({ type: mongoose.Schema.Types.Mixed })
  public reqData: any

  @prop({ enum: ReqTaskStatus, default: ReqTaskStatus.NOTSTART })
  public status: ReqTaskStatus

  @prop({ required: true, default: true })
  public newRecord: boolean

  @prop()
  public startTime: number

  @prop()
  public endTime: number

  @prop()
  public txHash: string
  /**
   * 添加时的block num
   */
  @prop()
  public blockAdd: number
  /**
   * 请求时的block num
   */
  @prop()
  public blockReq: number

  @prop({ type: mongoose.Schema.Types.Mixed, default: [] })
  public errMsg: any[]

  public async requestChain(this: DocumentType<RequestTaskClass>) {
    let result
    let self = this
    self.blockReq = new BlockChain().currentBlockNum
    await self.save()

    switch (self.taskType) {
      case TaskType.MINT_FT:
        result = await new BlockChain().erc20Reactor.mint(self.reqData)
        break
      case TaskType.MINT_NFT:
        result = await new BlockChain().erc721Reactor.batchMint(self.reqData)
        break
      case TaskType.TRANSFER_FT:
        result = await new BlockChain().erc20Reactor.transfer(self.reqData)
        break
      case TaskType.TRANSFER_NFT:
        result = await new BlockChain().erc721Reactor.transfer(self.reqData)
        break
      case TaskType.MINT_PRESALE_BOX:
        result = await new BlockChain().erc721Reactor.mintOne(self.reqData)
        break
    }
    logger.info(result)
    let { transactionHash } = result
    self.txHash = transactionHash
    self.status = ReqTaskStatus.WAIT_CONFIRM
    await self.save()
  }

  public static async allUnFinishedTask(chainTaskId: string) {
    return RequestTask.find({ chainTaskId, status: { $ne: ReqTaskStatus.SUCCESS } })
  }
}

export const RequestTask = getModelForClass(RequestTaskClass, { existingConnection: RequestTaskClass['db'] })