export class VerifyJwtService implements VerifyJwtOutboundPort {
  constructor(
    private readonly jwtService: JwtService,
    @Inject(DECODE_JWT_OUTBOUND_PORT)
    private readonly decodJwtOutboundPort: DecodeJwtOutboundPort,
    @Inject(FIND_ACCOUNT_EMAIL_JOIN_TYPE_OUTBOUND_PORT)
    private readonly findAccountEmailJoinTypeOutboundPort: FindAccountEmainJoinTypeOutboundPort,
    @Inject(LOGOUT_ACCOUNT_INBOUND_PORT)
    private readonly logoutAccountInboundPort: LogoutAccountInboundPort,
    @Inject(CREATE_JWT_OUTBOUND_PORT)
    private readonly createJwtOutboundPort: CreateJwtOutboundPort
  ) {}

  async excute(params: VerifyJwtInputDto) {
    try {
      params.tokenType === JWT_TYPE.ACCESS_TOKEN
        ? await this.verifyAccessJwt(params.jwt)
        : await this.verifyRefreshJwt(params.jwt)
    } catch (e) {
      throw e
    }
  }

  private async verifyAccessJwt(jwt: string) {
    try {
      this.jwtService.verify(jwt, {
        secret: process.env.JWT_ACCESS_SECRET_KEY,
        audience: getJwtAudience(),
        issuer: getJwtIssuer(JWT_TYPE.ACCESS_TOKEN),
      } as JwtVerifyOptions)
    } catch (e) {
      const validResult = this.tokenExceptionHandler(
        e,
        jwt,
        JWT_TYPE.ACCESS_TOKEN
      )

      if (validResult instanceof AuthException) {
        throw validResult
      }

      //고민 포인트 01
      //액세스 토큰에서 만료가 되면 리프래시 토큰을 검증한다.
      //큰 문제 없다면 AccessToken을 다시 전달한다.
      //이 부분에는 거의 10~20줄 짜리 코드 로직이 들어갔었다.
    }
  }

  /**
   * 리프레시 토큰 검증  고민포인트 02
   * @param jwt
   */
  private async verifyRefreshJwt(jwt: string) {
    try {
      this.jwtService.verify(jwt, {
        secret: process.env.JWT_REFRESH_SECRET_KEY,
        audience: getJwtAudience(),
        issuer: getJwtIssuer(JWT_TYPE.REFRESH_TOKEN),
      } as JwtVerifyOptions)
    } catch (e) {
      //고민 포인트 03
      //리프레시 만료시에 대한 처리 로직
    }
  }

  /**
   * 토큰 예외 공통 처리 핸들러
   * @param e
   * @param jwt
   * @param tokenType
   * @returns
   */
  private tokenExceptionHandler(
    e: Error,
    jwt: string,
    tokenType: JwtType
  ): boolean | AuthException {
    //토큰 만료 시
    if (e instanceof TokenExpiredError) {
      console.log('[tokenExceptionHandler] : TokenExpiredError')
      // return true;
      return new AuthException(AuthJwtErrorCode.jwtExpired(jwt, tokenType))
    }
    // payload가 잘 못 되었을 때 (base64 decode가 안되는 경우 등)
    else if (e instanceof SyntaxError) {
      console.log('[tokenExceptionHandler] : Syntax')
      // throw new AuthException(AuthJwtErrorCode.jwtInvalid(jwt, tokenType));
      return new AuthException(AuthJwtErrorCode.jwtInvalid(jwt, tokenType))
    }

    // JwtWebTokenError should be later than TokenExpiredError
    //보통 토큰의 시크릿 코드가 변경되었는데 구형 키 값을 사용하여 만들어진 JWT를 사용할 경우 발생
    else if (e instanceof JsonWebTokenError) {
      console.log('[tokenExceptionHandler] : JsonWebTokenError')
      // throw new AuthException(AuthJwtErrorCode.invalidTokenOrInvalidSignature(jwt));
      return new AuthException(
        AuthJwtErrorCode.invalidTokenOrInvalidSignature(jwt, tokenType)
      )
    }

    //그 외 기타 에러
    //기타 에러
    return new AuthException(AuthJwtErrorCode.jwtEtcError(jwt, tokenType))
  }
}

@Injectable()
export class AccessJwtStrategy extends PassportStrategy(Strategy, 'jwt') {
  constructor(
    @Inject(VERIFY_JWT_OUTBOUND_PORT)
    private readonly verifyjwtOutboundPort: VerifyJwtOutboundPort,
    @Inject(DECODE_JWT_OUTBOUND_PORT)
    private readonly decodJwtOutboundPort: DecodeJwtOutboundPort,
    @Inject(CREATE_JWT_OUTBOUND_PORT)
    private readonly createJwtOutboundPort: CreateJwtOutboundPort,
    @Inject(FIND_ACCOUNT_EMAIL_JOIN_TYPE_OUTBOUND_PORT)
    private readonly findAccountEmailJoinTypeOutboundPort: FindAccountEmainJoinTypeOutboundPort,
    @Inject(LOGOUT_ACCOUNT_INBOUND_PORT)
    private readonly logoutAccountInboundPort: LogoutAccountInboundPort
  ) {
    super()
  }

  async validate(req: Request, payload: any) {
    const jwt = req.header('testAuth')

    if (!jwt) {
      throw new AuthException(AuthJwtErrorCode.jwtNotFound())
    }

    try {
      await this.verifyjwtOutboundPort.excute({
        jwt,
        tokenType: JWT_TYPE.ACCESS_TOKEN,
      })
    } catch (e) {
      if (e instanceof AuthException) {
        //Access Jwt 만료된 경우
        if (e.errorCode === ERROR_CODE_JWT_EXPIRED) {
          const validResult: boolean = await this.validRefreshJwt(account)
          //이후 로직 처리
        }
      } else {
        throw e
      }
    }
    return payload
  }
}