import BookRepository, {
    BookCoverQuery,
    BookQuery,
    ChapterBookResult, GuideLineAIQuery,
    GuideLineQuery, WorldElementValue
} from '../repositories/book.repository.js';
import type {
    IssueQuery,
    ActQuery,
    PlotPointQuery,
    IncidentQuery,
    WorldQuery
} from '../repositories/book.repository.js';
import System from '../System.js';
import { getUserEncryptionKey } from '../keyManager.js';
import path from "path";
import fs from "fs";
import BookRepo from "../repositories/book.repository.js";
import Chapter, {ActChapter, ChapterContentData, ChapterProps} from "./Chapter.js";
import UserRepo from "../repositories/user.repository.js";
import ChapterRepo from "@/electron/database/repositories/chapter.repository";
import {mainStyle} from "@/electron/database/models/EpubStyle";

export interface BookProps{
    id:string;
    type:string;
    authorId:string;
    title:string;
    subTitle?:string;
    summary?:string;
    serieId?:number;
    desiredReleaseDate?:string;
    desiredWordCount?:number;
    wordCount?:number;
    coverImage?:string;
    bookMeta?:string;
}

export interface GuideLine{
    tone:string;
    atmosphere:string;
    writingStyle:string;
    themes:string;
    symbolism: string;
    motifs: string;
    narrativeVoice: string;
    pacing: string;
    intendedAudience: string;
    keyMessages: string;
}

interface PlotPoint {
    plotPointId: string,
    title:string,
    summary:string,
    linkedIncidentId: string | null,
    chapters?:ActChapter[]
}

interface Incident {
    incidentId: string,
    title:string,
    summary:string,
    chapters?:ActChapter[]
}

export interface ExportData {
    buffer: Buffer;
    fileName: string;
}

export interface Act {
    id: number;
    summary: string | null;
    incidents?:Incident[];
    plotPoints?:PlotPoint[],
    chapters?:ActChapter[]
}

export interface Issue {
    id: string,
    name: string
}

export interface WorldElement {
    id: string;
    name: string;
    description: string;
    type?:number;
}

export interface WorldProps {
    id: string;
    name: string;
    history: string;
    politics: string;
    economy: string;
    religion: string;
    languages: string;
    laws: WorldElement[];
    biomes: WorldElement[];
    issues: WorldElement[];
    customs: WorldElement[];
    kingdoms: WorldElement[];
    climate: WorldElement[];
    resources: WorldElement[];
    wildlife: WorldElement[];
    arts: WorldElement[];
    ethnicGroups: WorldElement[];
    socialClasses: WorldElement[];
    importantCharacters: WorldElement[];
}

export interface GuideLineAI {
    narrativeType: number|null;
    dialogueType: number|null;
    globalResume: string|null;
    atmosphere: string|null;
    verbeTense: number|null;
    langue: number|null;
    currentResume: string|null;
    themes: string|null;
}

export interface CompleteBookData {
    bookId: string;
    title: string;
    subTitle: string;
    summary: string;
    coverImage: string;
    userInfos: {
        firstName: string;
        lastName: string;
        authorName: string;
    },
    chapters: CompleteChapterContent[];
}

export interface CompleteChapterContent {
    id: string;
    title: string;
    content: string;
    order: number;
    version?: number;
}

export default class Book {
    private readonly id: string;
    private type:string;
    private authorId: string;
    private title: string;
    private subTitle: string;
    private summary: string;
    private serieId: number;
    private desiredReleaseDate: string;
    private desiredWordCount:number;
    private wordCount: number;
    private cover: string;
    
    constructor(id:string,authorId?:string) {
        this.id = id;
        if (authorId){
            this.authorId = authorId;
        } else {
            this.authorId = '';
        }
        this.title = '';
        this.subTitle = '';
        this.summary = '';
        this.serieId = 0;
        this.desiredReleaseDate = '';
        this.desiredWordCount = 0;
        this.wordCount = 0;
        this.cover = '';
        this.type = '';
    }
    public static async getBooks(userId: string, lang: 'fr' | 'en' = 'fr'): Promise<BookProps[]> {
        const userKey: string | null = getUserEncryptionKey(userId);
        if (!userKey) {
            throw new Error(
                lang === 'fr' ? "Clé d'encryption utilisateur non trouvée." : 'User encryption key not found.'
            );
        }

        const books:BookQuery[] = BookRepository.fetchBooks(userId, lang);
        if (!books || books.length === 0) {
            return [];
        }
        
        return await Promise.all(
            books.map(async (book: BookQuery):Promise<BookProps> => {
                return {
                    id: book.book_id,
                    type: book.type,
                    authorId: book.author_id,
                    title: System.decryptDataWithUserKey(book.title, userKey),
                    subTitle: book.sub_title ? System.decryptDataWithUserKey(book.sub_title, userKey) : '',
                    summary: book.summary ? System.decryptDataWithUserKey(book.summary, userKey) : '',
                    serieId: book.serie_id || 0,
                    desiredReleaseDate: book.desired_release_date || '',
                    desiredWordCount: book.desired_word_count || 0,
                    wordCount: book.words_count || 0,
                    coverImage: book.cover_image ? await this.getPicture(userId, userKey, book.cover_image) : '',
                };
            }) ?? []
        );
    }
    
    public static async getCoverPicture(userId:string,bookId:string, lang: 'fr' | 'en' = 'fr'):Promise<string>{
        const query:BookCoverQuery = BookRepo.fetchBookCover(userId,bookId,lang);
        if (query){
            const userKey:string = getUserEncryptionKey(userId);
            return System.decryptDataWithUserKey(query.cover_image,userKey);
        } else {
            return '';
        }
    }
    
    public static async deleteCoverPicture(userId: string, bookId: string, lang: 'fr' | 'en' = 'fr'): Promise<boolean> {
        const coverName:string = await Book.getCoverPicture(userId,bookId,lang);
        return BookRepo.updateBookCover(bookId, '', userId, lang);
    }
    public static getPicture(userId: string, userKey: string, image: string, lang: 'fr' | 'en' = 'fr'): string {
        if (!image) return '';
        try {
            const decryptedFileName: string = System.decryptDataWithUserKey(image, userKey);
            const userDirectory: string = path.join('');
            fs.accessSync(userDirectory, fs.constants.R_OK);
            const data = fs.readFileSync(userDirectory);
            return data.toString('base64');
        } catch (err) {
            return '';
        }
    }
    
    public static async addBook(bookId: string | null, userId: string, title: string, subTitle: string, summary: string, type: string, serie: number, publicationDate: string, desiredWordCount: number, lang: 'fr' | 'en' = 'fr'): Promise<string> {
        let id:string = '';
        const userKey:string|null = getUserEncryptionKey(userId);

        const encryptedTitle:string = System.encryptDataWithUserKey(title, userKey);
        const encryptedSubTitle:string = subTitle ? System.encryptDataWithUserKey(subTitle, userKey) : '';
        const encryptedSummary:string = summary ? System.encryptDataWithUserKey(summary, userKey) : '';
        const hashedTitle:string = System.hashElement(title);
        const hashedSubTitle:string = subTitle ? System.hashElement(subTitle) : '';
        
        if (BookRepo.verifyBookExist(hashedTitle,hashedSubTitle,userId,lang)){
            throw new Error(lang === "fr" ? `Tu as déjà un livre intitulé ${title} - ${subTitle}.` : `You already have a book named ${title} - ${subTitle}.`);
        }
        if (bookId){
            id = bookId;
        } else {
            id = System.createUniqueId();
        }
        return BookRepo.insertBook(id,userId,encryptedTitle,hashedTitle,encryptedSubTitle,hashedSubTitle,encryptedSummary,type,serie,publicationDate,desiredWordCount,lang);
    }
    
    public static async getBook(userId:string,bookId: string): Promise<BookProps> {
        const book:Book = new Book(bookId);
        await book.getBookInfos(userId);
        return {
            id: book.getId(),
            type: book.getType(),
            authorId: book.getAuthorId(),
            title: book.getTitle(),
            subTitle: book.getSubTitle(),
            summary: book.getSummary(),
            serieId: book.getSerieId(),
            desiredReleaseDate: book.getDesiredReleaseDate(),
            desiredWordCount: book.getDesiredWordCount(),
            wordCount: book.getWordCount(),
            coverImage: book.getCover()
        };
    }
    
    public static async getGuideLine(userId: string, bookId: string, lang: 'fr' | 'en' = 'fr'): Promise<GuideLine | null> {
        const guideLineResponse: GuideLineQuery[] = BookRepo.fetchGuideLine(userId, bookId,lang);
        if (guideLineResponse.length === 0) {
            return null;
        }
        const guideLine: GuideLineQuery = guideLineResponse[0];
        const userKey: string = getUserEncryptionKey(userId);
        return {
            tone: guideLine.tone ? System.decryptDataWithUserKey(guideLine.tone, userKey) : '',
            atmosphere: guideLine.atmosphere ? System.decryptDataWithUserKey(guideLine.atmosphere, userKey) : '',
            writingStyle: guideLine.writing_style ? System.decryptDataWithUserKey(guideLine.writing_style, userKey) : '',
            themes: guideLine.themes ? System.decryptDataWithUserKey(guideLine.themes, userKey) : '',
            symbolism: guideLine.symbolism ? System.decryptDataWithUserKey(guideLine.symbolism, userKey) : '',
            motifs: guideLine.motifs ? System.decryptDataWithUserKey(guideLine.motifs, userKey) : '',
            narrativeVoice: guideLine['narrative-voice'] ? System.decryptDataWithUserKey(guideLine['narrative-voice'] as string, userKey) : '',
            pacing: guideLine.pacing ? System.decryptDataWithUserKey(guideLine.pacing, userKey) : '',
            intendedAudience: guideLine.intended_audience ? System.decryptDataWithUserKey(guideLine.intended_audience, userKey) : '',
            keyMessages: guideLine.key_messages ? System.decryptDataWithUserKey(guideLine.key_messages, userKey) : '',
        };
    }
    
    public static async updateGuideLine(userId: string, bookId: string, tone: string | null, atmosphere: string | null, writingStyle: string | null, themes: string | null, symbolism: string | null, motifs: string | null, narrativeVoice: string | null, pacing: string | null, keyMessages: string | null, intendedAudience: string | null, lang: 'fr' | 'en' = 'fr'): Promise<boolean> {
        const userKey: string = getUserEncryptionKey(userId);
        const encryptedTone: string = tone ? System.encryptDataWithUserKey(tone, userKey) : '';
        const encryptedAtmosphere: string = atmosphere ? System.encryptDataWithUserKey(atmosphere, userKey) : '';
        const encryptedWritingStyle: string = writingStyle ? System.encryptDataWithUserKey(writingStyle, userKey) : '';
        const encryptedThemes: string = themes ? System.encryptDataWithUserKey(themes, userKey) : '';
        const encryptedSymbolism: string = symbolism ? System.encryptDataWithUserKey(symbolism, userKey) : '';
        const encryptedMotifs: string = motifs ? System.encryptDataWithUserKey(motifs, userKey) : '';
        const encryptedNarrativeVoice: string = narrativeVoice ? System.encryptDataWithUserKey(narrativeVoice, userKey) : '';
        const encryptedPacing: string = pacing ? System.encryptDataWithUserKey(pacing, userKey) : '';
        const encryptedKeyMessages: string = keyMessages ? System.encryptDataWithUserKey(keyMessages, userKey) : '';
        const encryptedIntendedAudience: string = intendedAudience ? System.encryptDataWithUserKey(intendedAudience, userKey) : '';
        
        return BookRepo.updateGuideLine(userId, bookId, encryptedTone, encryptedAtmosphere, encryptedWritingStyle, encryptedThemes, encryptedSymbolism, encryptedMotifs, encryptedNarrativeVoice, encryptedPacing, encryptedKeyMessages, encryptedIntendedAudience, lang);
    }
    
    public static addNewIncident(userId: string, bookId: string, name: string, lang: 'fr' | 'en' = 'fr'): string {
        const userKey: string = getUserEncryptionKey(userId);
        const encryptedName:string = System.encryptDataWithUserKey(name,userKey);
        const hashedName:string = System.hashElement(name);
        const incidentId: string = System.createUniqueId();
        return BookRepo.insertNewIncident(incidentId, userId, bookId, encryptedName, hashedName, lang);
    }
    public static async getPlotPoints(userId:string, bookId: string,actChapters:ActChapter[], lang: 'fr' | 'en' = 'fr'):Promise<PlotPoint[]>{
        const query:PlotPointQuery[] = BookRepo.fetchAllPlotPoints(userId,bookId,lang);
        const userKey:string = getUserEncryptionKey(userId);
        let plotPoints:PlotPoint[] = [];
        if (query.length>0){
            for (const plot of query) {
                let chapters:ActChapter[] = [];
                for (const chapter of actChapters) {
                    if (chapter.plotPointId === plot.plot_point_id){
                        chapters.push(chapter);
                    }
                }
                plotPoints.push({
                    plotPointId: plot.plot_point_id,
                    title: plot.title ? System.decryptDataWithUserKey(plot.title,userKey) : '',
                    summary : plot.summary ? System.decryptDataWithUserKey(plot.summary,userKey) : '',
                    linkedIncidentId: plot.linked_incident_id,
                    chapters:chapters
                })
            }
        }
        return plotPoints;
    }
    public static async getIncitentsIncidents(userId:string,bookId: string,actChapters:ActChapter[], lang: 'fr' | 'en' = 'fr'):Promise<Incident[]>{
        const query:IncidentQuery[] = BookRepo.fetchAllIncitentIncidents(userId,bookId,lang);
        let incidents:Incident[] = [];
        const userKey:string = getUserEncryptionKey(userId);
        if (query.length>0){
            for (const incident of query) {
                let chapters:ActChapter[] = [];
                for (const chapter of actChapters) {
                    if (chapter.incidentId === incident.incident_id){
                        chapters.push(chapter);
                    }
                }
                incidents.push({
                    incidentId: incident.incident_id,
                    title: incident.title ? System.decryptDataWithUserKey(incident.title,userKey) : '',
                    summary : incident.summary ? System.decryptDataWithUserKey(incident.summary,userKey) : '',
                    chapters:chapters
                })
            }
        }
        return incidents;
    }
    
    public static removeIncident(userId: string, bookId: string, incidentId: string, lang: 'fr' | 'en' = 'fr'): boolean {
        return BookRepo.deleteIncident(userId, bookId, incidentId, lang);
    }
    
    public static async getActsData(userId: string, bookId: string, lang: 'fr' | 'en' = 'fr'): Promise<Act[]> {
        const userKey:string = getUserEncryptionKey(userId);
        const actChapters:ActChapter[] = Chapter.getAllChapterFromActs(userId, bookId, lang);
        const query: ActQuery[] = BookRepo.fetchAllActs(userId, bookId, lang);
        const incidents: Incident[] = await Book.getIncitentsIncidents(userId, bookId, actChapters);
        const plotsPoint: PlotPoint[] = await Book.getPlotPoints(userId, bookId, actChapters);
        let acts: Act[] = [];
        acts.push({
            id: 1,
            summary: '',
            chapters: actChapters.filter((chapter: ActChapter) => chapter.actId === 1)
        })
        acts.push({
            id: 2,
            summary: '',
            incidents: incidents ? incidents : [],
        })
        acts.push({
            id: 3,
            summary: '',
            plotPoints: plotsPoint ? plotsPoint : [],
        })
        acts.push({
            id: 4,
            summary: '',
            chapters: actChapters.filter((chapter: ActChapter) => chapter.actId === 4)
        })
        acts.push({
            id: 5,
            summary: '',
            chapters: actChapters.filter((chapter: ActChapter) => chapter.actId === 5)
        })
        if (query.length > 0) {
            for (const act of query) {
                acts[act.act_index - 1].summary = act.summary && userKey ? System.decryptDataWithUserKey(act.summary, userKey) : '';
            }
        }
        return acts;
    }
    public static async getIssuesFromBook(userId:string,bookId:string, lang: 'fr' | 'en' = 'fr'):Promise<Issue[]>{
        const query:IssueQuery[] = BookRepo.fetchIssuesFromBook(userId,bookId,lang);
        const userKey:string = getUserEncryptionKey(userId);
        let issues:Issue[] = [];
        if (query.length>0){
            for (const issue of query) {
                issues.push({
                    id:issue.issue_id,
                    name: System.decryptDataWithUserKey(issue.name,userKey)
                })
            }
        }
        return issues;
    }
    
    static updateBookBasicInformation(userId: string, title: string, subTitle: string, summary: string, publicationDate: string, wordCount: number, bookId: string, lang: 'fr' | 'en' = 'fr'): boolean {
        const userKey:string = getUserEncryptionKey(userId);
        const encryptedTitle:string = System.encryptDataWithUserKey(title, userKey);
        const encryptedSubTitle:string = subTitle ? System.encryptDataWithUserKey(subTitle, userKey) : '';
        const encryptedSummary:string = summary ? System.encryptDataWithUserKey(summary, userKey) : '';
        const hashedTitle:string = System.hashElement(title);
        const hashedSubTitle:string = subTitle ? System.hashElement(subTitle) : '';
        return BookRepo.updateBookBasicInformation(userId, encryptedTitle, hashedTitle, encryptedSubTitle, hashedSubTitle, encryptedSummary, publicationDate, wordCount, bookId, lang);
    }
    
    static addNewPlotPoint(userId: string, bookId: string, incidentId: string, name: string, lang: 'fr' | 'en' = 'fr'): string {
        const userKey:string = getUserEncryptionKey(userId);
        const encryptedName:string = System.encryptDataWithUserKey(name, userKey);
        const hashedName:string = System.hashElement(name);
        const plotPointId: string = System.createUniqueId();
        return BookRepo.insertNewPlotPoint(plotPointId, userId, bookId, encryptedName, hashedName, incidentId, lang);
    }
    
    static removePlotPoint(userId: string, plotId: string, lang: 'fr' | 'en' = 'fr'): boolean{
        return BookRepo.deletePlotPoint(userId, plotId, lang);
    }
    
    public static addNewIssue(userId: string, bookId: string, name: string, lang: 'fr' | 'en' = 'fr'): string {
        const userKey:string = getUserEncryptionKey(userId);
        const encryptedName:string = System.encryptDataWithUserKey(name,userKey);
        const hashedName:string = System.hashElement(name);
        const issueId: string = System.createUniqueId();
        return BookRepo.insertNewIssue(issueId, userId, bookId, encryptedName, hashedName,lang);
    }
    
    public static removeIssue(userId: string, issueId: string, lang: 'fr' | 'en' = 'fr'): boolean{
        return BookRepo.deleteIssue(userId, issueId,lang);
    }
    
    public static async updateAct(acts: Act[], userId: string, bookId: string, userKey: string, lang: 'fr' | 'en' = 'fr'): Promise<boolean> {
        for (const act of acts) {
            const incidents: Incident[] = act.incidents ? act.incidents : [];
            const actId: number = act.id;
            if (actId === 1 || actId === 4 || actId === 5) {
                const actSummary: string = act.summary ? System.encryptDataWithUserKey(act.summary, userKey) : '';
                try {
                    BookRepo.updateActSummary(userId, bookId, actId, actSummary,lang);
                } catch (e: unknown) {
                    const actSummaryId: string = System.createUniqueId();
                    BookRepo.insertActSummary(actSummaryId, userId, bookId, actId, actSummary,lang);
                }
                if (act.chapters) {
                    Chapter.updateChapterInfos(act.chapters, userId, actId, bookId, null, null, lang);
                }
            } else if (actId === 2) {
                for (const incident of incidents) {
                    const incidentSummary: string = incident.summary ? System.encryptDataWithUserKey(incident.summary, userKey) : '';
                    const incidentId: string = incident.incidentId;
                    const incidentName: string = incident.title;
                    const incidentHashedName: string = System.hashElement(incidentName);
                    const encryptedIncidentName: string = System.encryptDataWithUserKey(incidentName, userKey);
                    BookRepo.updateIncident(userId, bookId, incidentId, encryptedIncidentName, incidentHashedName, incidentSummary, lang);
                    if (incident.chapters) {
                        Chapter.updateChapterInfos(incident.chapters, userId, actId, bookId, incidentId, null, lang);
                    }
                }
            } else {
                const plotPoints: PlotPoint[] = act.plotPoints ? act.plotPoints : [];
                for (const plotPoint of plotPoints) {
                    const plotPointSummary: string = plotPoint.summary ? System.encryptDataWithUserKey(plotPoint.summary, userKey) : '';
                    const plotPointId: string = plotPoint.plotPointId;
                    const plotPointName: string = plotPoint.title;
                    const plotPointHashedName: string = System.hashElement(plotPointName);
                    const encryptedPlotPointName: string = System.encryptDataWithUserKey(plotPointName, userKey);
                    BookRepo.updatePlotPoint(userId, bookId, plotPointId, encryptedPlotPointName, plotPointHashedName, plotPointSummary, lang);
                    if (plotPoint.chapters) {
                        Chapter.updateChapterInfos(plotPoint.chapters, userId, actId, bookId, null, plotPointId, lang);
                    }
                }
            }
        }
        return true;
    }

    public static updateStory(userId: string, bookId: string, acts: Act[], mainChapters: ChapterProps[], lang: 'fr' | 'en' = 'fr'): boolean {
        const userKey: string = getUserEncryptionKey(userId);
        Book.updateAct(acts, userId, bookId, userKey, lang);
        for (const chapter of mainChapters) {
            const chapterId: string = chapter.chapterId;
            const chapterTitle: string = chapter.title;
            const chapterHashedTitle: string = System.hashElement(chapterTitle);
            const encryptedTitle: string = System.encryptDataWithUserKey(chapterTitle, userKey);
            const chapterOrder: number = chapter.chapterOrder;
            ChapterRepo.updateChapter(userId, chapterId, encryptedTitle, chapterHashedTitle, chapterOrder, lang);
        }
        return true;
    }

    public static addNewWorld(userId: string, bookId: string, worldName: string, lang: 'fr' | 'en' = 'fr'): string {
        const userKey: string = getUserEncryptionKey(userId);
        const hashedName: string = System.hashElement(worldName);
        if (BookRepo.checkWorldExist(userId, bookId, hashedName, lang)) {
            throw new Error(lang === "fr" ? `Tu as déjà un monde ${worldName}.` : `You already have a world named ${worldName}.`);
        }
        const encryptedName: string = System.encryptDataWithUserKey(worldName, userKey);
        const worldId: string = System.createUniqueId();
        return BookRepo.insertNewWorld(worldId, userId, bookId, encryptedName, hashedName, lang);
    }

    public static getWorlds(userId: string, bookId: string, lang: 'fr' | 'en' = 'fr'): WorldProps[] {
        const worldElements: WorldQuery[] = BookRepo.fetchWorlds(userId, bookId, lang);
        const userKey: string = getUserEncryptionKey(userId);
        let worlds: WorldProps[] = []
        for (const element of worldElements) {
            const existWorld: WorldProps | undefined = worlds.find((world: WorldProps) => world.id === element.world_id);

            if (!existWorld) {
                const newWorld: WorldProps = {
                    id: element.world_id,
                    name: System.decryptDataWithUserKey(element.world_name, userKey),
                    history: element.history ? System.decryptDataWithUserKey(element.history, userKey) : '',
                    politics: element.politics ? System.decryptDataWithUserKey(element.politics, userKey) : '',
                    economy: element.economy ? System.decryptDataWithUserKey(element.economy, userKey) : '',
                    religion: element.religion ? System.decryptDataWithUserKey(element.religion, userKey) : '',
                    languages: element.languages ? System.decryptDataWithUserKey(element.languages, userKey) : '',
                    laws: [],
                    biomes: [],
                    issues: [],
                    customs: [],
                    kingdoms: [],
                    climate: [],
                    resources: [],
                    wildlife: [],
                    arts: [],
                    ethnicGroups: [],
                    socialClasses: [],
                    importantCharacters: [],
                };
                
                worlds.push(newWorld);

                if (element.element_type) {
                    const newElement = {
                        id: element.element_id as string,
                        name: element.element_name ? System.decryptDataWithUserKey(element.element_name, userKey) : '',
                        description: element.element_description ? System.decryptDataWithUserKey(element.element_description, userKey) : ''
                    };
                    
                    switch (element.element_type) {
                        case 1:
                            worlds[worlds.length - 1].laws.push(newElement);
                            break;
                        case 2:
                            worlds[worlds.length - 1].biomes.push(newElement);
                            break;
                        case 3:
                            worlds[worlds.length - 1].issues.push(newElement);
                            break;
                        case 4:
                            worlds[worlds.length - 1].customs.push(newElement);
                            break;
                        case 5:
                            worlds[worlds.length - 1].kingdoms.push(newElement);
                            break;
                        case 6:
                            worlds[worlds.length - 1].climate.push(newElement);
                            break;
                        case 7:
                            worlds[worlds.length - 1].resources.push(newElement);
                            break;
                        case 8:
                            worlds[worlds.length - 1].wildlife.push(newElement);
                            break;
                        case 9:
                            worlds[worlds.length - 1].arts.push(newElement);
                            break;
                        case 10:
                            worlds[worlds.length - 1].ethnicGroups.push(newElement);
                            break;
                        case 11:
                            worlds[worlds.length - 1].socialClasses.push(newElement);
                            break;
                        case 12:
                            worlds[worlds.length - 1].importantCharacters.push(newElement);
                            break;
                    }
                }
            } else {
                const existingElement = {
                    id: element.element_id as string,
                    name: element.element_name ? System.decryptDataWithUserKey(element.element_name, userKey) : '',
                    description: element.element_description ? System.decryptDataWithUserKey(element.element_description, userKey) : ''
                };
                
                switch (element.element_type) {
                    case 1:
                        existWorld.laws.push(existingElement);
                        break;
                    case 2:
                        existWorld.biomes.push(existingElement);
                        break;
                    case 3:
                        existWorld.issues.push(existingElement);
                        break;
                    case 4:
                        existWorld.customs.push(existingElement);
                        break;
                    case 5:
                        existWorld.kingdoms.push(existingElement);
                        break;
                    case 6:
                        existWorld.climate.push(existingElement);
                        break;
                    case 7:
                        existWorld.resources.push(existingElement);
                        break;
                    case 8:
                        existWorld.wildlife.push(existingElement);
                        break;
                    case 9:
                        existWorld.arts.push(existingElement);
                        break;
                    case 10:
                        existWorld.ethnicGroups.push(existingElement);
                        break;
                    case 11:
                        existWorld.socialClasses.push(existingElement);
                        break;
                    case 12:
                        existWorld.importantCharacters.push(existingElement);
                        break;
                }
            }
        }
        return worlds;
    }
    
    public static updateWorld(userId: string, world: WorldProps, lang: 'fr' | 'en' = 'fr'): boolean {
        const userKey: string = getUserEncryptionKey(userId);
        const encryptName: string = world.name ? System.encryptDataWithUserKey(world.name, userKey) : '';
        const encryptHistory: string = world.history ? System.encryptDataWithUserKey(world.history, userKey) : '';
        const encryptPolitics: string = world.politics ? System.encryptDataWithUserKey(world.politics, userKey) : '';
        const encryptEconomy: string = world.economy ? System.encryptDataWithUserKey(world.economy, userKey) : '';
        const encryptReligion: string = world.religion ? System.encryptDataWithUserKey(world.religion, userKey) : '';
        const encryptLanguages: string = world.languages ? System.encryptDataWithUserKey(world.languages, userKey) : '';
        let elements: WorldElementValue[] = [];
        const elementTypes: { key: keyof WorldProps, elements: WorldElement[] }[] = [
            {key: 'laws', elements: world.laws},
            {key: 'biomes', elements: world.biomes},
            {key: 'issues', elements: world.issues},
            {key: 'customs', elements: world.customs},
            {key: 'kingdoms', elements: world.kingdoms},
            {key: 'climate', elements: world.climate},
            {key: 'resources', elements: world.resources},
            {key: 'wildlife', elements: world.wildlife},
            {key: 'arts', elements: world.arts},
            {key: 'ethnicGroups', elements: world.ethnicGroups},
            {key: 'socialClasses', elements: world.socialClasses},
            {key: 'importantCharacters', elements: world.importantCharacters}
        ];

        elementTypes.forEach(({key, elements: elementsList}) => {
            elements = elements.concat(elementsList.map((element: WorldElement) => {
                const encryptedName: string = System.encryptDataWithUserKey(element.name, userKey);
                const hashedName: string = System.hashElement(element.name);
                const encryptedDescription: string = element.description ? System.encryptDataWithUserKey(element.description, userKey) : '';
                const elementType: number = Book.getElementTypes(key);

                return {
                    id: element.id,
                    name: encryptedName,
                    hashedName: hashedName,
                    description: encryptedDescription,
                    type: elementType
                };
            }));
        });

        BookRepo.updateWorld(userId, world.id, encryptName, System.hashElement(world.name), encryptHistory, encryptPolitics, encryptEconomy, encryptReligion, encryptLanguages, lang);
        return BookRepo.updateWorldElements(userId, elements, lang);
    }

    public static addNewElementToWorld(userId: string, worldId: string, elementName: string, elementType: string, lang: 'fr' | 'en' = 'fr'): string {
        const userKey: string = getUserEncryptionKey(userId);
        const hashedName: string = System.hashElement(elementName);
        if (BookRepo.checkElementExist(worldId, hashedName, lang)) {
            throw new Error(lang === "fr" ? `Vous avez déjà un élément avec ce nom ${elementName}.` : `You already have an element named ${elementName}.`);
        }
        const elementTypeId: number = Book.getElementTypes(elementType);
        const encryptedName: string = System.encryptDataWithUserKey(elementName, userKey);
        const elementId: string = System.createUniqueId();
        return BookRepo.insertNewElement(userId, elementId, elementTypeId, worldId, encryptedName, hashedName, lang);
    }
    public static getElementTypes(elementType:string):number{
        switch (elementType){
            case 'laws':
                return 1;
            case 'biomes':
                return 2;
            case 'issues':
                return 3;
            case 'customs':
                return 4;
            case 'kingdoms':
                return 5;
            case 'climate':
                return 6;
            case 'resources':
                return 7;
            case 'wildlife':
                return 8;
            case 'arts':
                return 9;
            case 'ethnicGroups':
                return 10;
            case 'socialClasses':
                return 11;
            case 'importantCharacters':
                return 12;
            default:
                return 0;
        }
    }
    
    public static removeElementFromWorld(userId: string, elementId: string, lang: 'fr' | 'en' = 'fr'): boolean {
        return BookRepo.deleteElement(userId, elementId, lang);
    }

    public static removeBook(userId: string, bookId: string, lang: 'fr' | 'en' = 'fr'): boolean {
        return BookRepo.deleteBook(userId, bookId, lang);
    }

    static getGuideLineAI(userId: string, bookId: string, lang: 'fr' | 'en' = 'fr'): GuideLineAI {
        const userKey: string = getUserEncryptionKey(userId);
        try {
            const guideLine: GuideLineAIQuery = BookRepo.fetchGuideLineAI(userId, bookId, lang);
            return {
                narrativeType: guideLine.narrative_type,
                dialogueType: guideLine.dialogue_type,
                globalResume: guideLine.global_resume ? System.decryptDataWithUserKey(guideLine.global_resume, userKey) : '',
                atmosphere: guideLine.atmosphere ? System.decryptDataWithUserKey(guideLine.atmosphere, userKey) : '',
                verbeTense: guideLine.verbe_tense,
                themes: guideLine.themes ? System.decryptDataWithUserKey(guideLine.themes, userKey) : '',
                currentResume: guideLine.current_resume ? System.decryptDataWithUserKey(guideLine.current_resume, userKey) : '',
                langue: guideLine.langue
            }
        } catch (e: unknown) {
            if (e instanceof Error && e.message.includes('not found')) {
                return {
                    narrativeType: 0,
                    dialogueType: 0,
                    globalResume: '',
                    atmosphere: '',
                    verbeTense: 0,
                    themes: '',
                    currentResume: '',
                    langue: 0
                }
            }
            if (e instanceof Error) {
                throw new Error(e.message);
            } else {
                console.error(lang === 'fr' ? "Erreur inconnue lors de la récupération de la ligne directrice de l'IA." : "Unknown error while fetching AI guideline.");
                throw new Error(lang === 'fr' ? "Erreur inconnue lors de la récupération de la ligne directrice de l'IA." : "Unknown error while fetching AI guideline.");
            }
        }
    }

    public static setAIGuideLine(userId: string, bookId: string, narrativeType: number, dialogueType: number, plotSummary: string, toneAtmosphere: string, verbTense: number, language: number, themes: string, lang: 'fr' | 'en' = 'fr'): boolean {
        const userKey: string = getUserEncryptionKey(userId);
        const encryptedPlotSummary: string = plotSummary ? System.encryptDataWithUserKey(plotSummary, userKey) : '';
        const encryptedToneAtmosphere: string = toneAtmosphere ? System.encryptDataWithUserKey(toneAtmosphere, userKey) : '';
        const encryptedThemes: string = themes ? System.encryptDataWithUserKey(themes, userKey) : '';
        return BookRepo.insertAIGuideLine(userId, bookId, narrativeType, dialogueType, encryptedPlotSummary, encryptedToneAtmosphere, verbTense, language, encryptedThemes, lang);
    }
    
    public getId(): string {
        return this.id;
    }
    
    public getAuthorId(): string {
        return this.authorId;
    }
    
    public getTitle(): string {
        return this.title;
    }
    
    public getSubTitle(): string {
        return this.subTitle;
    }
    
    public getSummary(): string {
        return this.summary;
    }
    
    public getSerieId(): number {
        return this.serieId;
    }
    
    public getDesiredReleaseDate(): string {
        return this.desiredReleaseDate;
    }
    
    public getDesiredWordCount(): number {
        return this.desiredWordCount;
    }
    
    public getWordCount(): number {
        return this.wordCount;
    }
    
    public getCover(): string {
        return this.cover;
    }
    
    public getType(): string {
        return this.type;
    }
    
    static completeBookData(userId: string, id: string, lang: 'fr' | 'en' = 'fr'): CompleteBookData {
        const data = BookRepo.fetchBook(id, userId, lang);
        const chapters: ChapterBookResult[] = BookRepo.fetchCompleteBookChapters(id, lang);
        const userKey: string = getUserEncryptionKey(userId);
        const userInfos = UserRepo.fetchAccountInformation(userId, lang);

        const bookTitle: string = data.title ? System.decryptDataWithUserKey(data.title, userKey) : '';
        const decryptedChapters: any[] = [];

        for (const chapter of chapters) {
            if (!chapter.meta_chapter) continue;
            if (!chapter.meta_chapter_content) continue;
            decryptedChapters.push({
                id: '',
                title: chapter.title ? System.decryptDataWithUserKey(chapter.title, userKey) : '',
                content: chapter.content ? System.decryptDataWithUserKey(chapter.content, userKey) : '',
                order: chapter.chapter_order
            })
        }
        const coverImage: string = data.cover_image ? Book.getPicture(userId, userKey, data.cover_image, lang) : '';
        return {
            bookId: id,
            title: bookTitle,
            subTitle: data.sub_title ? System.decryptDataWithUserKey(data.sub_title, userKey) : '',
            summary: data.summary ? System.decryptDataWithUserKey(data.summary, userKey) : '',
            coverImage: coverImage,
            userInfos: {
                firstName: userInfos.first_name ? System.decryptDataWithUserKey(userInfos.first_name, userKey) : '',
                lastName: userInfos.last_name ? System.decryptDataWithUserKey(userInfos.last_name, userKey) : '',
                authorName: userInfos.author_name ? System.decryptDataWithUserKey(userInfos.author_name, userKey) : '',
            },
            chapters: decryptedChapters
        };
    }
    
    static getChaptersOrSheet(bookChapters: CompleteChapterContent[]): ChapterContentData[] {
        const chapters: ChapterContentData[] = [];
        const haveSheet: CompleteChapterContent | undefined = bookChapters.find((chapter: CompleteChapterContent): boolean => chapter.order === -1);
        const haveChapter: CompleteChapterContent | undefined = bookChapters.find((chapter: CompleteChapterContent): boolean => chapter.order > 0);
        if (haveSheet && !haveChapter) {
            chapters.push({
                title: haveSheet.title,
                chapterOrder: haveSheet.order,
                content: System.htmlToText(Chapter.tipTapToHtml(JSON.parse(haveSheet.content))),
                wordsCount: 0,
                version: haveSheet.version || 0
            });
        } else if (haveChapter) {
            for (const chapter of bookChapters) {
                if (chapter.order < 0) continue;
                chapters.push({
                    title: chapter.title,
                    chapterOrder: chapter.order,
                    content: System.htmlToText(Chapter.tipTapToHtml(JSON.parse(chapter.content))),
                    wordsCount: 0,
                    version: chapter.version || 0
                });
            }
        }
        return chapters;
    }

    static getAllChapters(userId: string, bookId: string, lang: 'fr' | 'en' = 'fr'): ChapterContentData[] {
        try {
            const book: CompleteBookData = Book.completeBookData(userId, bookId, lang);
            return Book.getChaptersOrSheet(book.chapters);
        } catch (e: unknown) {
            return [];
        }
    }
    
    public getBookInfos(userId: string, lang: 'fr' | 'en' = 'fr'): void {
        const book: BookQuery = BookRepo.fetchBook(this.id, userId, lang);
        const userKey: string = getUserEncryptionKey(userId);
        if (book) {
            this.authorId = book.author_id;
            this.type = book.type;
            this.title = book.title ? System.decryptDataWithUserKey(book.title, userKey) : '';
            this.subTitle = book.sub_title ? System.decryptDataWithUserKey(book.sub_title, userKey) : '';
            this.summary = book.summary ? System.decryptDataWithUserKey(book.summary, userKey) : '';
            this.serieId = book.serie_id ?? 0;
            this.desiredReleaseDate = book.desired_release_date ?? '';
            this.desiredWordCount = book.desired_word_count ?? 0;
            this.wordCount = book.words_count ?? 0;
            this.cover = book.cover_image ? Book.getPicture(userId, userKey, book.cover_image, lang) : '';
        } else {
            this.authorId = '';
            this.title = '';
            this.subTitle = '';
            this.summary = '';
            this.serieId = 0;
            this.desiredReleaseDate = '';
            this.wordCount = 0;
            this.cover = '';
        }
    }
}