const express = require('express');

module.exports = function (options) {
    const db = options.db;
    var router = express.Router();

    router.route('/t/:id')
        .post(function(request, response, next) {
            db.TranslationArtifactVersion.findByPk(request.params.id, {
                include: [
                    {
                        association: db.TranslationArtifactVersion.Forks,
                        required: false,
                        where: {
                            // TODO: use entityId as query...
                            creatorId: request.user.id 
                        }
                    },
                    {
                        association: db.TranslationArtifactVersion.TranslationChapters,
                        include: [
                            {
                                association: db.TranslationChapter.TranslationChunks,
                                include: [
                                    {
                                        association: db.TranslationChunk.Translation
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }).then(async (translationArtifactVersion) => {
                if (translationArtifactVersion) {
                    // fork check if forkable...
                    const forkedTranslationArtifactVersion = await db.TranslationArtifactVersion.create({
                        creatorId: request.user.id,
                        name: translationArtifactVersion.name,
                        artifactVersionId: translationArtifactVersion.artifactVersionId,
                        userId: request.user.id,
                        dialectId: translationArtifactVersion.dialectId,
                        forkedFromId: translationArtifactVersion.id,
                        owner: {
                            ownerEntities: [
                                {
                                    entityId: request.user.individualEntityUser.entityUser.entityId,
                                }
                            ]
                        },
                        translationChapters: translationArtifactVersion.translationChapters.map(translationChapter => {
                            return {
                                creatorId: request.user.id,
                                chapterId: translationChapter.chapterId,
                                translationChunks: translationChapter.translationChunks.map(translationChunk => {
                                    const tc = {
                                        creatorId: request.user.id,
                                        chunkId: translationChunk.chunkId,
                                        text: translationChunk.text,
                                        index: translationChunk.index,
                                    }
                                    // if (translationChunk.translation) {
                                    //     tc.translation = {
                                    //         creatorId: translationChunk.translation.creatorId,
                                    //         text: translationChunk.translation.text,
                                    //         // TODO: Might want to create translations separately...
                                    //         translationArtifactVersionId: translationChunk.translation.translationArtifactVersionId,
                                    //     }
                                    // }
                                    return tc
                                })
                            }
                        })
                    }, {
                        include: [
                            {
                                association: db.TranslationArtifactVersion.TranslationChapters,
                                include: [
                                    {
                                        association: db.TranslationChapter.TranslationChunks,
                                    }
                                ]
                            },
                            {
                                association: db.TranslationArtifactVersion.Owner,
                                include: [
                                    {
                                        association: db.Owner.OwnerEntities
                                    }
                                ]
                            }
                        ]
                    })
                    if (forkedTranslationArtifactVersion) {
                        return response.redirect(`/v/${forkedTranslationArtifactVersion.artifactVersionId}/translations/${forkedTranslationArtifactVersion.id}`)
                    }
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })
    
    router.route('/e/:id')
        .get(function(request, response, next) {
            db.ArtifactVersion.findByPk(request.params.id, {
                include: [
                    {
                        association: db.ArtifactVersion.Artifact
                    }
                ]
            }).then(artifactVersion => {
                if (artifactVersion) {
                    response.display("fork-artifact-version", {
                        user: request.user,
                        pageTitle: "Add translation - Mantra",
                        artifactVersion: artifactVersion
                    })
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })
        .post(async function(request, response, next) {
            const dialectTokens = request.body.dialect?.split(":")
            if (dialectTokens?.length == 2) {
                const countryId = dialectTokens[0].split("-")[0]
                const languageId = dialectTokens[0].split("-")[1]

                const dialect = await db.Dialect.findOne({
                    where: {
                        countryId: countryId,
                        languageId: languageId
                    }
                })

                if (dialect) {
                    const artifactVersion = await db.ArtifactVersion.findByPk(request.params.id, {
                        include: [
                            {
                                association: db.ArtifactVersion.Artifact
                            },
                            {
                                association: db.ArtifactVersion.TranslationArtifactVersions,
                                required: false,
                                where: {
                                    dialectId: dialect.id,
                                }
                            },
                            {
                                association: db.ArtifactVersion.Chapters,
                                include: [
                                    {
                                        association: db.Chapter.Chunks
                                    }
                                ]
                            }
                        ]
                    })

                    if (artifactVersion) {
                        const forkedTranslationArtifactVersion = await forkArtifactVersion(
                            artifactVersion, 
                            dialect, 
                            request.user.id,
                            request.user.individualEntityUser.entityUser.entityId
                        )
                        if (forkedTranslationArtifactVersion) {
                            return response.redirect(`/v/${forkedTranslationArtifactVersion.artifactVersionId}/translations/${forkedTranslationArtifactVersion.id}`)
                        } 
                    }
                }
            }
            next()
        })

    const forkArtifactVersion = (artifactVersion, dialect, userId, entityId) => {
        if (artifactVersion.translationArtifactVersions.length == 0) {
            // create a translationArtifactVersion with a new dialect...
            return db.TranslationArtifactVersion.create({
                creatorId: userId,
                name: dialect.name,
                artifactVersionId: artifactVersion.id,
                dialectId: dialect.id,
                userId: userId,
                owner: {
                    ownerEntities: [
                        {
                            entityId: entityId,
                        }
                    ]
                },
                translationChapters: artifactVersion.chapters.map(chapter => {
                    return {
                        creatorId: userId,
                        chapterId: chapter.id,
                        translationChunks: chapter.chunks.map(chunk => {
                            return {
                                creatorId: userId,
                                chunkId: chunk.id,
                                text: chunk.text,
                                index: chunk.index
                            }
                        })
                    }
                })
            }, {
                include: [
                    {
                        association: db.TranslationArtifactVersion.Owner,
                        include: [
                            {
                                association: db.Owner.OwnerEntities
                            }
                        ]
                    },
                    {
                        association: db.TranslationArtifactVersion.TranslationChapters,
                        include: [
                            {
                                association: db.TranslationChapter.TranslationChunks
                            }
                        ]
                    },
                ]
            })
        } else {
            return db.TranslationArtifactVersion.create({
                creatorId: userId,
                name: artifactVersion.translationArtifactVersions[0].name,
                artifactVersionId: artifactVersion.translationArtifactVersions[0].artifactVersionId,
                userId: userId,
                dialectId: artifactVersion.translationArtifactVersions[0].dialectId,
                forkedFromId: artifactVersion.translationArtifactVersions[0].id,
                owner: {
                    ownerEntities: [
                        {
                            entityId: entityId,
                        }
                    ]
                },
                translationChapters: artifactVersion.chapters.map(chapter => {
                    return {
                        creatorId: userId,
                        chapterId: chapter.id,
                        translationChunks: chapter.chunks.map(chunk => {
                            return {
                                creatorId: userId,
                                chunkId: chunk.id,
                                text: chunk.text,
                                index: chunk.index
                            }
                        })
                    }
                })
            }, {
                include: [
                    {
                        association: db.TranslationArtifactVersion.Owner,
                        include: [
                            {
                                association: db.Owner.OwnerEntities
                            }
                        ]
                    },
                    {
                        association: db.TranslationArtifactVersion.TranslationChapters,
                        include: [
                            {
                                association: db.TranslationChapter.TranslationChunks
                            }
                        ]
                    },
                ]
            })
        }
    }
    return router;
};