import prisma from '../../prisma/PrismaClient';
import { now } from '../../utils/TimeLocal';
import { Prisma, Vendor } from '@prisma/client';

type FindAllOptions = {
    skip?: number;
    take?: number;
    where?: Prisma.VendorWhereInput;
    orderBy?: Prisma.VendorOrderByWithRelationInput;
};

const VendorRepository = {
    findAll: async ({ skip, take, where, orderBy }: FindAllOptions) => {
        const vendors = await prisma.vendor.findMany({
            where,
            skip,
            take,
            orderBy,
            select: {
                id: true,
                name: true,
                name_pt: true,
                strengths: true,
                weaknesses: true,
                website: true,
                user: { select: { id: true, fullname: true } },
                _count: {
                    select: {
                        vendor_experiences: {
                            where: {
                                deletedAt: null,
                                status: "active"
                            },
                        },
                    },
                },
                createdAt: true,
                updatedAt: true,
            },
        });

        const formattedVendors = vendors.map(v => {
            const { _count, ...rest } = v;
            return {
                ...rest,
                count_hospitals: _count.vendor_experiences,
            };
        });

        return formattedVendors;
    },

    countAll: async (where?: Prisma.VendorWhereInput) => {
        return prisma.vendor.count({ where });
    },

    findById: async (id: string) => {
        const vendor = await prisma.vendor.findFirst({
            where: {
                id,
                deletedAt: null,
            },
            select: {
                id: true,
                name: true,
                name_pt: true,
                strengths: true,
                weaknesses: true,
                website: true,
                user: { select: { id: true, fullname: true } },
                _count: {
                    select: {
                        vendor_experiences: {
                            where: {
                                deletedAt: null,
                            },
                        },
                    },
                },
                createdAt: true,
                updatedAt: true,
            },
        });

        if (!vendor) return null;

        const { _count, ...rest } = vendor;
        return {
            ...rest,
            count_hospitals: _count.vendor_experiences,
        };
    },

    create: async (data: Prisma.VendorCreateInput) => {
        return prisma.vendor.create({ data });
    },

    update: async (id: string, data: Prisma.VendorUpdateInput) => {
        return prisma.vendor.update({
            where: { id },
            data,
        });
    },

    delete: async (id: string) => {
        const vendor = await prisma.vendor.update({
            where: { id },
            data: {
                deletedAt: now().toDate(),
            },
        });

        await prisma.vendorExperience.updateMany({
            where: {
                vendor_id: id,
                deletedAt: null,
            },
            data: {
                vendor_id: null,
            },
        });

        return vendor;
    },

    findByName: async (name: string, name_pt: string): Promise<Vendor | null> => {
        return prisma.vendor.findFirst({
            where: {
                name,
                name_pt,
                deletedAt: null,
            },
        });
    },
};

export default VendorRepository;