const express = require('express')
const XL = require('excel4node');

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

    router.route('/')
        .get(function(request, response, next) {
            db.Project.findAll()
            .then(projects => {
                response.display("projects", {
                    user: request.user,
                    pageTitle: "Projects - Mantra",
                    projects: projects
                })
            })
        })
    
    router.route('/:id')
        .get(function(request, response, next) {
            db.Project.findByPk(request.params.id, {
                include: [
                    {
                        association: db.Project.ProjectEntryVersions,
                        include: [
                            {
                                association: db.ProjectEntryVersion.EntryVersion,
                                include: [
                                    {
                                        association: db.EntryVersion.Entry
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        association: db.Project.ProjectTranslationEntryVersions,
                        include: [
                            {
                                association: db.ProjectTranslationEntryVersion.TranslationEntryVersion,
                                include: [
                                    {
                                        association: db.TranslationEntryVersion.EntryVersion,
                                        include: [
                                            {
                                                association: db.EntryVersion.Entry
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }).then(project => {
                if (project) {
                    response.display("project", {
                        user: request.user,
                        pageTitle: "Projects - Mantra",
                        project: project
                    })
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })

    router.route('/create')
        .get(function(request, response, next) {
            response.display("project-form", {
                user: request.user,
                pageTitle: "Projects - Mantra",
                project: {

                }
            })
        })
        .post(function(request, response, next) {
            db.Project.create({
                name: request.body.name,
                description: request.body.description
            }).then(project => {
                if (project) {
                    response.redirect(`/projects/${project.id}`)
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })

    router.route('/:id/add-entry')
        .get(function(request, response, next) {
            db.Project.findByPk(request.params.id, {
                include: [
                    {
                        association: db.Project.ProjectEntryVersions
                    },
                    {
                        association: db.Project.ProjectTranslationEntryVersions
                    }
                ]
            }).then(async (project) => {
                if (project) {
                    const entries = await db.Entry.findAll({
                        // Narrow it down to entries this user has admin ownership off...,
                        include: [
                            {
                                association: db.Entry.EntryVersions,
                                limit: 1,
                                required: true
                                // TODO: Order by version...
                            }
                        ]
                    })
                    response.display("project-add-entry", {
                        user: request.user,
                        pageTitle: "Projects - Mantra",
                        project: project,
                        entries: entries
                    })
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })
        .post(function(request, response, next) {
            db.Project.findByPk(request.params.id, {
                include: [
                    {
                        association: db.Project.ProjectEntryVersions,
                        include: [
                            {
                                association: db.ProjectEntryVersion.EntryVersion,
                                include: [
                                    {
                                        association: db.EntryVersion.Entry
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        association: db.Project.ProjectTranslationEntryVersions,
                        include: [
                            {
                                association: db.ProjectTranslationEntryVersion.TranslationEntryVersion,
                                include: [
                                    {
                                        association: db.TranslationEntryVersion.EntryVersion,
                                        include: [
                                            {
                                                association: db.EntryVersion.Entry
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }).then(async (project) => {
                if (project) {
                    // TODO: Fi
                    const entryVersion = await db.EntryVersion.findByPk(request.body.entryVersionId, {
                        // Narrow it down to entries this user has admin ownership off...,
                    })

                    if (entryVersion) {
                        const projectEntryVersion = db.ProjectEntryVersion.create({
                            projectId: project.id,
                            entryVersionId: entryVersion.id
                        })
    
                        response.redirect(`/projects/${project.id}`)
                    } else {
                        response.redirect(`/projects/${project.id}/add-entry`)
                    }

                    
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })

    router.route('/:id/add-translation')
        .get(function(request, response, next) {
            db.Project.findByPk(request.params.id, {
                include: [
                    {
                        association: db.Project.ProjectEntryVersions
                    },
                    {
                        association: db.Project.ProjectTranslationEntryVersions
                    }
                ]
            }).then(async (project) => {
                if (project) {
                    const translationEntryVersions = await db.TranslationEntryVersion.findAll({
                        // Narrow it down to entries this user has admin ownership off...,
                        include: [
                            {
                                association: db.TranslationEntryVersion.EntryVersion,
                                required: true,
                                // TODO: Order by version...
                                include: [
                                    {
                                        association: db.EntryVersion.Entry
                                    }
                                ]
                            }
                        ]
                    })
                    response.display("project-add-translation", {
                        user: request.user,
                        pageTitle: "Projects - Mantra",
                        project: project,
                        translationEntryVersions: translationEntryVersions
                    })
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })
        .post(function(request, response, next) {
            db.Project.findByPk(request.params.id, {
                include: [
                    {
                        association: db.Project.ProjectEntryVersions
                    },
                    {
                        association: db.Project.ProjectTranslationEntryVersions
                    }
                ]
            }).then(async (project) => {
                if (project) {
                    // TODO: Fi
                    const translationEntryVersion = await db.TranslationEntryVersion.findByPk(request.body.translationEntryVersionId, {
                        // Narrow it down to entries this user has admin ownership off...,
                        include: [
                            {
                                association: db.TranslationEntryVersion.EntryVersion,
                                required: true
                                // TODO: Order by version...
                            }
                        ]
                    })

                    if (translationEntryVersion) {
                        const projectTranslationEntryVersion = db.ProjectTranslationEntryVersion.create({
                            projectId: project.id,
                            translationEntryVersionId: translationEntryVersion.id
                        })
    
                        response.redirect(`/projects/${project.id}`)
                    } else {
                        response.redirect(`/projects/${project.id}/add-translation`)
                    }
                    
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })

    router.route('/:id/campaign')
        .get(function(request, response, next) {
            db.Project.findByPk(request.params.id, {
                include: [
                    {
                        association: db.Project.Campaign,
                        required: true
                    },
                    {
                        association: db.Project.ProjectEntryVersions,
                        include: [
                            {
                                association: db.ProjectEntryVersion.EntryVersion,
                                include: [
                                    {
                                        association: db.EntryVersion.Entry
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        association: db.Project.ProjectTranslationEntryVersions,
                        include: [
                            {
                                association: db.ProjectTranslationEntryVersion.TranslationEntryVersion,
                                include: [
                                    {
                                        association: db.TranslationEntryVersion.EntryVersion,
                                        include: [
                                            {
                                                association: db.EntryVersion.Entry
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }).then(project => {
                if (project) {
                    response.redirect(`/campaigns/${project.campaign.id}`)
                } else {
                    response.redirect(`/projects/${request.params.id}/campaign/create`)
                }
            })
        })

    router.route('/:id/campaign/create')
        .get(function(request, response, next) {
            db.Project.findByPk(request.params.id, {
                include: [
                    {
                        association: db.Project.Campaign,
                    }
                ]
            }).then(project => {
                if (project) {
                    if (project.campaign) {
                        response.redirect(`/campaigns/${project.campaign.id}`)
                    } else {
                        response.display("campaign-form", {
                            user: request.user,
                            pageTitle: "Campaign - Mantra",
                            campaign: {
                                name: `Campaign for ${project.name} project`
                            },
                            project: project,
                        })
                    }
                    
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })

    router.route('/:id/spreadsheet')
        .post(function(request, response, next) {
            db.Project.findByPk(request.params.id, {

            }).then(async (project) => {
                if (project) {
                    db.TranslationEntryVersion.findAll({
                        include: [
                            // TODO: require translationEntryVersions in ProjectEntryVersion
                            {
                                association: db.TranslationEntryVersion.ProjectTranslationEntryVersions,
                                where: {
                                    projectId: request.params.id
                                },
                                required: true
                            },
                            {
                                association: db.TranslationEntryVersion.EntryVersion,
                                include: [
                                    {
                                        association: db.EntryVersion.Entry,
                                        include: [
                                            {
                                                association: db.Entry.Dialect
                                            }
                                        ]
                                    },
                                    {
                                        association: db.EntryVersion.Chapters,
                                        include: [ 
                                            {
                                                association: db.Chapter.Chunks,
                                                include: [
                                                    {
                                                        association: db.Chunk.Translation
                                                    }
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                association: db.TranslationEntryVersion.Dialect
                            }
                        ]
                    }).then(translationEntryVersions => {
                        console.log("Translation Entry: ", translationEntryVersions.length)
                        const workbook = new XL.Workbook();
                        const cellWidth = 45
                        const cellHeight = 25
        
                        translationEntryVersions.forEach((translationEntryVersion, index) => {
                            const worksheet_name = `${index+1}-${translationEntryVersion.dialect.countryId}-${translationEntryVersion.dialect.languageId} - ${translationEntryVersion.entryVersion.entry.name}`.substring(0, 30);
        
                            // Don't have [ ] * ? : / \ 
                            const worksheet = workbook.addWorksheet(worksheet_name.replace(/[`*?:'\[\]\\\/]/gi, ""))

                            worksheet.cell(2,2,2,3,true)
                                .string(translationEntryVersion.entryVersion.entry.name)
                                .style({
                                    font: {
                                        bold: true,
                                    },
                                    alignment: {
                                        wrapText: true 
                                    }
                                })

                            worksheet.cell(4,2)
                                .string(translationEntryVersion.entryVersion.entry.dialect.name)
                                .style({
                                    font: {
                                        bold: true,
                                    },
                                    alignment: {
                                        wrapText: true
                                    }
                                })  

                            worksheet.cell(4,3)
                                .string(translationEntryVersion.dialect.name)
                                .style({
                                    font: {
                                        bold: true,
                                    },
                                    alignment: {
                                        wrapText: true
                                    }
                                }) 
                            
                            var cellIndex = 6
                            for (const i in translationEntryVersion.entryVersion.chapters) {
                                const chapter = translationEntryVersion.entryVersion.chapters[i] 
                                const chunks = chapter.chunks.sort((a,b) => a.index - b.index)
                                for (const j in chunks) {
                                    const chunk = chunks[j]

                                    worksheet.cell(cellIndex,2)
                                        .string(chunk.text)
                                        .style({
                                            alignment: {
                                                wrapText: true,
                                                vertical: 'top'
                                            }
                                        }) 

                                    worksheet.cell(cellIndex,3)
                                        .string(chunk.translation?.text ?? "")
                                        .style({
                                            alignment: {
                                                wrapText: true,
                                                vertical: 'top'
                                            }
                                        }) 

                                    const textLength = chunk.text.length
                                    worksheet.row(cellIndex).setHeight(
                                        Math.ceil(Math.max(textLength/cellWidth, 1)*cellHeight)
                                    )
                                    cellIndex++
                                }
                                cellIndex++
                            }

                            // Format
                            worksheet.column(2).setWidth(cellWidth);
                            worksheet.column(3).setWidth(cellWidth);
                        })
                        workbook.write(`${project.name}.xlsx`, response);
                    }).catch(error => {
                        next(error)
                    })
                } else {
                    next()
                }
            })
            
        })

    return router;
};