import { getModelForClass, DocumentType, modelOptions, mongoose, prop, Severity, index } 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,
  PUBLISH_AIRDROP_LIST = 5,
}

export const TaskTypeMap = new Map([
  [TaskType.UNKNOW, 'Unknow'],
  [TaskType.MINT_FT, 'Mint Ft'],
  [TaskType.MINT_NFT, 'Mint NFT'],
  [TaskType.TRANSFER_FT, 'Ft转账'],
  [TaskType.TRANSFER_NFT, 'NFT转账'],
  [TaskType.PUBLISH_AIRDROP_LIST, '公布空投名单'],
])

export enum ReqTaskStatus {
  NOTSTART = 0,
  PEDING = 1,
  WAIT_CONFIRM = 2, // 加入合约schedule后, 等待状态确认
  WAIT_EXEC = 3, // 等待执行
  WAIT_EXEC_CONFIRM = 4, // 等待执行后的状态确认
  SUCCESS = 5,
  SCHEDULE_REVERT = 8,
  EXEC_REVERT = 9,
  ERROR = 99,
}

@dbconn()
@index({ scheduleId: 1 }, { unique: true })
@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({ default: 0 })
  public index: number

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

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

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

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

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

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

  @prop()
  public startTime: number

  @prop()
  public endScheduleTime: number

  @prop()
  public endExecTime: number

  //begin for schedule
  @prop()
  public scheduleId: string

  @prop({ type: () => [String] })
  public targets: string[]

  @prop({ type: () => [String] })
  public datas: string[]

  @prop({ type: () => [String] })
  public values: string[]

  @prop()
  public predecessor: string

  @prop()
  public salt: string
  //end for schedule

  @prop()
  public txHash: string

  @prop()
  public execHash: 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 self = this
    self.blockReq = new BlockChain().currentBlockNum
    await self.save()
    let result = await new BlockChain().walletReactor.beginSchedule(self, 60)
    logger.info(result)
    let { transactionHash } = result
    self.txHash = transactionHash
    self.status = ReqTaskStatus.WAIT_CONFIRM
    await self.save()
  }

  public async execSchdule(this: DocumentType<RequestTaskClass>) {
    let self = this
    let result = await new BlockChain().walletReactor.executeSchedule(self)
    logger.info('schedule exec result:')
    logger.info(result)
    let { transactionHash } = result
    self.execHash = transactionHash
    self.status = ReqTaskStatus.WAIT_EXEC_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'] })