import logger from '../utils/logger'
import {configurationModel} from '../models/replicationConfig.model'
import errorCodes from '../utils/ErrorCodes.json'

/**
 * Adds a configuration for replicating blocks from the underlying Blockchain to HANA
 * @param req request
 * @param res response next handler
 */
export function createConfiguration(req, res) {
    const config = req.swagger.params.configuration.value
    const confDoc = new configurationModel(config)
    confDoc.save((err, conf) => {

        if (err) {
            // duplicate key
            if (err.code === 11000) {
                logger.error("ConfigurationService::22 ::", err)
                const retErr = {
                    code: `ConfigurationService:`,
                    message: errorCodes[302]
                }
                res.status(400).json(retErr)

            } else {
                logger.error("ConfigurationService::38 ::", err)
                const retErr = {
                    code: `ConfigurationService:`,
                    message: errorCodes[300]
                }
                res.status(400).json(retErr)

            }
        }

        else {
            configurationModel.findById(conf._doc._id).select('-_id -__v').exec((err, resConfig) => {
                // is there an issue?
                if (err) {
                    logger.error("ConfigurationService::39 ::", err)
                    const retErr = {
                        code: `ConfigurationService:`,
                        message: errorCodes[301]
                    }
                    res.status(400).json(retErr)

                }
                // all good
                else {
                    res.status(200).json(resConfig)
                }
            })
        }
    })

}

export async function getConfiguration(req, res) {
    /**
     * Returns the HANA table names used for replication as configured in the SCP user interface
     *
     * returns ReplicationConfigurations
     **/

    const messageTypes = await getMessageTypes(req)

    // todo can there be more configurations?
    configurationModel.find().select('-_id -__v -messages').exec((err, configurations) => {
        if (err) {

            logger.error("ConfigurationService::88 ::", err)
            const retErr = {
                code: `ConfigurationService:`,
                message: errorCodes[300]
            }

            res.status(404).json(retErr)
        }

        else {
            const result = {}
            result.configs = []
            configurations.forEach(c => {
                // logger.silly(c)
                c._doc.messages = messageTypes
                result.configs.push(c)
            })


            res.status(200).json(result)
        }
    })

}


async function getMessageTypes(req) {

    const messageSchemas = [],
        noMessagesCC = []

    await req.fc.getInstantiatedChaincodes().then(async chainCodes => {
        const revDnsPre = 'com.sap.icn.blockchain'
        const channelName = req.fc._channel.getName()

        logger.silly(`chaincodes in channel ${channelName}:`, chainCodes)

        for (let cCode of chainCodes) {

            try {
                const request = {
                    chaincodeId: cCode.name,
                    chaincodeVersion: cCode.version,
                    channel: process.env.HL_DEFAULT_CHANNEL_NAME,
                    fcn: "$sql",
                    args: ["SCHEMA"]
                }
                // logger.silly(`Requesting message schema for ${request.toString()}`)

                await req.fc._channel.queryByChaincode(request)
                    .then((response_payloads) => {
                        for (let i = 0; i < response_payloads.length; i++) {
                            // logger.silly('code, request', response_payloads[i].code, request)
                            // logger.silly(util.format('Query result from peer [%s]: %s', i, response_payloads[i].toString('utf8')))
                            // only handle successfull calls
                            if (response_payloads[i].code !== 2) {
                                const messages = JSON.parse(response_payloads[i].toString('utf8'))
                                for (let m of messages.messages) {
                                    m.type = `${revDnsPre}.${channelName}.${cCode.name}`
                                }
                                messageSchemas.push(messages)

                            } else {
                                noMessagesCC.push(request)
                            }
                        }
                    }).catch(
                        (rejectMessage) => {
                            noMessagesCC.push(request)
                        }
                    )
            } catch (err) {

                logger.error("ConfigurationService::139 ::", err)
                const retErr = {
                    code: `ConfigurationService:`,
                    message: err.message
                }
            }

        }
    })

    // logger.silly(`positive response`, messages)
    // logger.silly(`negative response`, noMessagesCC)

    return messageSchemas

}