import { Injectable, HttpException, HttpStatus } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { responseMessages } from '../../messages/response-messages';
import { FileManagers } from '../../entities/file-managers.entity';
import { FileLogs } from '../../entities/file-logs.entity';
import { Users } from '../../entities/users.entity';
import { SocialMedias } from '../../entities/social-medias.entity';
import { InstagramProfiles } from '../../entities/instagram-profile.entity';
import { FacebookPages } from '../../entities/facebook-pages.entity';
import { YoutubeChannels } from '../../entities/youtube-channel.entity';
import { TikTokProfiles } from '../../entities/tiktok-profile.entity';
import { XiaohongshuProfiles } from '../../entities/xiaohongshu-profile.entity';
import slugify from 'slugify';
const { slugify: translitSlug } = require("transliteration");

@Injectable()
export class FileManagerRepository {
    constructor(
        @InjectRepository(Users)
        private Users: Repository<Users>,

        @InjectRepository(FileManagers)
        private FileManagers: Repository<FileManagers>,

        @InjectRepository(FileLogs)
        private FileLogs: Repository<FileLogs>,

        @InjectRepository(SocialMedias)
        private SocialMedias: Repository<SocialMedias>,

        @InjectRepository(InstagramProfiles)
        private InstagramProfiles: Repository<InstagramProfiles>,

        @InjectRepository(FacebookPages)
        private FacebookPages: Repository<FacebookPages>,

        @InjectRepository(YoutubeChannels)
        private YoutubeChannels: Repository<YoutubeChannels>,

        @InjectRepository(TikTokProfiles)
        private TikTokProfiles: Repository<TikTokProfiles>,

        @InjectRepository(XiaohongshuProfiles)
        private XiaohongshuProfiles: Repository<XiaohongshuProfiles>,
    ) { }

    async createFileManagerwithObject(request: any) {
        const result = await this.FileManagers.insert(request);
        if (result.raw.affected == 0) { return }

        const resultObject = await this.FileManagers.findOne({ where: { id: result.identifiers[0].id } });

        return resultObject;
    }

    async createFileLogs(request: any) {
        const result = await this.FileLogs.insert(request);
        if (result.raw.affected == 0) { return }

        return;
    }

    // Function to generate slug
    async generateSlug1(firstName: any, lastName: any) {
        // Create base slug from first and last name
        let baseSlug = `${firstName} ${lastName}`
            .toLowerCase()
            .replace(/[^a-z0-9\s-]/g, '') // Remove any characters that aren't alphanumeric or spaces
            .replace(/\s+/g, '-')         // Replace spaces with hyphens
            .replace(/-+/g, '-');         // Remove extra hyphens

        const randomPart = Math.random().toString(36).substring(2, 6); // 4 characters

        const newSlug = `${baseSlug}-${randomPart}`;

        const existSlug = await this.Users.findOne({ where: { slug: newSlug } });
        if (existSlug) {
            await this.generateSlug(firstName, lastName);
        }

        return `${baseSlug}-${randomPart}`;
    }

    async generateSlug(firstName, lastName = '') {

        // Generate initial slug from the name
        let slug = slugify(translitSlug(`${firstName} ${lastName}`), { lower: true, strict: true });

        // Check if the slug exists
        let existing = await this.Users.findOne({ where: { slug }, withDeleted: true });

        // If slug exists, append a 4-character random string
        if (existing) {
            const randomString = Math.random().toString(36).substring(2, 6); // Generate a 4-character random string
            slug = `${slug}-${randomString}`;
        }

        return slug;
    }

    async createUserwithObject(request: any) {
        const result = await this.Users.insert(request);
        if (result.raw.affected == 0) { return }

        const resultObject = await this.Users.findOne({ where: { id: result.identifiers[0].id } });

        return resultObject;
    }

    async ceateSocialMediaWithObject(request: any) {
        const result = await this.SocialMedias.insert(request);
        if (result.raw.affected == 0) { return }

        const resultObject = await this.SocialMedias.findOne({ where: { id: result.identifiers[0].id } });

        return resultObject;
    }

    async ceateInstaProfile(request: any) {
        await this.InstagramProfiles.insert(request);
        return;
    }

    async ceateFacebookPage(request: any) {
        await this.FacebookPages.insert(request);
        return;
    }

    async ceateYoutubeChannel(request: any) {
        await this.YoutubeChannels.insert(request);
        return;
    }

    async ceateTikTokProfile(request: any) {
        await this.TikTokProfiles.insert(request);
        return;
    }

    async ceateXiProfile(request: any) {
        await this.XiaohongshuProfiles.insert(request);
        return;
    }
}