import { BusinessRole, ComplexRole, POSRole } from '@/generated/prisma/enums'
import { PrismaPromise } from '@/generated/prisma/internal/prismaNamespace'
import { PrismaService } from '@/prisma/prisma.service'
import { ForbiddenException, Injectable, NotFoundException } from '@nestjs/common'
import { ResponseMapper } from 'common/response/response-mapper'
import { UpdatePermissionDto } from './dto/permission.dto'

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

  async findAll(consumer_id: string, account_id: string) {
    let data: any = []

    const businesses = [] as any
    const complexes = [] as any
    let poses = [] as any

    const consumerAccount = await this.prisma.consumerAccount.findUniqueOrThrow({
      where: {
        id: account_id,
        consumer_id,
      },
      select: {
        id: true,
        role: true,
      },
    })

    const role = consumerAccount?.role

    if (!role) {
      return new NotFoundException('کاربر مورد نظر شما یافت نشد.')
    }

    if (role === 'MANAGER') {
      return ResponseMapper.list(data)
    }

    const permissions = await this.prisma.permissionConsumer.findMany({
      where: {
        consumer_account: {
          id: account_id,
        },
      },
      select: {
        pos_permissions: {
          select: {
            pos_id: true,
            role: true,
          },
        },
        business_permissions: {
          select: {
            business_id: true,
            role: true,
          },
        },
        complex_permissions: {
          select: {
            complex_id: true,
            role: true,
          },
        },
      },
    })

    const posList = await this.prisma.pos.findMany({
      where: {
        complex: {
          business_activity: {
            consumer: {
              accounts: {
                some: {
                  id: account_id,
                },
              },
            },
          },
        },
      },
      select: {
        id: true,
        name: true,
        complex: {
          select: {
            id: true,
            name: true,
            business_activity: {
              select: {
                id: true,
                name: true,
              },
            },
          },
        },
      },
    })

    if (role === 'OPERATOR') {
      poses = posList?.map(pos => ({
        ...pos,
        hasAccess: permissions.some(permission =>
          permission.pos_permissions.some(
            posPermission => posPermission.pos_id === pos.id,
          ),
        ),
      }))

      return ResponseMapper.single({ poses })
    } else {
      const businessActivities = await this.prisma.businessActivity.findMany({
        where: {
          consumer: {
            accounts: {
              some: {
                id: account_id,
              },
            },
          },
        },
        select: {
          id: true,
          name: true,
          complexes: {
            select: {
              id: true,
              name: true,
              pos_list: {
                select: {
                  id: true,
                  name: true,
                },
              },
            },
          },
        },
      })

      businessActivities.forEach(businessActivity => {
        businesses.push({
          id: businessActivity.id,
          name: businessActivity.name,
          hasAccess: false,
          role: null,
        })

        businessActivity.complexes.forEach(complex => {
          complexes.push({
            id: complex.id,
            name: complex.name,
            hasAccess: false,
            role: null,
          })

          complex.pos_list.forEach(pos => {
            poses.push({
              id: pos.id,
              name: pos.name,
              hasAccess: false,
              role: null,
            })
          })
        })
      })

      return ResponseMapper.single({ businessActivities, complexes })
    }
  }

  async create(consumer_id: string, account_id: string, data: UpdatePermissionDto) {
    const consumerAccount = await this.prisma.consumerAccount.findUniqueOrThrow({
      where: {
        id: account_id,
        consumer_id,
      },
      select: {
        id: true,
        role: true,
      },
    })

    const role = consumerAccount?.role

    if (!role) {
      return new NotFoundException('کاربر مورد نظر شما یافت نشد.')
    }
    if (role === 'MANAGER') {
      return new ForbiddenException(
        'این امکان برای کاربران با سطح دسترسی مدیر اصلی وجود ندارد.',
      )
    }

    const existingPermissionConsumer = await this.prisma.permissionConsumer.findUnique({
      where: {
        consumer_account_id: account_id,
      },
      select: {
        id: true,
      },
    })

    if (!existingPermissionConsumer) {
      throw new NotFoundException(``)
    }

    const permissionConsumerId = existingPermissionConsumer.id
    await this.prisma.$transaction(async tx => {
      await tx.permissionPos.deleteMany({
        where: { permission_id: permissionConsumerId },
      })
      await tx.permissionComplex.deleteMany({
        where: { permission_id: permissionConsumerId },
      })
      await tx.permissionBusiness.deleteMany({
        where: { permission_id: permissionConsumerId },
      })

      const createOperations: PrismaPromise<any>[] = []

      if (data.poses && data.poses.length > 0) {
        data.poses.forEach(posId => {
          createOperations.push(
            tx.permissionPos.create({
              data: {
                role: POSRole.OPERATOR,
                permission: { connect: { id: permissionConsumerId } },
                pos: { connect: { id: posId } },
              },
            }),
          )
        })
      }

      if (data.complexes && data.complexes.length > 0) {
        data.complexes.forEach(complexId => {
          createOperations.push(
            tx.permissionComplex.create({
              data: {
                role: ComplexRole.OPERATOR,
                permission: { connect: { id: permissionConsumerId } },
                complex: { connect: { id: complexId } },
              },
            }),
          )
        })
      }

      if (data.business_activities && data.business_activities.length > 0) {
        data.business_activities.forEach(businessId => {
          createOperations.push(
            tx.permissionBusiness.create({
              data: {
                role: BusinessRole.OPERATOR,
                permission: { connect: { id: permissionConsumerId } },
                business: { connect: { id: businessId } },
              },
            }),
          )
        })
      }

      if (createOperations.length > 0) {
        await Promise.all(createOperations)
      }
    })
    return ResponseMapper.create({})
  }
}