import {
   Injectable,
   NestInterceptor as INestInterceptor,
   ExecutionContext,
   CallHandler   
} from "@nestjs/common"

import { Observable } from "rxjs"
import { map } from "rxjs/operators"

const ObservableToPromise = <T=any>(observable:Observable<T>):Promise<T> => {
   return new Promise((res,rej)=>{
      observable.subscribe({
         next:val=>{ res(val) },
         error:err=>{ rej(err) }
      })
   })
}

export interface NestInterceptorBeforeHanlder {
   (context:ExecutionContext):Promise<void>
}

export interface NestInterceptorResponseHandler<T> {
   (response:any):Promise<T>
}


@Injectable()
export class NestInterceptor<ResponseType=any> implements INestInterceptor<any,ResponseType>{

   private beforeHandlerList:NestInterceptorBeforeHanlder[] = []

   private responseHandler:NestInterceptorResponseHandler<ResponseType>|null = null

   public async intercept(context:ExecutionContext,next:CallHandler):Promise<Observable<ResponseType>> {
      if ( this.beforeHandlerList.length > 0 ) {
         for ( let handle of this.beforeHandlerList.values() ) {
            await handle(context)
         }
      }
      if ( this.responseHandler === null ) {
         return next.handle()
      } else {
         let observableValue = await ObservableToPromise(next.handle())
         let response = await this.responseHandler(observableValue)
         return next.handle().pipe(
            map(val=>response)
         )
      }
   }

   public addBeforeHandler(handler:NestInterceptorBeforeHanlder):this {
      this.beforeHandlerList.push(handler)
      return this
   }

   public setReponseHandler(handler:NestInterceptorResponseHandler<ResponseType>):this {
      this.responseHandler = handler
      return this
   }

}