export class ServiceNodeNotInSessionError extends Error {
  constructor(message: string, ...params: any[]) {
    super(...params)
    this.message = message
    this.name = 'ServiceNodeNotInSessionError'
  }
}

export class EmptyKeyManagerError extends Error {
  constructor(message: string, ...params: any[]) {
    super(...params)
    this.message = message
    this.name = 'EmptyKeyManagerError'
  }
}

export class NoServiceNodeError extends Error {
  constructor(message: string, ...params: any[]) {
    super(...params)
    this.message = message
    this.name = 'NoServiceNodeError'
  }
}

export enum PocketCoreErrorCodes {
  AppNotFoundError = 45,
  DuplicateProofError = 37,
  EmptyPayloadDataError = 25,
  EvidenceSealedError = 90,
  HTTPExecutionError = 28,
  InvalidBlockHeightError = 60,
  InvalidSessionError = 14,
  OutOfSyncRequestError = 75,
  OverServiceError = 71,
  RequestHashError = 74,
  UnsupportedBlockchainError = 76,
}

export class PocketCoreError extends Error {
  code: number
  message: string

  constructor(code: number, message: string, ...params: any[]) {
    super(...params)
    this.code = code
    this.message = message
  }
}

export class EmptyPayloadDataError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'EmptyPayloadError'
  }
}

export class RequestHashError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'RequestHashError'
  }
}

export class UnsupportedBlockchainError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'UnsupportedBlockchainError'
  }
}

export class InvalidBlockHeightError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'InvalidBlockHeightError'
  }
}

export class InvalidSessionError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'InvalidSessionError'
  }
}

export class AppNotFoundError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'AppNotFoundError'
  }
}

export class EvidenceSealedError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'EvidenceSealedError'
  }
}

export class DuplicateProofError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'DuplicateProofError'
  }
}

export class OutOfSyncRequestError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'OutOfSyncRequestError'
  }
}

export class OverServiceError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'OverServiceError'
  }
}

export class HTTPExecutionError extends PocketCoreError {
  constructor(code: number, message: string, ...params: any[]) {
    super(code, message, ...params)
    this.name = 'HTTPExecutionError'
  }
}

export function validateRelayResponse(relayResponse: any) {
  if ('response' in relayResponse && 'signature' in relayResponse) {
    return relayResponse.response
  }

  // probably an unhandled error
  if (!('response' in relayResponse) && !('error' in relayResponse)) {
    return relayResponse
  }

  switch (relayResponse.error.code) {
    case PocketCoreErrorCodes.AppNotFoundError:
      throw new AppNotFoundError(
        PocketCoreErrorCodes.AppNotFoundError,
        relayResponse.error.message ?? ''
      )
    case PocketCoreErrorCodes.DuplicateProofError:
      throw new DuplicateProofError(
        PocketCoreErrorCodes.DuplicateProofError,
        relayResponse.error.message
      )
    case PocketCoreErrorCodes.EmptyPayloadDataError:
      throw new EmptyPayloadDataError(
        PocketCoreErrorCodes.EmptyPayloadDataError,
        relayResponse.error.message
      )
    case PocketCoreErrorCodes.EvidenceSealedError:
      throw new EvidenceSealedError(
        PocketCoreErrorCodes.EvidenceSealedError,
        relayResponse.error.message
      )
    case PocketCoreErrorCodes.InvalidBlockHeightError:
      throw new InvalidBlockHeightError(
        PocketCoreErrorCodes.InvalidBlockHeightError,
        relayResponse.error.message
      )
    case PocketCoreErrorCodes.OutOfSyncRequestError:
      throw new OutOfSyncRequestError(PocketCoreErrorCodes.OutOfSyncRequestError,
        relayResponse.error.message)
    case PocketCoreErrorCodes.OverServiceError:
      throw new OverServiceError(
        PocketCoreErrorCodes.OverServiceError,
        relayResponse.error.message
      )
    case PocketCoreErrorCodes.RequestHashError:
      throw new RequestHashError(
        PocketCoreErrorCodes.RequestHashError,
        relayResponse.error.message
      )
    case PocketCoreErrorCodes.UnsupportedBlockchainError:
      throw new UnsupportedBlockchainError(
        PocketCoreErrorCodes.UnsupportedBlockchainError,
        relayResponse.error.message
      )
    case PocketCoreErrorCodes.HTTPExecutionError:
      throw new HTTPExecutionError(
        PocketCoreErrorCodes.HTTPExecutionError,
        relayResponse.error.message
      )
    case PocketCoreErrorCodes.InvalidSessionError:
      throw new InvalidSessionError(
        PocketCoreErrorCodes.InvalidSessionError,
        relayResponse.error.message
      )
    default:
      throw new PocketCoreError(
        relayResponse.error.code,
        relayResponse.error.message ?? ''
      )
  }
}