import prisma from '../config/database';
import { Prisma, ScanStatus, Marketplace } from '@prisma/client';

export class ScanRepository {
    async create(data: Prisma.ScanCreateInput) {
        return prisma.scan.create({ data });
    }

    async findById(id: string) {
        return prisma.scan.findUnique({
            where: { id },
            include: { items: { orderBy: { priceNumeric: 'asc' } } },
        });
    }

    async findByUserId(
        userId: string,
        page: number,
        limit: number,
        filters?: {
            marketplace?: Marketplace;
            keyword?: string;
            startDate?: Date;
            endDate?: Date;
        }
    ) {
        const where: Prisma.ScanWhereInput = { userId };

        if (filters?.marketplace) where.marketplace = filters.marketplace;
        if (filters?.keyword) {
            where.OR = [
                { keyword: { contains: filters.keyword } },
                { category: { contains: filters.keyword } },
            ];
        }
        if (filters?.startDate || filters?.endDate) {
            where.createdAt = {};
            if (filters.startDate) where.createdAt.gte = filters.startDate;
            if (filters.endDate) where.createdAt.lte = filters.endDate;
        }

        const [scans, total] = await Promise.all([
            prisma.scan.findMany({
                where,
                skip: (page - 1) * limit,
                take: limit,
                orderBy: { createdAt: 'desc' },
                include: { _count: { select: { items: true } } },
            }),
            prisma.scan.count({ where }),
        ]);

        return { scans, total, page, limit, totalPages: Math.ceil(total / limit) };
    }

    async update(id: string, data: Prisma.ScanUpdateInput) {
        return prisma.scan.update({ where: { id }, data });
    }

    async createItems(scanId: string, items: Prisma.ScanItemCreateManyInput[]) {
        return prisma.scanItem.createMany({
            data: items.map((item) => ({ ...item, scanId })),
        });
    }

    async countByUser(userId: string) {
        return prisma.scan.count({ where: { userId } });
    }

    async getTotalScans() {
        return prisma.scan.count();
    }

    async getRecentScans(userId: string, limit = 5) {
        return prisma.scan.findMany({
            where: { userId },
            orderBy: { createdAt: 'desc' },
            take: limit,
        });
    }
}

export default new ScanRepository();