import {
  Controller,
  Post,
  Body,
  ValidationPipe,
  Get,
  Logger,
} from '@nestjs/common';
import CreateUserDto from './dto/create-user.dto';
import { UsersService } from './users.service';
import { Public } from '../common/decorators/public.decorator';
import { Captcha } from '../common/decorators/captcha.decorator';
import { Req } from '@nestjs/common/decorators';
import { Request } from 'express';
import CreateApikeyDto from './dto/create-apikey.dto';
import { UtilsService } from '../utils/utils.service';
import { FastifyRequest } from 'fastify-multipart';
import { UpdateUploadsDto } from './dto/update-uploads.dto';
import UpdateDataDto from './dto/update-data.dto';
import { GenericRespEnum } from '../utils/enums/responses/generic.enum';
import { Readable } from 'stream';
import { RateLimit } from 'nestjs-rate-limiter';

@Controller('user')
export class UsersController {
  private readonly logger = new Logger(UsersController.name);
  constructor(
    private readonly usersService: UsersService,
    private readonly utilService: UtilsService,
  ) {}

  private async modifyObject(user: string, dto: UpdateUploadsDto) {
    const data = await this.usersService.getCoreUserData(user);
    dto.raw = data.raw === dto.raw ? undefined : dto.raw;
    dto.leaderboardPrivate =
      data.leaderboardPrivate === dto.leaderboardPrivate
        ? undefined
        : dto.leaderboardPrivate;
    dto.domain = data.domain === dto.domain ? undefined : dto.domain;
    dto.cname = data.cname === dto.cname ? undefined : dto.cname;
    return dto;
  }
  @Public()
  @RateLimit({
    for: 'Fastify',
    keyPrefix: 'register',
    points: 2,
    duration: 10,
    blockDuration: 60,
    errorMessage:
      'You can only register 2 times every 10 seconds. Try again in 1 minute.',
  })
  @Post('create')
  @Captcha()
  async createUser(
    @Body(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
    createUserDto: CreateUserDto,
    @Req() req: Request,
  ) {
    return await this.usersService.create(
      createUserDto.username,
      createUserDto.password,
      createUserDto.email,
    );
  }
  @Get('/fetch')
  async getData(@Req() req: FastifyRequest) {
    return await this.usersService.getCoreUserData(req.user);
  }
  @Post('/keys/generate')
  async generateApiKey(
    @Body(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
    createApikeyDto: CreateApikeyDto,
    @Req() req: FastifyRequest,
  ) {
    const { ip, wildcard } = createApikeyDto;
    await this.usersService.createUserApikey(req.user, wildcard ? '*' : ip);
    return this.utilService.Enums.Responses.GenericRespEnum.API_KEY_GENERATED;
  }
  @Get('/keys/fetch')
  public async fetchKeys(@Req() req: Request) {
    const r = await this.usersService.getUserApiKey(req.user);
    return r
      ? { key: this.utilService.decrypt(r.api_key), ip: r.ip, exists: true }
      : { exists: false };
  }
  @Get('/keys/revoke')
  public async revokeKey(@Req() req: Request) {
    await this.usersService.deleteUserApiKey(req.user);
    return GenericRespEnum.API_KEY_REMOVED;
  }

  @Post('/settings/uploads')
  public async setUploadSettings(
    @Req() { user }: Request,
    @Body(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
    updateUploadsDto: UpdateUploadsDto,
  ) {
    const updated: string[] = [];
    updateUploadsDto = await this.modifyObject(user, updateUploadsDto);

    if ([true, false].includes(updateUploadsDto.raw)) {
      await this.usersService.setFieldData(user, 'raw', updateUploadsDto.raw);
      updated.push(GenericRespEnum.RAW_UPDATED);
    }

    if ([true, false].includes(updateUploadsDto.leaderboardPrivate)) {
      await this.usersService.setFieldData(
        user,
        'leaderboard_private',
        updateUploadsDto.leaderboardPrivate,
      );
      updated.push(GenericRespEnum.LEADERBOARD_UPDATED);
    }
    this.logger.debug('DTO', updateUploadsDto);
    //these could be simplified probably
    if (updateUploadsDto.cname && updateUploadsDto.domain) {
      await this.usersService.setUserCname(
        user,
        updateUploadsDto.cname,
        updateUploadsDto.domain,
      );
      updated.push(GenericRespEnum.CNAME_UPDATED);
    }

    if (updateUploadsDto.domain && !updateUploadsDto.cname) {
      await this.usersService.setUserDomain(user, updateUploadsDto.domain);
      updated.push(GenericRespEnum.DOMAIN_UPDATED);
    }

    if (updateUploadsDto.cname && !updateUploadsDto.domain) {
      await this.usersService.setUserCname(user, updateUploadsDto.cname);
      updated.push(GenericRespEnum.DOMAIN_UPDATED);
      updated.push(GenericRespEnum.CNAME_UPDATED);
    }

    return { updated: updated };
  }

  @Get('/leaderboard')
  public async fetchLeaderBoard() {
    return await this.usersService.getLeaderBoard();
  }

  @Post('/settings/data')
  public async updateData(
    @Req() { user }: Request,
    @Body(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
    dto: UpdateDataDto,
  ) {
    const updated: string[] = [];
    const errors: string[] = [];

    if (dto.username) {
      await this.usersService.setFieldData(user, 'username', dto.username);
      updated.push(GenericRespEnum.USERNAME_UPDATED);
    }
    if (dto.email) {
      //TODO! email logic
      await this.usersService.changeUserEmail(user, dto.email);
      updated.push(GenericRespEnum.EMAIL_UPDATED);
    }

    if (dto.password && dto.oldPassword) {
      const pass = await this.usersService.getUserPasswordHash(user);
      if (await this.utilService.comparePass(dto.oldPassword, pass)) {
        await this.usersService.setFieldData(
          user,
          'password',
          await this.utilService.hashPass(dto.password),
        );
        updated.push(GenericRespEnum.PASS_UPDATED);
      } else {
        errors.push(GenericRespEnum.ERR_PASS_NOMATCH);
      }
    }
    return { updated, errors };
  }

  @Post('/set/pfp')
  public async setPfp(@Req() req: FastifyRequest) {
    return new Promise((res, rej) => {
      req.multipart(
        async (field, file: Readable, filename, encoding, mimetype) => {
          try {
            const result = await this.usersService.setUserPfp('CUSTOM', {
              file: await this.utilService.convertStreamToBuffer(file),
              name: filename,
              mime: mimetype,
              user: req.user,
            });
            res(result);
          } catch (err) {
            rej(err);
          }
        },
        () => {},
      );
    });
  }

  @Get('/delete')
  public async deleteAcc(@Req() req: FastifyRequest) {
    return await this.usersService.deleteUserAccount(req.user);
  }
}