import { Injectable, HttpException, HttpStatus } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { responseMessages } from '../../messages/response-messages';
import { Keywords } from "../../entities/keywords.entity";
import { KeywordTranslation } from "../../entities/keyword-translations.entity";

@Injectable()
export class KeywordsRepository {
    constructor(
        @InjectRepository(Keywords)
        private Keywords: Repository<Keywords>,
        @InjectRepository(KeywordTranslation)
        private KeywordTranslation: Repository<KeywordTranslation>,
    ) { }

    async createData(request: any) {
        const result = await this.Keywords.insert(request);
        if (!result.identifiers || result.identifiers.length === 0) {
            throw new HttpException(responseMessages.en.keywords.create_failed, HttpStatus.UNPROCESSABLE_ENTITY);
        }

        return { id: result.identifiers[0].id };
    }

    async createTranslations(keywordId: string, translations: any[]) {
        const translationEntities = translations.map(trans => {
            const translation = new KeywordTranslation();
            translation.keywordRef = { id: keywordId } as Keywords;
            translation.language_code = trans.language_code;
            translation.keyword = trans.keyword;
            translation.setDefaults();
            return translation;
        });

        await this.KeywordTranslation.save(translationEntities);
        return;
    }

    async updateTranslations(keywordId: string, translations: any[]) {
        // Delete existing translations for this keyword using query builder for proper relation handling
        await this.KeywordTranslation
            .createQueryBuilder()
            .delete()
            .where("keyword_id = :keywordId", { keywordId })
            .execute();

        // Create new translations
        await this.createTranslations(keywordId, translations);
        return;
    }
}