import {
  Body,
  Controller,
  Post,
  Req,
  ValidationPipe,
  Get,
  UnauthorizedException,
  Logger,
} from '@nestjs/common';
import { AlbumsService } from './albums.service';
import { FastifyRequest } from 'fastify';
import { AddOrRemoveDto } from './dto/addOrRemove.dto';
import { CreateDto } from './dto/create.dto';
import { FetchDto } from './dto/fetch.dto';
import { Both } from '../common/decorators/both.decorator';
import { UpdateDto } from './dto/update.dto';
import { AlbumsEnum } from '../utils/enums/responses.enum';
import { DeleteDto } from './dto/delete.dto';
import { ApiKey } from '../common/decorators/apikey.decorator';
import { AllowApi } from '../common/decorators/allowapi.decorator';

@Controller('album')
@AllowApi()
export class AlbumsController {
  private readonly logger = new Logger(AlbumsController.name);
  constructor(private readonly albumsService: AlbumsService) {}

  @Post('/add')
  async addToAlbum(
    @Req() { user }: FastifyRequest,
    @Body(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
    { album, image }: AddOrRemoveDto,
  ) {
    return await this.albumsService.addImageToAlbum(user, album, image);
  }

  @Post('/remove')
  async removeFromAlbum(
    @Req() { user }: FastifyRequest,
    @Body(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
    { album, image }: AddOrRemoveDto,
  ) {
    return await this.albumsService.removeFromAlbum(album, image, false, user);
  }

  @Post('/create')
  async createAlbum(
    @Req() { user }: FastifyRequest,
    @Body(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
    dto: CreateDto,
  ) {
    return await this.albumsService.createAlbum(user, dto.name, dto.public);
  }

  @Get('/fetch')
  public async getAllUserAlbums(@Req() { user }: FastifyRequest) {
    return await this.albumsService.getUserAlbums(user);
  }
  @Post('/fetch/data')
  @Both()
  public async fetchAlbum(
    @Req() { user }: FastifyRequest,
    @Body(new ValidationPipe())
    { album, take, skip, pathQuery, extQuery }: FetchDto,
  ) {
    const alb = await this.albumsService.getAlbum(album);
    if (alb.public || alb.owner === user) {
      this.logger.log('Sending back album');
      return {
        contents: await this.albumsService.getContents(
          album,
          take,
          skip,
          pathQuery,
          extQuery,
        ),
        owner: alb.owner === user,
        data: alb,
      };
    } else {
      this.logger.log('Unauthorized for album:', alb.name);
      throw new UnauthorizedException();
    }
  }
  @Post('/update')
  public async updateAlbum(
    @Req() { user }: FastifyRequest,
    @Body(new ValidationPipe()) data: UpdateDto,
  ) {
    if ((await this.albumsService.getAlbum(data.album)).owner !== user) {
      throw new UnauthorizedException();
    }

    if ([true, false].includes(data.public)) {
      //what a shit solution
      await this.albumsService.setFieldData(data.album, 'public', data.public);
    }

    if (data.name) {
      await this.albumsService.setFieldData(data.album, 'name', data.name);
    }
    return AlbumsEnum.UPDATED;
  }

  @Post('/delete')
  public async deleteAlbum(
    @Req() { user }: FastifyRequest,
    @Body(new ValidationPipe()) data: DeleteDto,
  ) {
    if ((await this.albumsService.getAlbum(data.album)).owner !== user) {
      throw new UnauthorizedException();
    }

    await this.albumsService.deleteAlbum(data.album);
    return AlbumsEnum.ALBUM_DELETED;
  }
}