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) {
            if (request.user) {
                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) {
                        const existingTranslation = {}
                        // fork check if forkable...
                        const forkedTranslationArtifactVersion = await db.TranslationArtifactVersion.create({
                            creatorId: request.user.id,
                            name: translationArtifactVersion.name,
                            artifactVersionId: translationArtifactVersion.artifactVersionId,
                            visibility: translationArtifactVersion.visibility,
                            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,
                                    index: translationChapter.index,
                                    translationChunks: translationChapter.translationChunks.map(translationChunk => {
                                        if (translationChunk.translation) {
                                            existingTranslation[translationChunk.chunkId] = {
                                                creatorId: translationChunk.translation.creatorId,
                                                text: translationChunk.translation.text,
                                            }
                                        }
                                        return {
                                            creatorId: request.user.id,
                                            chunkId: translationChunk.chunkId,
                                            text: translationChunk.text,
                                            index: translationChunk.index,
                                        }
                                    })
                                }
                            })
                        }, {
                            include: [
                                {
                                    association: db.TranslationArtifactVersion.TranslationChapters,
                                    include: [
                                        {
                                            association: db.TranslationChapter.TranslationChunks,
                                        }
                                    ]
                                },
                                {
                                    association: db.TranslationArtifactVersion.Owner,
                                    include: [
                                        {
                                            association: db.Owner.OwnerEntities
                                        }
                                    ]
                                }
                            ]
                        })
                        if (forkedTranslationArtifactVersion) {
                            const t = []
                            forkedTranslationArtifactVersion.translationChapters.forEach(translationChapter => {
                                translationChapter.translationChunks.forEach(translationChunk => {
                                    if (existingTranslation[translationChunk.chunkId]) {
                                        t.push({
                                            translationChunkId: translationChunk.id,
                                            creatorId: existingTranslation[translationChunk.chunkId].creatorId,
                                            text: existingTranslation[translationChunk.chunkId].text,
                                            translationArtifactVersionId: forkedTranslationArtifactVersion.id
                                        })
                                    }
                                })
                            });
                            await db.Translation.bulkCreate(t)
                            return response.redirect(`/translate/${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(`/translate/${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,
                visibility: artifactVersion.artifact.visibility,
                dialectId: dialect.id,
                userId: userId,
                owner: {
                    ownerEntities: [
                        {
                            entityId: entityId,
                        }
                    ]
                },
                translationChapters: artifactVersion.chapters.map(chapter => {
                    return {
                        creatorId: userId,
                        chapterId: chapter.id,
                        index: chapter.index,
                        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,
                visibility: artifactVersion.artifact.visibility,
                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,
                        index: chapter.index,
                        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;
};