import { Injectable, Logger } from '@nestjs/common';
import { DatabaseService } from '../database/database.service';
import { UtilsService } from '../utils/utils.service';
import { CodesEnum } from '../utils/enums/codes.enum';
import { CodeDescriptor } from '../../types';
@Injectable()
export class CodesService {
  private readonly logger = new Logger(CodesService.name);
  constructor(
    private readonly utilsService: UtilsService,
    private readonly databaseService: DatabaseService,
  ) {}

  async createCode(
    type: keyof typeof CodesEnum,
    expiration: number,
    user?: string,
    excess?: string,
    encryptExcess = true,
  ): Promise<CodeDescriptor> {
    expiration = 1000 * (60 * expiration);
    this.logger.debug(`Generating code ${type}`);
    return (await this.databaseService.write.codes.create({
      data: {
        user,
        code: await this.utilsService.generateSnowflake(),
        issued_at: Date.now().toString(),
        expiration: (Date.now() + expiration).toString(),
        type,
        excess:
          typeof excess === 'string'
            ? encryptExcess
              ? this.utilsService.encrypt(excess)
              : excess
            : undefined,
      },
    })) as CodeDescriptor;
  }

  async fetchCode(code: string): Promise<CodeDescriptor | null> {
    if (!code) {
      return null;
    }
    return (await this.databaseService.read.codes.findFirst({
      where: {
        code: code || undefined,
      },
    })) as CodeDescriptor;
  }

  async isCodeValid(code: string): Promise<boolean> {
    return (
      (await this.databaseService.read.codes.count({
        where: { code },
      })) > 0
    );
  }

  async setCodeUsed(code: string) {
    await this.databaseService.write.codes.update({
      where: {
        code,
      },
      data: { used: true },
    });
  }

  public async isCodeExpired(code: string, expiry?: string): Promise<boolean> {
    expiry = expiry || (await this.fetchCode(code))?.expiration;
    if (!expiry) {
      return false;
    }
    this.logger.debug('Fetching code yo');
    return this.utilsService.didTimeStampExpire(parseInt(expiry));
  }

  public async isCodeUsed(code: string): Promise<boolean> {
    const r = await this.databaseService.read.codes.count({
      where: { code, used: false },
    });
    return r !== 0;
  }

  public async getUsedCodes() {
    return await this.databaseService.read.codes.findMany({
      where: {
        used: true,
      },
    });
  }

  public async delete(code: string) {
    await this.databaseService.write.codes.delete({
      where: {
        code,
      },
    });
  }
  public async getCodePool() {
    return await this.databaseService.read.codes.count();
  }
}