server/src/repositories/ZoneRepository.ts

import { Zone, ZoneEventTile, ZoneObject } from '@prisma/client'
import prisma from '../utilities/Prisma'; // Import the global Prisma instance

class ZoneRepository {
    async getFirst(): Promise<Zone | null> {
        try {
            return await prisma.zone.findFirst();
        } catch (error: any) {
            // Handle error
            throw new Error(`Failed to get first zone: ${error.message}`);
        }
    }

    async getAll(): Promise<Zone[]> {
        try {
            return await prisma.zone.findMany();
        } catch (error: any) {
            // Handle error
            throw new Error(`Failed to get all zone: ${error.message}`);
        }
    }

    async getById(id: number): Promise<Zone | null> {
        try {
            return await prisma.zone.findUnique({
                where: {
                    id: id
                },
                include: {
                    zoneEventTiles: {
                        include: {
                            zone: true
                        }
                    },
                    zoneObjects: {
                        include: {
                            object: true
                        }
                    }
                }
            });
        } catch (error: any) {
            // Handle error
            throw new Error(`Failed to get zone by id: ${error.message}`);
        }
    }

    async create(name: string, width: number, height: number, tiles: string[][]): Promise<Zone> {
        try {
            return await prisma.zone.create({
                data: {
                    name: name,
                    width: width,
                    height: height,
                    tiles: tiles
                }
            });
        } catch (error: any) {
            // Handle error
            throw new Error(`Failed to create zone: ${error.message}`);
        }
    }

    async update(id: number, name: string, width: number, height: number, tiles: string[][], zoneEventTiles: ZoneEventTile[], zoneObjects: ZoneObject[]): Promise<Zone> {
        try {
            return await prisma.zone.update({
                where: {
                    id: id
                },
                data: {
                    name,
                    width,
                    height,
                    tiles,
                    zoneEventTiles: {
                        deleteMany: {
                            zoneId: id // Ensure only event tiles related to the zone are deleted
                        },
                        // Save new zone event tiles
                        create: zoneEventTiles.map(zoneEventTile => ({
                            type: zoneEventTile.type,
                            position_x: zoneEventTile.position_x,
                            position_y: zoneEventTile.position_y
                        }))
                    },
                    zoneObjects: {
                        deleteMany: {
                            zoneId: id // Ensure only objects related to the zone are deleted
                        },
                        // Save new zone objects
                        create: zoneObjects.map(zoneObject => ({
                            objectId: zoneObject.objectId,
                            depth: zoneObject.depth,
                            position_x: zoneObject.position_x,
                            position_y: zoneObject.position_y
                        }))
                    }
                }
            });
        } catch (error: any) {
            // Handle error
            throw new Error(`Failed to update zone: ${error.message}`);
        }
    }

    async delete(id: number): Promise<Zone> {
        try {
            return await prisma.zone.delete({
                where: {
                    id: id
                }
            });
        } catch (error: any) {
            // Handle error
            throw new Error(`Failed to delete zone: ${error.message}`);
        }
    }
}

export default new ZoneRepository;