@ApiTags('auth')
@Controller('auth')
export class AuthController {
  @Post('register')
  @ApiResponseEntity({
    type: AuthSignUserOutDto,
    summary: '회원가입 및 로그인',
  })
  async register(
    @Body() authSignUserInDto: AuthSignUserInDto,
  ): Promise<ResponseEntity<AuthSignUserOutDto>> {
    const authSignUserOutDto =
      await this.authService.register(authSignUserInDto);

    return ResponseEntity.ok().body(authSignUserOutDto);
  }
  
  @Get('jwt-validator')
  @ApiResponseEntity({ type: UserDto, summary: 'jwt 유효성 검증' })
  @ApiBearerAuth('jwt')
  @UseGuards(JwtAuthGuard)
  async jwtValidator(@CurrentUser() user: JwtPayload): Promise<ResponseEntity<JwtPayload>> {
    return ResponseEntity.ok().body(user);
  }

  @Post('refresh')
  @ApiResponseEntity({ type: AuthSignUserOutDto, summary: '토큰 갱신' })
  @ApiBearerAuth('jwt-refresh')
  @UseGuards(JwtRefreshAuthGuard)
  async refreshToken(
    @CurrentUser() user: User,
  ): Promise<ResponseEntity<AuthSignUserOutDto>> {
    const authSignUserOutDto = await this.authService.refreshToken(user);

    return ResponseEntity.ok().body(authSignUserOutDto);
  }
}

@ApiTags('auth')
@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  /**
   * API 인증
   * */
  @Post('api-key')
  @ApiResponseEntity({ type: GetApiKeyOutDto, summary: '1분 api key 발급' })
  async getApiKey(): Promise<ResponseEntity<GetApiKeyOutDto>> {
    const getApiKeyOutDto = this.authService.getApiKey();

    return ResponseEntity.ok().body(getApiKeyOutDto);
  }

  @Post('api-key-validator')
  @ApiResponseEntity({ type: GetApiKeyOutDto, summary: '1분 api key 발급' })
  @ApiSecurity('apiKey')
  @UseGuards(ApiKeyAuthGuard)
  async apiKeyValidator(): Promise<ResponseEntity<string>> {
    return ResponseEntity.ok().body('유효한 api key 확인 완료');
  }
}

@ApiTags('auth')
@Controller('auth')
export class AuthController {
  /**
   * OAUTH 인증 - Firebase 방식
   * */
  @Post('google/firebase/login')
  @ApiResponseEntity({
    type: AuthSignUserOutDto,
    summary: 'Firebase Google 로그인',
  })
  async googleFirebaseLogin(
    @Body() googleFirebaseLoginInDto: GoogleFirebaseLoginInDto,
  ): Promise<ResponseEntity<AuthSignUserOutDto>> {
    const authSignUserOutDto = await this.authService.googleLoginWithIdToken(
      googleFirebaseLoginInDto.idToken,
    );

    return ResponseEntity.ok().body(authSignUserOutDto);
  }

  /**
   * OAUTH 인증 - Google OAuth 2.0 직접 구현
   * */
  @Post('google/oauth/login')
  @ApiResponseEntity({
    type: AuthSignUserOutDto,
    summary: 'Google OAuth 2.0 직접 로그인',
  })
  async googleOAuthLogin(
    @Body() googleOauthLoginInDto: GoogleOauthLoginInDto,
  ): Promise<ResponseEntity<AuthSignUserOutDto>> {
    const authSignUserOutDto = await this.authService.googleLoginWithCode(
      googleOauthLoginInDto.code,
    );

    return ResponseEntity.ok().body(authSignUserOutDto);
  }
}

@ApiTags('auth')
@Controller('auth')
export class AuthController {
  /**
   * RBAC 권한 관리
   */
  @Put('role')
  @ApiResponseEntity({ type: UserDto, summary: '관리자 권한 변경' })
  @ApiBearerAuth('jwt')
  @UseGuards(JwtAuthGuard)
  async updateRole(
    @Body() updateRoleUserDto: UpdateRoleUserDto,
  ): Promise<ResponseEntity<AuthSignUserOutDto>> {
    const authSignUserOutDto = await this.authService.updateRole(updateRoleUserDto);
    return ResponseEntity.ok().body(authSignUserOutDto);
  }
}

@Module({
  imports: [
    ThrottlerModule.forRoot({
      throttlers: [
        {
          ttl: 60000,        // 1분
          limit: 10,         // 10번 요청
        },
      ],
      storage: new RedisThrottlerStorage(),
    }),
    providers: [
      // { provide: APP_GUARD, useClass: ThrottlerGuard }, // 개별 적용으로 변경
    ],
  ],
})
export class ApiModule {}

export class NestedObjectDto {
  @ApiProperty()
  @IsString()
  @Length(1, 50)
  string: string;

  @ApiProperty()
  @IsNumber()
  @Min(0)
  @Max(100)
  number: number;
}

export const VALIDATION_CONST_ENUM = {
  None: 0,
  Test: 1,
  Live: 2,
};
export type ValidationConstEnum =
  (typeof VALIDATION_CONST_ENUM)[keyof typeof VALIDATION_CONST_ENUM];

export class ValidationInDto {
  // 기본 문자열 검증
  @ApiProperty({ description: '기본 문자열 (1-50자)' })
  @IsString()
  @IsOptional()
  @Length(1, 50)
  string?: string;

  // 이메일 검증
  @ApiProperty({ description: '이메일 형식' })
  @IsEmail()
  @IsOptional()
  email?: string;

  // 숫자 검증
  @ApiProperty({ description: '양수 (1-100)' })
  @IsNumber()
  @IsOptional()
  @Min(1)
  @Max(100)
  number?: number;

  // 불린 검증
  @ApiProperty({ description: '불린 값' })
  @IsBoolean()
  @IsOptional()
  boolean?: boolean;

  // URL 검증
  @ApiProperty({ description: 'URL 형식', required: false })
  @IsOptional()
  @IsUrl()
  url?: string | null;

  // 날짜 문자열 검증
  @ApiProperty({ description: '날짜 문자열 (ISO)', required: false })
  @IsOptional()
  @IsDateString()
  date?: string | null;

  // 열거형 검증
  @ApiProperty({ description: '역할 선택', enum: ['ADMIN', 'USER', 'GUEST'] })
  @IsIn(['ADMIN', 'USER', 'GUEST'])
  @IsOptional()
  in?: string;

  // 상수 열거형 검증
  @ApiProperty({
    description: constToString(VALIDATION_CONST_ENUM, 'VALIDATION_CONST_ENUM'),
  })
  @IsNumber()
  @IsOptional()
  @Validate(ConstantsValidator, [VALIDATION_CONST_ENUM])
  constEnum?: ValidationConstEnum;

  // 배열 검증
  @ApiProperty({ description: '문자열 배열', type: [String] })
  @IsArray()
  @IsOptional()
  @IsString({ each: true })
  @Length(1, 20, { each: true })
  array?: string[];

  // 중첩 객체 검증
  @ApiProperty({ description: '중첩 객체', type: NestedObjectDto })
  @IsObject()
  @IsOptional()
  @ValidateNested()
  @Type(() => NestedObjectDto)
  object?: NestedObjectDto;

  // 중첩 객체 배열 검증
  @ApiProperty({ description: '중첩 객체 배열', type: [NestedObjectDto] })
  @IsArray()
  @IsOptional()
  @ValidateNested({ each: true })
  @Type(() => NestedObjectDto)
  objectArray?: NestedObjectDto[];
}

@Controller('auth')
export class AuthController {
  /**
   * sql injection
   */
  @Post('sql-injection')
  @ApiResponseEntity({ summary: 'sql-injection' })
  async sqlInjection(
    @Body() sqlInjectionInDto: SqlInjectionInDto,
  ): Promise<ResponseEntity<unknown>> {
    await this.authService.sqlInjection(sqlInjectionInDto.query);
    return ResponseEntity.ok().build();
  }
}