///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2000-2017 Ericsson Telecom AB                               //
//                                                                           //
// All rights reserved. This program and the accompanying materials          //
// are made available under the terms of the Eclipse Public License v2.0     //
// which accompanies this distribution, and is available at                  //
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html                                 //
///////////////////////////////////////////////////////////////////////////////
/**
The function we mock.
 */
function CDsRestAPIComm(p_extension, p_model) {
    "use strict";
    ////////////////////////// MOCK OF DS CALLS //////////////////////////

    var model;
    if (p_model != undefined) {
        model = p_model;
    } else {
        model = new Model(new DataGenerator());
    }

    var schema = {
        "$schema": "http://json-schema.org/draft-04/schema#",
        "definitions": {
            "filter": {
                "oneOf": [
                    {
                        "type": "object",
                        "additionalProperties": false,
                        "properties": {
                            "dataValue": {
                                "type": "string"
                            }
                        }
                    },
                    {
                        "type": "object",
                        "additionalProperties": false,
                        "properties": {
                            "request": {
                                "type": "object",
                                "additionalProperties": false,
                                "properties": {
                                    "source": {
                                        "type": "string"
                                    },
                                    "ptcname": {
                                        "type": "string"
                                    },
                                    "element": {
                                        "type": "string"
                                    },
                                    "params": {
                                        "$ref": "#/definitions/filterParams"
                                    }
                                }
                            }
                        }
                    }
                ]
            },
            "filterParams": {
                "type": "array",
                "items": {
                    "type": "object",
                    "additionalProperties": false,
                    "properties": {
                        "paramName": {
                            "type": "string"
                        },
                        "paramValue": {
                            "$ref": "#/definitions/filter"
                        }
                    }
                }
            },
            "params": {
                "type": "array",
                "items": {
                    "title": "params",
                    "description": "params",
                    "type" : "object",
                    "additionalProperties": false,
                    "properties": {
                        "paramName": {
                            "type": "string"
                        },
                        "paramValue": {
                            "type": "string"
                        }
                    },
                    "required": [
                        "paramName",
                        "paramValue"
                    ]
                }
            },
            "getDataRequest": {
                "type": "object",
                "additionalProperties": false,
                "properties": {
                    "getData": {
                        "title": "getDataFieldsDef",
                        "description": "getDataFieldsDef",
                        "type": "object",
                        "additionalProperties": false,
                        "properties": {
                            "source": {
                                "type": "string"
                            },
                            "ptcname": {
                                "type": "string"
                            },
                            "element": {
                                "type": "string"
                            },
                            "params": {
                                "$ref": "#/definitions/params"
                            },
                            "cookie": {
                                "type": "string"
                            },
                            "children": {
                                "type": "array",
                                "items": {
                                    "$ref": "#/definitions/getDataRequest"
                                }
                            },
                            "filter": {
                                "$ref": "#/definitions/filter"
                            },
                            "rangeFilter": {
                                "type": "object",
                                "properties": {
                                    "offset": {
                                        "type": "integer",
                                        "minimum": 0
                                    },
                                    "count": {
                                        "type": "integer",
                                        "minimum": 0
                                    }
                                },
                                "additionalProperties": false
                            },
                            "selection": {
                                "type": "array",
                                "items": {
                                    "type": "integer"
                                }
                            },
                            "selectionValues": {
                                "type": "array",
                                "items": {
                                    "type": "string"
                                }
                            },
                            "writableInfo": {
                                "type": "boolean"
                            },
                            "timeline": {
                                "type": "object",
                                "additionalProperties": false,
                                "properties": {
                                    "period": {
                                        "type": "number",
                                        "minimum": 0
                                    },
                                    "maxpoints": {
                                        "type": "integer",
                                        "minimum": 0
                                    },
                                    "since": {
                                        "type": "integer",
                                        "minimum": 0
                                    }
                                }
                            }
                        },
                        "required": [
                            "source",
                            "element"
                        ]
                    }
                }
            },
            "setDataRequest": {
                "type": "object",
                "additionalProperties": false,
                "properties": {
                    "setData": {
                        "type": "object",
                        "properties": {
                            "source": {
                                "type": "string"
                            },
                            "ptcname": {
                                "type": "string"
                            },
                            "element": {
                                "type": "string"
                            },
                            "content": {
                                "type": "string"
                            },
                            "tp": {
                                "type": "integer"
                            },
                            "indxsInList": {
                                "type": "array",
                                "items": {
                                    "type": "integer"
                                }
                            },
                            "params": {
                                "$ref": "#/definitions/params"
                            }
                        },
                        "required": [
                            "source",
                            "element",
                            "content",
                            "tp"
                        ]
                    }
                }
            }
        },
        "type": "object",
        "additionalProperties": true,
        "properties": {
            "requests": {
                "type": "array",
                "items": {
                    "anyOf": [
                        {
                            "$ref": "#/definitions/getDataRequest"
                        },
                        {
                            "$ref": "#/definitions/setDataRequest"
                        }
                    ]
                }
            }
        }
    };

    var ajv = new Ajv({
            allErrors : true,
            format : "full",
            verbose : true,
            inlineRefs : false
        });

    var validate = ajv.compile(schema);

    this.ajaxCall = function (request, callback) {
        var v_requestObj = request;
        var isRequestValid = validate(v_requestObj);
        var answer;

        if (isRequestValid) {
            answer = parseRequest(v_requestObj).contentList;
        } else {
            console.log("AJV validate says, the request is invalid per DsRestAPI DSServer JSON API!");
            console.log("AJV says, these are the errors:", validate.errors);
            console.log("The invalid request:", JSON.stringify(request, null, 4));
            answer = [
                {
                    "node" : {
                        "val" : "Error processing request, Reason: While JSON-decoding type '@EPTF_CLL_DsRestAPI_DSServer_Definitions.EPTF_DsRestAPI_RqWrapper': Invalid field name 'XY'",
                        "tp" : 4
                    }
                }
            ];
        }

        callback(answer);
    };

    /**
    This method obtains or sets the data from the outside source.
    @param data: a getData or a setData object
    @param parents: the parents of the current node
    @returns the content belonging to the current node obtained from an outside source
     */
    function getContent(data, parents) {
        var content;
        if (data.content) {
            content = model.setContent(data);
        } else {
            content = model.getContent(data, parents);
        }
        // we create a copy of the answer since we may have to modify it
        content = mcopy(content);
        return content;
    }

    /**
    This method creates the tree using a recursive DFS algorithm. For more details, see the comments below.
    @param data: either a getData or a setData object
    @param contentList: the list that will contain the children of the parent
    @param parents: the parent list of the current node of the tree
     */
    function expand(data, contentList, parents) {
        // data can be undefined if the request is wrong, in this case, we return the already constructed list
        // TODO the real server returns an empty content list as the complete answer even if a single child request is invalid somewhere
        if (data == undefined) {
            return;
        }

        // we obtain the content that belongs to this node
        // this is an object that either contains a single "node" object or a "list" of node objects
        var content = getContent(data, parents);
        // we add the content to the output
        contentList.push(content);

        // a tricky part that keeps the code shorter
        // we create an empty list
        // if the content we got is a list of nodes, then this list will be the same
        // else we got a single node that we now add to the empty list
        // the point is, we can iterate over this list and do not have to check multiple conditions and there will be no code duplication
        var list = [];
        if (content.list == undefined) {
            list.push(content);
        } else {
            list = content.list;
        }

        if (data.children != undefined && data.children.length > 0) {
            var ListLength = list.length;
            for (var i = 0; i < ListLength; ++i) {
                // NOTE: originally the second part of the condition was "i in data.selection", which does not work with arrays...
                if (data.selection == undefined || data.selection.indexOf(i) != -1) {
                    // here we create an empty list of children for the current node
                    var node = list[i].node;
                    node.childVals = [];
                    // we add the node to the parent list, which we use as a simple stack
                    parents.push(node);
                    var childrenLength = data.children.length;
                    for (var j = 0; j < childrenLength; ++j) {
                        // we expand the children of the currently examined node recursively
                        expand(getGetData(data.children[j]), node.childVals, parents);
                    }
                    // we remove the current node from the parents list, since we have now finished examined all its children
                    parents.pop();
                }
            }
        }
    }

    /**
    This method parses the request and returns the answer.
    The result is obtained by a simple DFS algorithm.
    @param request: The request
    @returns the answer to the request that is accepted by the GUI
     */
    function parseRequest(request) {
        var answer = {
            contentList : []
        };
        var requestsLength = request.requests.length;
        for (var i = 0; i < requestsLength; ++i) {
            var data = getGetData(request.requests[i]);
            // if there is no getData or setData, return
            if (data == undefined) {
                return answer;
            }

            // ---------- setData and tp checking ----------
            var isSetData = !!(request.requests[i].setData);
            var isTpMatch = false;
            var TpMatchErrorMsg = ">> TODO This error message is not set properly in DsRestAPIComm_Mock! It should be set according to the datatype conversion failure. <<";

            if (isSetData) {
                // Check if tp matches the content's implicit type
                switch (data.tp) {
                case 1:
                    isTpMatch = /^(\-|\+)?([0-9]+)$/.test(data.content);
                    if (!isTpMatch)
                        TpMatchErrorMsg = "Cannot convert content: " + data.content + " to tp: " + data.tp + ", Reason: The argument of function str2int(), which is \"" + data.content + "\", does not represent a valid int value. Invalid character `" + data.content[0] + "' was found at index 0.";
                    break; // int
                case 2:
                    isTpMatch = /^(\-|\+)?([0-9]+(\.[0-9]+)?)$/.test(data.content);
                    if (!isTpMatch)
                        TpMatchErrorMsg = "Cannot convert content: " + data.content + " to tp: " + data.tp + ", Reason: The argument of function str2float(), which is \"" + data.content + "\", does not represent a valid float value. Invalid character `" + data.content[0] + "' was found at index 0.";
                    break; // float
                case 3:
                    isTpMatch = /^(true|false)$/.test(data.content);
                    break; // boolean
                case 4:
                    isTpMatch = true;
                    break; // charstring
                case 5: // octetstring
                case 6:
                    isTpMatch = /^([0-9a-fA-F]{2})*$/.test(data.content);
                    break; // hexstring
                case 7:
                    isTpMatch = /^[0-1]*$/.test(data.content);
                    break; // bitstring
                case 8: // integer[]
                case 9: // float[]
                case 10:
                    isTpMatch = /^\[.*\]$/.test(data.content);
                    break; // charstring[] -- we only check if it is a list, not the inner type.
                case 11:
                    isTpMatch = /^\[led:\w+\]/.test(data.content);
                    break; // LED
                default:
                    TpMatchErrorMsg = "Invalid tp: " + data.tp;
                    // error - invalid tp#
                }
            }

            // the help needs to be returned in a special way
            if (data.element === "help" && data.params != undefined && data.params.length === 1) {
                if (!isTpMatch && isSetData) {
                    // request tp does not match request content's datatype
                    answer.contentList.push({
                        "node" : {
                            "val" : a2hex(TpMatchErrorMsg),
                            "tp" : 4
                        }
                    });
                } else if (isSetData) {
                    // Nothing is writable in the help section.
                    answer.contentList.push({
                        "node" : {
                            "val" : a2hex("Value cannot be changed"),
                            "tp" : 4
                        }
                    });

                // ---------- end of setData and tp checking ----------

                } else {
                    var helpstr = JSON.stringify(DSHelp, null, 4);
                    var hex = a2hex(helpstr);
                    answer.contentList.push({
                        "node" : {
                            "val" : hex,
                            "tp" : 10
                        }
                    });
                }
            } else {
                var parents = [];
                expand(data, answer.contentList, parents);
            }


        }
        return answer;
    }

    /**
    @param obj An object
    @returns getData or setData from the object if one of them exists, or null if they do not
     */
    function getGetData(obj) {
        if (obj.getData != undefined) {
            return obj.getData;
        } else if (obj.setData != undefined) {
            return obj.setData;
        } else if (obj.listOfGetData != undefined) {
            return obj.listOfGetData;
        } else {
            mlog("Request has neither getData, nor setData element...");
            return undefined;
        }
    }

    this.getSchema = function () {
        return mcopy(schema);
    };
}