import { PasswordUtil } from '@/common/utils/password.util'
import {
  AccountStatus,
  AccountType,
  PartnerRole,
  PartnerStatus,
} from '@/generated/prisma/enums'
import { PrismaService } from '@/prisma/prisma.service'
import { Injectable } from '@nestjs/common'
import { ResponseMapper } from 'common/response/response-mapper'
import { CreatePartnerDto, LicenseChargeDto, UpdatePartnerDto } from './dto/partner.dto'

@Injectable()
export class PartnersService {
  constructor(private readonly prisma: PrismaService) {}

  async findAll() {
    const partners = await this.prisma.partner.findMany()
    return ResponseMapper.list(partners)
  }

  async findOne(id: string) {
    const [partner, relatedLicenseCount] = await this.prisma.$transaction([
      this.prisma.partner.findUnique({
        where: { id },
      }),
      this.prisma.license.count({
        where: {
          partner_id: id,
        },
      }),
    ])

    return ResponseMapper.single({
      ...partner,
      remained_license: Math.max(
        (partner?.license_quota || 0) - (relatedLicenseCount || 0),
        0,
      ),
    })
  }

  async create(data: CreatePartnerDto) {
    const { username, password, ...rest } = data
    const partner = await this.prisma.partner.create({
      data: {
        ...rest,
        status: PartnerStatus.ACTIVE,
        partner_accounts: {
          create: {
            role: PartnerRole.OWNER,
            account: {
              create: {
                username,
                password: await PasswordUtil.hash(data.password),
                status: AccountStatus.ACTIVE,
                type: AccountType.PARTNER,
              },
            },
          },
        },
      },
    })
    return ResponseMapper.create(partner)
  }

  async update(id: string, data: UpdatePartnerDto) {
    const partner = await this.prisma.partner.update({ where: { id }, data })
    return ResponseMapper.update(partner)
  }

  async licenseCharge(id: string, data: LicenseChargeDto) {
    const partner = await this.prisma.partner.update({
      where: { id },
      data: {
        license_quota: {
          increment: data.count,
        },
      },
    })
    return ResponseMapper.update(partner)
  }

  async delete(id: string) {
    await this.prisma.partner.delete({ where: { id } })
    return ResponseMapper.delete()
  }
}