import { LicenseInclude } from '@/generated/prisma/models'
import { PrismaService } from '@/prisma/prisma.service'
import { Injectable } from '@nestjs/common'
import { ResponseMapper } from 'common/response/response-mapper'
import { LicenseStatus } from 'generated/prisma/enums'
import { CreateLicenseDto, UpdateLicenseDto } from './dto/license.dto'

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

  private readonly licenseInclude = {
    partner: true,
    pos: {
      include: {
        complex: true,
        provider: true,
        accounts: {
          include: {
            user: true,
          },
          omit: {
            business_id: true,
            partner_id: true,
            provider_id: true,
            pos_id: true,
          },
        },
        device: {
          include: {
            brand: true,
          },
          omit: {
            brand_id: true,
          },
        },
      },
    },
  } as LicenseInclude

  async findAll() {
    const [licenses, count] = await this.prisma.$transaction([
      this.prisma.license.findMany({
        include: this.licenseInclude,
        omit: {
          pos_id: true,
          partner_id: true,
        },
      }),
      this.prisma.license.count(),
    ])
    return ResponseMapper.paginate(
      licenses.map(license => {
        const { pos, ...rest } = license
        // @ts-ignore
        const { accounts, ...posRest } = pos
        return {
          account: accounts[0],
          pos: posRest,
          ...rest,
        }
      }),
      {
        count,
      },
    )
  }

  async findOne(id: string) {
    const license = await this.prisma.license.findFirst({
      where: { id },
      include: this.licenseInclude,
      omit: {
        pos_id: true,
        partner_id: true,
      },
    })
    if (license) {
      const { pos, ...rest } = license
      // @ts-ignore
      const { accounts, ...posRest } = pos
      return ResponseMapper.single({
        account: accounts[0],
        pos: posRest,
        ...rest,
      })
    }

    return ResponseMapper.single(license)
  }

  async create(data: CreateLicenseDto) {
    const date = new Date(data.starts_at || '')
    const expiresAt =
      data.expires_at || new Date(date.setFullYear(date.getFullYear() + 1))

    const license = await this.prisma.license.create({
      data: {
        partner_id: data.partner_id,
        pos_id: data.pos_id,
        starts_at: date,
        expires_at: expiresAt,
        status: LicenseStatus.ACTIVE,
      },
    })

    return ResponseMapper.create(license)
  }

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

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