import { Body, Controller, Get, Post, Put, Query, Req } from '@nestjs/common';
import { ApiBearerAuth, ApiOkResponse, ApiTags } from '@nestjs/swagger';

import { User } from './database/entities';
import { FunkiIdDiscordService } from './funki-id-discord.service';
import { FunkiIdEvmService } from './funki-id-evm.service';
import { FunkiIdRedditService } from './funki-id-reddit.service';
import { FunkiIdSteamService } from './funki-id-steam.service';
import { FunkiIdTelegramService } from './funki-id-telegram.service';
import { FunkiIdXService } from './funki-id-x.service';
import {
  CustomTokenResponse,
  DiscordAuthorizeDto,
  EvmAuthDto,
  EvmAuthResponse,
  EvmValidateAuthDto,
  GetWaitListUsersDto,
  GetWaitListUsersResponse,
  OnboardDto,
  OnboardWalletDto,
  RedditAuthorizeDto,
  SetUsernameDto,
  TelegramAuthorizeRequest,
} from './funki-id.dto';
import { AuthUser, Roles, UseFunkiIdGuard, UserRole } from './funki-id.guard';
import { FunkiIdService } from './funki-id.service';
import { ConfirmDeleteRequestDto, ConfirmReactivateRequestDto } from './modules/delete/delete.dto';
import { UserDeleteService } from './modules/delete/delete.service';

@Controller('funki-id')
@ApiTags('Funki ID')
@UseFunkiIdGuard()
@ApiBearerAuth()
export class FunkiIdController {
  constructor(
    private readonly funkiIdEvmService: FunkiIdEvmService,
    private readonly funkiIdService: FunkiIdService,
    private readonly funkiIdTelegramService: FunkiIdTelegramService,
    private readonly funkiIdDiscordService: FunkiIdDiscordService,
    private readonly funkiIdSteamService: FunkiIdSteamService,
    private readonly funkiIdRedditService: FunkiIdRedditService,
    private readonly funkiIdXService: FunkiIdXService,
    private readonly deleteService: UserDeleteService,
  ) {}

  @Post('/evm/initiate')
  @Roles(UserRole.EVERYONE)
  @ApiOkResponse({ type: EvmAuthResponse })
  async generateMessage(@Body() body: EvmAuthDto) {
    return this.funkiIdEvmService.generateMessage(body.publicKey, body.type);
  }

  @Post('/evm/validate')
  @Roles(UserRole.EVERYONE)
  @ApiOkResponse({ type: CustomTokenResponse })
  async validateAuthSignature(@AuthUser() user: User, @Body() body: EvmValidateAuthDto) {
    return this.funkiIdEvmService.authenticateWithSignature(user ?? null, body);
  }

  @Post('/evm/unlink')
  @ApiOkResponse({ type: Boolean })
  async unlinkWallet(@AuthUser() user: User, @Body() body: EvmValidateAuthDto) {
    return this.funkiIdEvmService.unlinkWallet(user, body);
  }

  @Get('/me')
  @ApiOkResponse({ type: User })
  async me(@AuthUser() user: User) {
    return this.funkiIdService.me(user.uid);
  }

  @Post('/telegram/authorize')
  @Roles(UserRole.EVERYONE)
  @ApiOkResponse({ type: CustomTokenResponse })
  async authorizeTelegram(@Body() body: TelegramAuthorizeRequest, @AuthUser() user: User) {
    return this.funkiIdTelegramService.authorize(body, user);
  }

  @Put('/username')
  @ApiOkResponse({ type: User })
  async updateName(@AuthUser() user: User, @Body() body: SetUsernameDto) {
    return this.funkiIdService.updateName(user, body.username);
  }

  @Post('/discord/authorize')
  @Roles(UserRole.EVERYONE)
  @ApiOkResponse({ type: CustomTokenResponse })
  async authorizeDiscord(@Body() body: DiscordAuthorizeDto, @AuthUser() user: User) {
    return this.funkiIdDiscordService.authorize(body, user);
  }

  @Post('/steam/get-auth-url')
  @Roles(UserRole.EVERYONE)
  @ApiOkResponse({ type: String })
  async getSteamAuthUrl() {
    return this.funkiIdSteamService.getAuthUrl();
  }

  @Get('/steam/authorize')
  @Roles(UserRole.EVERYONE)
  @ApiOkResponse({ type: CustomTokenResponse })
  async authorizeSteam(@Req() req: Request, @AuthUser() user: User) {
    return this.funkiIdSteamService.authorize(req.url, user);
  }

  @Post('/reddit/authorize')
  @Roles(UserRole.EVERYONE)
  @ApiOkResponse({ type: CustomTokenResponse })
  async authorizeReddit(@Body() body: RedditAuthorizeDto, @AuthUser() user: User) {
    return this.funkiIdRedditService.authorize(body, user);
  }

  @Post('/x/authorize')
  @Roles(UserRole.AUTHENTICATED)
  @ApiOkResponse({ type: CustomTokenResponse })
  async authorizeX(@AuthUser() user: User) {
    return this.funkiIdXService.authorize(user);
  }

  @Post('/request-delete')
  async requestDelete(@AuthUser() user: User) {
    return this.deleteService.requestDelete(user);
  }

  @Post('/request-delete/confirm')
  async confirmDeleteRequest(@AuthUser() user: User, @Body() dto: ConfirmDeleteRequestDto) {
    return this.deleteService.confirmDeleteRequest(user.uid, dto);
  }

  @Post('/request-reactivate')
  async requestReactivate(@AuthUser() user: User) {
    return this.deleteService.requestReactivate(user);
  }

  @Post('/request-reactivate/confirm')
  async confirmReactivateRequest(@AuthUser() user: User, @Body() dto: ConfirmReactivateRequestDto) {
    return this.deleteService.confirmReactivateRequest(user.uid, dto.code);
  }

  @Post('/onboard')
  @ApiOkResponse({ type: Boolean })
  async onboard(@AuthUser() user: User, @Body() dto: OnboardDto) {
    return this.funkiIdService.onboard(user, dto);
  }

  @Post('/onboard-wallet')
  @ApiOkResponse({ type: Boolean })
  async onboardWallet(@AuthUser() user: User, @Body() dto: OnboardWalletDto) {
    return this.funkiIdService.onboardWallet(user, dto.walletAddress);
  }

  @Get('/waitlist-users')
  @ApiOkResponse({ type: GetWaitListUsersResponse })
  async getWaitlistUsers(@Query() dto: GetWaitListUsersDto) {
    return this.funkiIdService.getWaitlistUsers(dto);
  }

  @Get('/onboarded-users')
  @ApiOkResponse({ type: Number })
  async getOnboardedUsersCount() {
    return this.funkiIdService.getOnboardedUsersCount();
  }
}