import { UploadedFileTypes } from '@/common/enums/enums'
import { GoodSelect } from '@/generated/prisma/models'
import { PosCacheInvalidationService } from '@/modules/pos/cache/pos-cache-invalidation.service'
import { UploaderService } from '@/modules/uploader/uploader.service'
import { PrismaService } from '@/prisma/prisma.service'
import { Injectable } from '@nestjs/common'
import { ResponseMapper } from 'common/response/response-mapper'
import { CreateGoodDto, UpdateGoodDto } from './dto/good.dto'

@Injectable()
export class ConsumerBusinessActivityGoodsService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly uploaderService: UploaderService,
    private readonly posCacheInvalidationService: PosCacheInvalidationService,
  ) {}

  defaultSelect: GoodSelect = {
    id: true,
    name: true,
    barcode: true,
    local_sku: true,
    pricing_model: true,
    image_url: true,
    sku: {
      select: {
        id: true,
        name: true,
      },
    },
    measure_unit: {
      select: {
        id: true,
        name: true,
      },
    },
    category: {
      select: {
        id: true,
        name: true,
      },
    },
    created_at: true,
  }

  async findAll(consumer_id: string, business_activity_id: string) {
    const goods = await this.prisma.good.findMany({
      where: {
        business_activity: {
          id: business_activity_id,
          consumer_id,
        },
      },
      select: this.defaultSelect,
    })

    return ResponseMapper.list(goods)
  }

  async findOne(consumer_id: string, business_activity_id: string, id: string) {
    const good = await this.prisma.good.findUnique({
      where: {
        business_activity: {
          id: business_activity_id,
          consumer_id,
        },
        id,
      },
      select: this.defaultSelect,
    })
    return ResponseMapper.single(good)
  }

  async create(
    business_activity_id: string,
    data: CreateGoodDto,
    file: Express.Multer.File,
  ) {
    const { category_id, sku_id, measure_unit_id, ...rest } = data
    let image_url = ''
    if (file) {
      const uploadedUrl = await this.uploaderService.uploadFile(
        file,
        UploadedFileTypes.GOOD,
      )
      image_url = uploadedUrl || ''
    }

    const good = await this.prisma.good.create({
      data: {
        ...rest,
        image_url,
        business_activity: {
          connect: {
            id: business_activity_id,
          },
        },
        category: {
          connect: {
            id: category_id,
          },
        },
        sku: {
          connect: {
            id: sku_id,
          },
        },
        measure_unit: {
          connect: {
            id: measure_unit_id,
          },
        },
      },
    })
    await this.posCacheInvalidationService.invalidateGoodsListByBusinessActivity(
      business_activity_id,
    )
    return ResponseMapper.create(good)
  }

  async update(
    consumer_id: string,
    business_activity_id: string,
    id: string,
    data: UpdateGoodDto,
    file: Express.Multer.File,
  ) {
    const good = await this.prisma.$transaction(async tx => {
      const { category_id, sku_id, measure_unit_id, ...rest } = data
      let image_url = ''
      if (file) {
        const uploadedUrl = await this.uploaderService.uploadFile(
          file,
          UploadedFileTypes.GOOD,
        )
        image_url = uploadedUrl || ''
      }

      const prevImage = await tx.good.findUnique({
        where: { id },
        select: { image_url: true },
      })

      if (image_url && prevImage?.image_url) {
        this.uploaderService.deleteFile(prevImage.image_url, UploadedFileTypes.GOOD)
      }

      return await tx.good.update({
        where: {
          business_activity: {
            id: business_activity_id,
            consumer_id,
          },
          id,
        },
        data: {
          image_url,
          business_activity: {
            connect: {
              id: business_activity_id,
            },
          },
          category: {
            connect: {
              id: category_id,
            },
          },
          sku: {
            connect: {
              id: sku_id,
            },
          },
          measure_unit: {
            connect: {
              id: measure_unit_id,
            },
          },
          ...rest,
        },
      })
    })
    await this.posCacheInvalidationService.invalidateGoodsListByBusinessActivity(
      business_activity_id,
    )
    return ResponseMapper.update(good)
  }

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