// Copyright 2015-2018 RWTH Aachen University

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#include "simple_reason_printer.hh"

#include<queue>

#include<iostream>

//#ifdef CONVERT_TO_DNF

//void SimpleReasonPrinter::print(bool result, vector<PolicyStackProcessorNode> reason, DNFConverterNode & dnf){

//#else

void SimpleReasonPrinter::print(bool result, vector<PolicyStackProcessorNode> reason){

//#endif

if (result){

queue<PolicyStackProcessorNode> workQueue;

workQueue.push(reason[1]);

while(!workQueue.empty()){

PolicyStackProcessorNode pspn = workQueue.front();

switch(pspn.type){

case PolicyStackProcessorNodeType::AND:

workQueue.push(reason[pspn.reason[0]]);

workQueue.push(reason[pspn.reason[1]]);

break;

case PolicyStackProcessorNodeType::OR:

workQueue.push(choose(reason, pspn));

break;

case PolicyStackProcessorNodeType::RELATION:

reasonList.push_back(pspn.reason[0]);

break;

}

workQueue.pop();

}

}

//#ifdef CONVERT_TO_DNF

//mDNF = dnf;

//#endif

}

//#ifdef CONVERT_TO_DNF

//void SimpleReasonPrinter::printDNF(){

//unsigned long i = 0;

//if (mDNF.size() == 0)

//return;

//while(true){

//std::cout<<"( ";

//set<uint64_t>::iterator it = mDNF[i].begin();

//while(true){

//std::cout<< _relationToString(*it);

//++it;

//if (it != mDNF[i].end())

//std::cout<<" && ";

//else

//break;

//}

//std::cout<<" )";

//++i;

//if (i != mDNF.size())

//std::cout<<" || ";

//else

//break;

//}

//std::cout<<std::endl;

//}

//#endif

string SimpleReasonPrinter::printReasonToString(){

string str = "";

for (uint64_t reasonId = 0; reasonId < reasonList.size(); ++reasonId){

vector<int64_t> variableIds = mRelationSet->getRelationVariableIds(reasonList[reasonId]);

Variable vLHS, vRHS;

vLHS = mVariableSet->getVariableById(variableIds[0]);

str += _variableToString(vLHS);

str += _relationTypeToString(mRelationSet->getRelationType(reasonList[reasonId]));

if (variableIds[1] >= 0){

vRHS = mVariableSet->getVariableById(variableIds[1]);

str += _variableToString(vRHS);

}

str += '\n';

}

return str;

}

string SimpleReasonPrinter::_relationToString(uint64_t relationId, string str_surrounding){

string str = "";

vector<int64_t> variableIds = mRelationSet->getRelationVariableIds(relationId);

Variable vLHS = mVariableSet->getVariableById(variableIds[0]);

RelationSetType type = mRelationSet->getRelationType(relationId);

if (vLHS.isFunction()){

if (type == RelationSetType::IS_TRUE){

str += _variableToString(vLHS, str_surrounding);

}

else if (type == RelationSetType::IS_FALSE){

str += "!" + _variableToString(vLHS, str_surrounding);

}

}

else{

str += _variableToString(vLHS, str_surrounding) + _relationTypeToString(type);

if (variableIds[1] >= 0){

Variable vRHS = mVariableSet->getVariableById(variableIds[1]);

str += _variableToString(vRHS, str_surrounding);

}

}

return str;

}

string SimpleReasonPrinter::_printReasonToJSON_AUX(uint64_t reasonId){

string str = "";

str += "\"";

str += _relationToString(reasonList[reasonId], "\\\"");

str += "\"";

return str;

}

void SimpleReasonPrinter::printReasonToJSON(string filename){

ofstream of(filename);

if (!of.is_open())

throw runtime_error("cannot open file" + filename);

of << "{\n" <<"\"reasons\":[\n";

if (reasonList.size() > 0){

of << _printReasonToJSON_AUX(0);

for (uint64_t reasonId = 1; reasonId < reasonList.size(); ++reasonId){

of << ",\n" << _printReasonToJSON_AUX(reasonId);

}

}

of << "\n] }";

of.close();

}

#ifdef PRINT_REASON_TO_CONSOLE

string SimpleReasonPrinter::printReasonToJSON(){

ostringstream out;

out << "{\n" <<"\"reasons\":[\n";

if (reasonList.size() > 0){

out << _printReasonToJSON_AUX(0);

for (uint64_t reasonId = 1; reasonId < reasonList.size(); ++reasonId){

out << ",\n" << _printReasonToJSON_AUX(reasonId);

}

}

out << "\n] }";

return out.str();

}

#endif//PRINT_REASON_TO_CONSOLE

string SimpleReasonPrinter::_relationTypeToString(RelationSetType t){

string str = "";

switch(t){

case RelationSetType::EQUAL:

str = "=";

break;

case RelationSetType::NEQ:

str = "!=";

break;

case RelationSetType::GEQ:

str = ">=";

break;

case RelationSetType::LEQ:

str = "<=";

break;

case RelationSetType::GREATER:

str = ">";

break;

case RelationSetType::LESS:

str = "<";

break;

case RelationSetType::IS_TRUE:

str = "=true";

break;

case RelationSetType::IS_FALSE:

str = "=false";

break;

case RelationSetType::END:

break;

};

return str;

}

string SimpleReasonPrinter::_variableToString(Variable v, string str_surrounding){

//string str;

ostringstream oss;

if (v.isReference()){

oss<< mPolicyDefinition->getIdName(v.idInPolicyDef);

if (v.isFunction()){

oss<< "( " << _variableToString(v.funcParams->at(0), str_surrounding);

for (vector<Variable>::iterator it = v.funcParams->begin() + 1; it != v.funcParams->end(); ++it){

oss << ", " << _variableToString(*it, str_surrounding);

}

oss<< " )";

}

}

else {

switch (v.type){

case VariableSetType::STRING:

oss<< str_surrounding <<*(v.value.asString)<< str_surrounding;

break;

case VariableSetType::BOOLEAN:

if (v.value.asBoolean)

oss<< "true";

else

oss<< "false";

break;

//ENUM_VALUE not used

case VariableSetType::INT8:

//uint8_t is defined as char. print directly will meet problem.

oss<< (int)(v.value.asInt8);

break;

case VariableSetType::INT16:

oss<< v.value.asInt16;

break;

case VariableSetType::INT32:

oss<< v.value.asInt32;

break;

case VariableSetType::UINT8:

//uint8_t is defined as char. print directly will meet problem.

oss<< (unsigned int)(v.value.asUInt8);

break;

case VariableSetType::UINT16:

oss<< v.value.asUInt16;

break;

case VariableSetType::UINT32:

oss<< v.value.asUInt32;

break;

default:

break;

}

}

return oss.str();

}