var express = require('express');
var router = express.Router();

var utils = require('../../../../src/utils');
var crossCtl = require('../../../../src/crossCtl');
var localHandler = require('../../');

// operation
/*
router.use(function (req, res, next) {


  next()
})
*/

function response4000WithHint(req, hint) {
    localHandler.handleApiFinalResponse(
        req,
        {
            Status: {
                Code: 4000,
                Message: 'Bad request',
                Description: hint,
            },
        },
        {}
    );
}

const request = require('request');

function handleCallbackOrNot(req, response) {
    if (req.body.callback == undefined) {
        localHandler.handleApiFinalResponse(req, response, {});
    } else {
        let options = {
            uri: req.body.callback,
            method: 'POST',
            body: response,
            json: true,
        };

        request.post(options, function (error, response, body) {
            var logTag = crossCtl.sConfig.type + '.callback';
            var logData = {
                error: error,
                response: response,
                body: body,
            };
            crossCtl.logDebugInfo(logTag, req, logData);

            localHandler.handleApiFinalResponse(req, response, {
                error: error,
                response: response,
                body: body,
            });
        });
    }
}

function handleRestOfFilterWork(req, mode, startTime) {
    let trackingId = utils.rawuuid();
    if (req.body.callback != undefined) {
        localHandler.handleApiFinalResponse(
            req,
            {
                TrackingId: trackingId,
                Status: {
                    Code: 2020,
                    Message: 'Accepted',
                    Description:
                        'Filter work created with trackingId ' + trackingId,
                },
            },
            {}
        );
    }
    let options = { quick: false, longest: true };
    if (mode == 'quick') {
        options.quick = true;
    }
    localHandler.doSearchWithLevel(
        req.keyInfo.level,
        req.body.text ? req.body.text : '',
        options,
        function (err, result) {
            if (err) {
                handleCallbackOrNot(req, {
                    Status: {
                        Code: 5000,
                        Message: 'Internal service error',
                        Description:
                            'Error occurred during filtering text. error = ' +
                            err,
                    },
                });
            } else {
                if (req.body.mode == 'filter') {
                    let filteredText = req.body.text;

                    for (var i = 0; i < result.length; i++) {
                        filteredText = localHandler.splice(
                            filteredText,
                            result[i][0],
                            result[i][1].length,
                            '*'.repeat(result[i][1].length)
                        );
                    }
                    handleCallbackOrNot(req, {
                        TrackingId: trackingId,
                        Status: {
                            Code: 2000,
                            Message: 'OK',
                            Description: '',
                        },
                        Detected: result,
                        Filtered: filteredText,
                    });
                } else {
                    handleCallbackOrNot(req, {
                        TrackingId: trackingId,
                        Status: {
                            Code: 2000,
                            Message: 'OK',
                            Description: '',
                        },
                        Detected: result,
                    });
                }
            }
        }
    );
}

router.post('/status', function (req, res) {
    req.workTag
        .res()
        .status(200)
        .send({ status: 'ok', data: localHandler.getDashboardData() });
});

router.post('/dummycallback', function (req, res) {
    var hero = req.body;
    console.log('in dummycallback, hero=', hero);

    req.workTag.res().status(200).send({ body: req.body });
});

router.post('/filter', function (req, res) {

    req.startTime = process.hrtime();
    let clientIP = utils.getIPFromReq(req);
    let noBurstIPKey = 'noBurstIP_' + clientIP;

    crossCtl.redis.doEasyIncrWithExpireAt(noBurstIPKey, 1, function (
        err,
        currentCount
    ) {
        if (err) {
            localHandler.handleApiFinalResponse(
                req,
                {
                    Status: {
                        Code: 5000,
                        Message: 'Internal service error',
                        Description:
                            'Error occurred during check throttle limit for IP. error = ' +
                            err,
                    },
                },
                {}
            );
        } else {
            if (currentCount > Number.MAX_SAFE_INTEGER) {
                localHandler.handleApiFinalResponse(
                    req,
                    {
                        Status: {
                            Code: 4290,
                            Message: 'Too many requests',
                            Description:
                                'Throttle limit exceeded. IP = ' +
                                clientIP +
                                ', Count = ' +
                                currentCount,
                        },
                    },
                    {}
                );
            } else {
                if (req.headers['x-api-key'] == undefined) {
                    localHandler.handleApiFinalResponse(
                        req,
                        {
                            Status: {
                                Code: 4010,
                                Message: 'Unauthorized',
                                Description:
                                    'This service requires an API key.',
                            },
                        },
                        {}
                    );
                } else {
                    let apiKey = req.headers['x-api-key'];
                    localHandler.getAPIKeyInfo(apiKey, function (err, info) {
                        if (err) {
                            localHandler.handleApiFinalResponse(
                                req,
                                {
                                    Status: {
                                        Code: 5000,
                                        Message: 'Internal service error',
                                        Description:
                                            'Error occurred during retrive API Key Info. API key = ' +
                                            apiKey +
                                            ', error = ' +
                                            err,
                                    },
                                },
                                {}
                            );
                        } else {
                            if (info == null) {
                                localHandler.handleApiFinalResponse(
                                    req,
                                    {
                                        Status: {
                                            Code: 4030,
                                            Message: 'Unauthorized',
                                            Description:
                                                'Invalid API Key. Please verify your API key is valid. API key = ' +
                                                apiKey,
                                        },
                                    },
                                    {}
                                );
                            } else {
                                req.keyInfo = info;
                                if (req.body.text == undefined) {
                                    response4000WithHint(
                                        req,
                                        'Missing field : text'
                                    );
                                } else {
                                    let mode = req.body.mode
                                        ? req.body.mode
                                        : 'normal';
                                    if (
                                        mode != 'quick' &&
                                        mode != 'normal' &&
                                        mode != 'filter'
                                    ) {
                                        response4000WithHint(
                                            req,
                                            'Bad field value. mode = ' + mode
                                        );
                                    } else {
                                        if (info['checksum_timeout'] != 0) {
                                            if (
                                                req.body.checksum ==
                                                    undefined ||
                                                req.body.ts == undefined
                                            ) {
                                                response4000WithHint(
                                                    req,
                                                    'Missing field : checksum, ts'
                                                );
                                            } else {
                                                let nowTS = Date.now();

                                                

                                                let tsAge = parseInt(
                                                    (nowTS - req.body.ts) /
                                                        (1000 * 60)
                                                );
                                                

                                                if (
                                                    tsAge >
                                                    info['checksum_timeout']
                                                ) {
                                                    response4000WithHint(
                                                        req,
                                                        'Checksum Expired.'
                                                    );
                                                } else {
                                                    // do checksum work
                                                    let serverChecksum = utils.getSHA256Hash(
                                                        info['secret'] +
                                                            '_' +
                                                            req.body.ts
                                                    );
                                                    
                                                    if (
                                                        serverChecksum !=
                                                        req.body.checksum
                                                    ) {
                                                        response4000WithHint(
                                                            req,
                                                            'Bad field value. checksum = ' +
                                                                req.body
                                                                    .checksum
                                                        );
                                                    } else {
                                                        handleRestOfFilterWork(
                                                            req,
                                                            mode,
                                                            req.startTime
                                                        );
                                                    }
                                                }
                                            }
                                        } else {
                                            if (
                                                req.body.checksum !=
                                                    undefined &&
                                                req.body.ts != undefined
                                            ) {
                                                // do checksum work
                                                let serverChecksum = utils.getSHA256Hash(
                                                    info['secret'] +
                                                        '_' +
                                                        req.body.ts
                                                );
                                                
                                                if (
                                                    serverChecksum !=
                                                    req.body.checksum
                                                ) {
                                                    response4000WithHint(
                                                        req,
                                                        'Bad field value. checksum = ' +
                                                            req.body.checksum
                                                    );
                                                } else {
                                                    handleRestOfFilterWork(
                                                        req,
                                                        mode,
                                                        req.startTime
                                                    );
                                                }
                                            } else {
                                                handleRestOfFilterWork(
                                                    req,
                                                    mode,
                                                    req.startTime
                                                );
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    });
                }
            }
        }
    });
});

module.exports = router;