import {
  BadRequestException,
  Injectable,
  UnauthorizedException,
  Logger,
} from '@nestjs/common';
import { DatabaseService } from '../database/database.service';
import { UploadsService } from '../uploads/uploads.service';
import { AlbumsEnum } from '../utils/enums/responses.enum';
import { albums } from '@prisma/client';
import { UtilsService } from '../utils/utils.service';
import * as Prisma from '@prisma/client';

@Injectable()
export class AlbumsService {
  private readonly logger = new Logger(AlbumsService.name);
  constructor(
    private readonly databaseService: DatabaseService,
    private readonly uploadsService: UploadsService,
    private readonly utilsService: UtilsService,
  ) {}

  public async getAlbum(album: string) {
    return await this.databaseService.read.albums.findFirst({
      where: { snowflake: album },
    });
  }
  private async getUploadAlbum(upload: string): Promise<string | undefined> {
    const r = await this.databaseService.read.uploads.findFirst({
      where: { snowflake: upload },
      select: { album: true },
    });
    return r.album;
  }

  public async removeFromAlbum<
    Omit extends boolean,
    User extends Omit extends false ? string : undefined,
  >(
    album: string,
    upload: string,
    omitCheck: Omit,
    user?: User,
    albumData?: albums,
  ) {
    const alb = albumData || (await this.getAlbum(album));
    const data = await this.uploadsService.getUploadData(upload);
    if (!omitCheck) {
      if (!alb) {
        throw new BadRequestException();
      }
      if (user !== data.owner || alb.owner !== user) {
        throw new UnauthorizedException();
      }
    }

    const p1 = await this.databaseService.write.albums.update({
      where: { snowflake: alb.snowflake },
      data: {
        elements: { decrement: 1 },
      },
    });

    // this.logger.debug("data", await this.getAlbum(album))
    const p2 = this.databaseService.write.uploads.update({
      where: {
        snowflake: upload,
      },
      data: {
        album: null,
      },
    });

    await Promise.all([p1, p2]);
    return AlbumsEnum.REMOVED_FROM_ALBUM;
  }

  public async addImageToAlbum(user: string, album: string, upload: string) {
    const { owner, path } = await this.uploadsService.getUploadData(upload);
    const alb = await this.getAlbum(album);

    if (await this.getUploadAlbum(upload)) {
      this.logger.debug('Removing from album before adding to new');
      await this.removeFromAlbum(album, upload, true, undefined, alb);
    }

    if (user !== owner || alb.owner !== user) {
      throw new UnauthorizedException();
    }

    await this.databaseService.write.albums.update({
      where: { snowflake: album },
      data: {
        elements: { increment: 1 },
      },
    });

    await this.databaseService.write.uploads.update({
      where: { snowflake: upload },
      data: { album: album },
    });

    return AlbumsEnum.ADDED_TO_ALBUM;
  }

  public async createAlbum(user: string, name: string, pub: boolean) {
    await this.databaseService.write.albums.create({
      data: {
        name,
        public: pub,
        elements: 0,
        created: Date.now().toString(),
        snowflake: await this.utilsService.generateSnowflake(),
        users: {
          connect: {
            snowflake: user,
          },
        },
      },
    });
    return this.utilsService.Enums.Responses.AlbumsEnum.CREATED;
  }

  public async getUserAlbums(user: string) {
    return await this.databaseService.read.albums.findMany({
      where: {
        owner: user,
      },
      select: {
        snowflake: true,
        elements: true,
        public: true,
        name: true,
        created: true,
      },
    });
  }

  public async getContents(
    album: string,
    take: number,
    skip: number,
    pathQuery?: string,
    extQuery?: string,
  ) {
    this.logger.debug(`Skipping ${skip} entries in album fetch`);
    const res = await this.databaseService.read.uploads.findMany({
      where: {
        album,
        ...this.utilsService.computeQueryObj(pathQuery, extQuery),
      },
      select: {
        mime: true,
        path: true,
        size: true,
        date: true,
        favorite: true,
        album: true,
        extension: true,
        snowflake: true,
      },
      skip,
      take,
    });
    return res.map((img) => {
      return {
        url: `${img.path!}.${img.extension}`,
        date: img.date!,
        size: img.size!,
        isFav: img.favorite!,
        album: img.album || false,
        extension: img.extension,
        id: img.snowflake,
        mime: img.mime,
      };
    });
  }
  public async setFieldData<T extends keyof Prisma.Prisma.albumsUpdateInput>(
    album: string,
    field: T,
    state: Prisma.Prisma.albumsUpdateInput[T],
  ) {
    await this.databaseService.write.albums.update({
      where: {
        snowflake: album,
      },
      data: {
        [field]: state,
      },
    });
  }

  public async deleteAlbum(album: string) {
    await this.databaseService.write.albums.delete({
      where: {
        snowflake: album,
      },
    });
  }
}