import { Injectable, NotFoundException } from '@nestjs/common';
import { PrismaService } from '@/src/prisma.service';
import { MongoService } from '@/src/database/mongo/mongo.service';
import { UrlHandler } from '@/src/utils/navigator/urlHandler';

@Injectable()
export class PagesService {
    constructor(
        private readonly prismaService: PrismaService,
        private readonly mongoService: MongoService,
        private readonly urlHandler: UrlHandler
    ) { }

    tokens = { employeeTypeToken: "L9wBdwV9OlxsLAgh", occupantTypeToken: "j0adQOsJBR0xq24d" }

    private async saveChunkToDB(data: Record<string, any>, chunkIndex: number) {
        await this.mongoService.set("Pages");
        if (chunkIndex == 1) { await this.mongoService.deleteMany({}) }
        await this.mongoService.createMany(Object.values(data));
    }

    async getPagesOccupants(userUUID: string, usersToken: string) {
        const user = await this.prismaService.users.findFirstOrThrow({ where: { uu_id: userUUID }, include: { people: true } });
        const userType = await this.prismaService.user_types.findFirstOrThrow({ where: { token: usersToken } })
        if (userType.type_token == this.tokens.occupantTypeToken) {
            const person = user.people
            const livingSpace = await this.prismaService.build_living_space.findFirstOrThrow({
                where: { person_id: person.id, occupant_types: { user_types: { id: userType.id } } },
                select: { build_parts_id: true }
            })
            const buildUUID = await this.prismaService.build.findFirstOrThrow({
                where: { build_parts: { some: { id: livingSpace.build_parts_id } } }, select: { uu_id: true }
            })
            this.mongoService.set(`Pages/${buildUUID.uu_id}`);
            console.log('usersToken', usersToken)
            console.log('user.uu_id', user.uu_id)
            const userPage = await this.mongoService.findOne({ [user.uu_id]: { $exists: true } })
            console.log('userPage', userPage)
            if (!userPage) { throw new NotFoundException('Users slot not found') }
            const userPageSlot = userPage[user.uu_id][usersToken]
            if (!userPageSlot) { throw new NotFoundException('Users slot not found') }
            console.log('userPageSlot', userPageSlot)
            const writeObject = {}
            for (const [key, value] of Object.entries(userPageSlot)) {
                writeObject[key] = `${key}:${value}`
            }
            console.log('writeObject', writeObject)
            return writeObject
        }
        else { throw new NotFoundException('User type not found') }
    }

    async getPagesEmployee(userUUID: string, usersToken: string) {
        const user = await this.prismaService.users.findFirstOrThrow({ where: { uu_id: userUUID }, include: { people: true } });
        const userType = await this.prismaService.user_types.findFirstOrThrow({ where: { token: usersToken } })
        if (userType.type_token == this.tokens.employeeTypeToken) {
            const person = user.people[0]
            const employee = await this.prismaService.employees.findFirstOrThrow({ where: { people_id: person.id, staff: { user_type_id: userType.id } } })
            const companyUUID = await this.prismaService.companies.findFirstOrThrow({
                where: { departments: { some: { duties: { some: { staff: { some: { uu_id: employee.staff_uu_id } } } } } } }, select: { uu_id: true }
            })
            this.mongoService.set(`Pages/${companyUUID.uu_id}`);
            const userPage = await this.mongoService.findOne({ [user.uu_id]: { [usersToken]: { $exists: true } } })
            if (!userPage) { throw new NotFoundException('Users slot not found') }
            return userPage
        }
        else { throw new NotFoundException('User type not found') }
    }

    async setPageViaToken(userUUID: string, usersToken: string, url: string, page: Record<string, any>) {
        const user = await this.prismaService.users.findFirstOrThrow({ where: { uu_id: userUUID }, include: { people: true } });
        const userType = await this.prismaService.user_types.findFirstOrThrow({ where: { token: usersToken } })
        const urlToken = await this.urlHandler.getSecureUrlToken(url)
        if (userType.type_token == this.tokens.employeeTypeToken) {
            const person = user.people[0]
            const employee = await this.prismaService.employees.findFirstOrThrow({ where: { people_id: person.id, staff: { user_type_id: userType.id } } })
            const companyUUID = await this.prismaService.companies.findFirstOrThrow({
                where: { departments: { some: { duties: { some: { staff: { some: { uu_id: employee.staff_uu_id } } } } } } }, select: { uu_id: true }
            })
            this.mongoService.set(`Pages/${companyUUID.uu_id}`);
            const userPage = await this.mongoService.findOne({ [employee.uu_id]: { $exists: true } });
            if (!userPage) {
                console.log('urlToken', urlToken)
            } else { console.log('urlToken', urlToken) }
        } else if (userType.type_token == this.tokens.occupantTypeToken) {
            const person = user.people
            const livingSpace = await this.prismaService.build_living_space.findFirstOrThrow({
                where: { person_id: person.id, occupant_types: { user_types: { id: userType.id } } },
                select: { uu_id: true, build_parts_id: true }
            })
            const buildUUID = await this.prismaService.build.findFirstOrThrow({
                where: { build_parts: { some: { id: livingSpace.build_parts_id } } }, select: { uu_id: true }
            })
            this.mongoService.set(`Pages/${buildUUID.uu_id}`);
            const userPage = await this.mongoService.findOne({ [user.uu_id]: { $exists: true } });
            if (!userPage) {
                const newUserPageSlot = await this.mongoService.create({ [user.uu_id]: { [`${usersToken}`]: { [`${urlToken}`]: `${page.key}` } } })
                return newUserPageSlot
            } else {
                const updatedUserPageSlot = await this.mongoService.updateOne(userPage._id, { [`${user.uu_id}.${usersToken}.${urlToken}`]: `${page.key}` })
                return updatedUserPageSlot ? { status: "success", data: updatedUserPageSlot } : { status: "error", data: null }
            }
            // console.log('urlToken', { [user.uu_id]: { [`${body.usersToken}`]: { [`${urlToken}`]: `${body.page.key}` } } })
        }
        else { throw new NotFoundException('User type not found') }
    }

    async getPageViaToken(usersUUID: string, token: string, url?: string, skip?: number, limit?: number) {
        this.mongoService.set("Pages");
        const addUrlQuery = url ? { url: url } : {};
        const user = await this.prismaService.users.findFirstOrThrow({ where: { uu_id: usersUUID }, include: { people: true } });
        const userType = await this.prismaService.user_types.findFirstOrThrow({ where: { token: token } })
        if (userType.type_token == this.tokens.employeeTypeToken) {
            const person = user.people[0]
            const pages = await this.mongoService.findMany({
                $and: [
                    { $or: [{ includeTokens: { $in: ['*'] } }, { includeTokens: { $in: [token] } }] },
                    { $nor: [{ excludeTokens: { $in: ['*'] } }, { excludeTokens: { $in: [token] } }] },
                    addUrlQuery,
                    { typeToken: this.tokens.employeeTypeToken },
                ],
            }, limit || 50, skip || 0, ['url'], ['asc'])
            if (!pages) { throw new NotFoundException(`Pages not found. User type: ${userType.type_token}`) }
            const employee = await this.prismaService.employees.findFirstOrThrow({
                where: { people_id: person.id, staff: { user_type_id: userType.id } },
                select: { uu_id: true, staff_uu_id: true }
            })
            const companyUUID = await this.prismaService.companies.findFirstOrThrow({
                where: { departments: { some: { duties: { some: { staff: { some: { uu_id: employee.staff_uu_id } } } } } } }, select: { uu_id: true }
            })
            this.mongoService.set(`Pages/${companyUUID.uu_id}`);
            const usersPages = await this.mongoService.findMany({ [employee.uu_id]: { $exists: true } });
            return pages;
        }
        else if (userType.type_token == this.tokens.occupantTypeToken) {
            const person = user.people
            const pages = await this.mongoService.findMany({
                $and: [
                    { $or: [{ includeTokens: { $in: ['*'] } }, { includeTokens: { $in: [token] } }] },
                    { $nor: [{ excludeTokens: { $in: ['*'] } }, { excludeTokens: { $in: [token] } }] },
                    addUrlQuery,
                    { typeToken: this.tokens.occupantTypeToken },
                ],
            }, limit || 50, skip || 0, ['url'], ['asc'])
            console.log('pages', pages)
            if (!pages) { throw new NotFoundException(`Pages not found. User type: ${userType.type_token}`) }
            const livingSpace = await this.prismaService.build_living_space.findFirstOrThrow({
                where: { person_id: person.id, occupant_types: { user_types: { id: userType.id } } },
                select: { uu_id: true, build_parts_id: true }
            })
            console.log('livingSpace', livingSpace)
            const buildUUID = await this.prismaService.build.findFirstOrThrow({
                where: { build_parts: { some: { id: livingSpace.build_parts_id } } }, select: { uu_id: true }
            })
            this.mongoService.set(`Pages/${buildUUID.uu_id}`);
            const usersPages = await this.mongoService.findMany({ [livingSpace.uu_id]: { $exists: true } });
            console.log('usersPages', usersPages)
            return Object.entries(pages).map(([key, value]: [string, any]) => {
                if (usersPages.some((page: any) => page[key])) { value.isSelected = true } else { value.isSelected = false }
                return value;
            })
        }
        else { throw new NotFoundException('User type not found') }
    }

    async configurePages(data: Record<string, any>, chunkIndex: number, chunkCount: number) {
        const count = Object.keys(data).length;
        console.log(`🧩 Chunk [${chunkIndex}/${chunkCount}] alındı. Kayıt sayısı: ${count}`);
        await this.saveChunkToDB(data, chunkIndex);
        return { message: 'Chunk işlendi', count };
    }
}