import {
  BadRequestException,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { CreateSponsorDto } from './dto/create-sponsor.dto';
import { UpdateSponsorDto } from './dto/update-sponsor.dto';
import { InjectRepository } from '@nestjs/typeorm';
import { Sponsor } from './entities/sponsor.entity';
import { Repository } from 'typeorm';
import { isEmpty } from 'src/common/helper';
import { SponsorRepository } from './sponsors.repository';
import isValidUuidV4 from 'src/common/uuid validator/uuid-validate';
import { lan } from 'src/lan';

@Injectable()
export class SponsorsService {
  constructor(
    @InjectRepository(Sponsor)
    private readonly sponsorService: Repository<Sponsor>,
    private readonly sponsorRepository: SponsorRepository,
  ) {}

  async create(createSponsorDto: CreateSponsorDto) {
    if (!isEmpty(createSponsorDto.image)) {
      const attachmentUrl = `uploads/sponsor-image/${createSponsorDto.image}`;
      createSponsorDto.image = attachmentUrl;
    }

    const sponsor = new Sponsor();
    Object.assign(sponsor, createSponsorDto);

    const returnData = await this.sponsorService.save(sponsor);
    return returnData;
  }

  async findAll(take: number, skip: number, search: string) {
    return await this.sponsorRepository.findAll(take, skip, search);
  }

  async findOne(id: string) {
    return this.sponsorRepository.findOne(id);
  }

  async update(id: string, updateSponsorDto: UpdateSponsorDto) {
    const sponsor = new Sponsor();
    Object.assign(sponsor, updateSponsorDto);

    return await this.sponsorService.update(id, sponsor);
  }

  async remove(id: string) {
    if (!isValidUuidV4(id)) {
      throw new BadRequestException(lan('common.invalid_uuid_format'));
    }

    const job = await this.sponsorRepository.findOne(id);

    if (isEmpty(job)) {
      throw new NotFoundException(lan('common.data_not_found'));
    }

    return this.sponsorService.softDelete(id);
    // return `This action removes a #${id} sponsor`;
  }
}