package com.lemans.ds.qualitycontrol

import com.lemans.services.LemansManager
import grails.transaction.Transactional

import javax.mail.internet.InternetAddress
import javax.mail.internet.MimeMessage

@Transactional
class ProductReviewManagerService extends LemansManager {

    def qcChangeLogService
    def qcRejectionLogService

    def jiraContext
    def jiraDigiQCUserName
    def jiraDigiQCPassword
    def jiraDigiQCPartEpic

    def temporaryMediaPath

    def hiddenChangeLogEmail

    def mailSender

    private static final String QC_LOGS_QUERY = '''
SELECT 
    changeLogId 
FROM qc.vwChangeLog cl WITH(NOLOCK) 
INNER JOIN qc.Config c WITH(NOLOCK)
ON cl.configId = c.configId
AND c.parentEntity = 'Product'
WHERE 
    cl.parentEntityId = CAST (:productId AS VARCHAR(10))  
    AND cl.approvalStatusId = 13001
'''

    void approveByChangeLogIds(List<Integer> changeLogIds, String username, Integer qcChangeGroupId = null) {
        qcChangeLogService.approveOrDeclineChangeLog(changeLogIds.unique(), 13002, username) //Approved
        List parentEntityIds = qcChangeLogService.getParentEntityIds(changeLogIds)
        if (13002 && qcChangeLogService.hasAllChangeLogsApproved(parentEntityIds)) {
            parentEntityIds.collect { String productId ->
                qcChangeLogService.deleteQCPriorityFlag(productId, 'Product', username)
            }
        }
        qcRejectionLogService.insertOrUpdateMessage(changeLogIds, '', '', username, 'Product', qcChangeGroupId, 'A')
        if (ifAllChangeLogsApproved(changeLogIds) && qcChangeGroupId !=null) { qcRejectionLogService.insertOrUpdateMessage(changeLogIds, '', '', username, 'Product', null) }
    }

    Map approveByProductId(Integer productId, String username) {
        List changeLogIds = sql().rows([productId: productId], QC_LOGS_QUERY)*.changeLogId
        if (changeLogIds) {
            approveByChangeLogIds(changeLogIds, username)
            qcChangeLogService.deleteQCPriorityFlag(productId as String, 'Product', username)
            return [:]
        } else {
            return [messages: [[type: 'error', text: 'productId has no changes to be approved']]]
        }
    }

    Map approveByProductIdAndEmail(Integer productId, String username) {
        List changeLogIds = sql().rows([productId: productId], QC_LOGS_QUERY)*.changeLogId
        if (changeLogIds) {
            approveByChangeLogIds(changeLogIds, username)
            qcChangeLogService.deleteQCPriorityFlag(productId as String, 'Product', username)
            sendEmail(productId, changeLogIds, username)
        }
    }

    private void sendEmail(Integer productId, List changeLogIds,  String username) {
        MimeMessage mimeMessage = createMessage(productId, changeLogIds, username)
        mailSender.send(mimeMessage)
    }

    MimeMessage createMessage(Integer productId, List changeLogIds, String username) {
        MimeMessage mimeMessage = mailSender.createMimeMessage()
        mimeMessage.addRecipient(MimeMessage.RecipientType.TO, new InternetAddress(hiddenChangeLogEmail))
        mimeMessage.from = new InternetAddress('noreply@parts-unltd.com ')
        mimeMessage.subject = "Auto Approve Change Logs not visible on Page for Product $productId Requested by user $username"
        mimeMessage.setContent changeLogIds.join(', ').toString(), 'text/html'
        mimeMessage
    }

    def declineByChangeLogIds(Map payload, String username) {
        JiraTicketResponse response = createJira(payload, username)
        qcChangeLogService.approveOrDeclineChangeLog(changeLogIds, 13003, username) //Declined
        List parentIds = qcChangeLogService.getParentEntityIds(changeLogIds)
        parentIds.each { parentId ->
            if(qcChangeLogService.isApprovedOrRejected(parentId)) {
                qcChangeLogService.deleteQCPriorityFlag(parentId as String, 'Product',  username)
            }
        }
        qcRejectionLogService.insertOrUpdateMessage(changeLogIds, response.key?:" ", payload.description.toString(), username, 'Product', payload.qcChangeGroupId as Integer)
        response.error ? response.toErrorMap() : response.toResponseMap()
    }

    def createJira(Map payload, String username) {
        List productReviewUsers = []
        List watchers = []

        if(payload.changeLogIds) {
            productReviewUsers = productReviewUsersByChangeLogIds(payload.changeLogIds?.unique())
            watchers = productReviewUsers?.collect { it.changedBy ? it.changedBy.tokenize('\\')[1] : null }?.findAll { it != null }
        } else if(payload.productId) {
            productReviewUsers = productReviewUsersByProductId(payload.productId)
        }

        String assignee = productReviewUsers ? (productReviewUsers[0].categorySpecialist ?: 'unassigned') : 'unassigned'

        JiraTicket jiraTicket = new JiraTicket(jiraContext, jiraDigiQCUserName, jiraDigiQCPassword, jiraDigiQCPartEpic, temporaryMediaPath).with {
            it.assignee = assignee
            reporter = username.tokenize('\\')[1]
            it.watchers = watchers
            description = payload.description ?: ''
            media = payload.media
            summary = this.summary(productReviewUsers ? productReviewUsers[0] : null)
            it
        }
        return jiraTicket.create()
    }

    private String summary(Map productInfo) {
        if (productInfo) {
            "${productInfo.qualifiedCategoryName ?: ''} - ${productInfo.productId ?: ''} - ${productInfo.productName ?: ''}"
        } else {
            'Quality Control Rejected'
        }
    }

    private List productReviewUsersByChangeLogIds(List<Integer> changeLogIds) {
        if (changeLogIds) {
            String query = """
SELECT
    DISTINCT    p.productId, 
    p.productName,
    p.qualifiedCategoryName,
    categorySpecialist = cs.userName,
    qc.changedBy 
FROM
    qc.vwChangeLog qc WITH(NOLOCK)
INNER JOIN
    dbo.vwProduct p WITH(NOLOCK)   
        ON p.productId = qc.parentEntityId 
LEFT OUTER JOIN
    dbo.Category c WITH(NOLOCK)   
        ON c.categoryId = p.categoryId    
        AND c.dateDeleted IS NULL  
LEFT OUTER JOIN
    dbo.CategorySpecialist cs WITH(NOLOCK)   
        ON cs.categoryId = c.parentCategoryId    
        AND cs.dateDeleted IS NULL 
WHERE
    qc.changeLogId IN (${changeLogIds.join(', ')})
"""
            sql().rows(query)
        }
    }

    private List productReviewUsersByProductId(String productId) {
            String query = """
SELECT
    DISTINCT    p.productId, 
    p.productName,
    p.qualifiedCategoryName,
    categorySpecialist = cs.userName
FROM
    dbo.vwProduct p WITH(NOLOCK)
LEFT OUTER JOIN
    dbo.Category c WITH(NOLOCK)   
        ON c.categoryId = p.categoryId    
        AND c.dateDeleted IS NULL  
LEFT OUTER JOIN
    dbo.CategorySpecialist cs WITH(NOLOCK)   
        ON cs.categoryId = c.parentCategoryId    
        AND cs.dateDeleted IS NULL 
WHERE
    p.productId = '${productId}'
"""
            sql().rows(query)
    }

    private boolean ifAllChangeLogsApproved(List<Integer> changeLogIds) {
        List parentEntityIds = qcChangeLogService.getParentEntityIds(changeLogIds)
        return qcChangeLogService.hasAllChangeLogsApproved(parentEntityIds)
    }
}