/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you 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.
 *
 */

/*
 *                        AT&T - PROPRIETARY
 *          THIS FILE CONTAINS PROPRIETARY INFORMATION OF
 *        AT&T AND IS NOT TO BE DISCLOSED OR USED EXCEPT IN
 *             ACCORDANCE WITH APPLICABLE AGREEMENTS.
 *
 *          Copyright (c) 2013 AT&T Knowledge Ventures
 *              Unpublished and Not for Publication
 *                     All Rights Reserved
 */
package org.apache.openaz.xacml.pdp.std.json;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;

import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.openaz.xacml.api.Advice;
import org.apache.openaz.xacml.api.Attribute;
import org.apache.openaz.xacml.api.AttributeCategory;
import org.apache.openaz.xacml.api.IdReference;
import org.apache.openaz.xacml.api.Obligation;
import org.apache.openaz.xacml.api.Response;
import org.apache.openaz.xacml.api.Result;
import org.apache.openaz.xacml.std.dom.DOMResponse;
import org.apache.openaz.xacml.std.json.JSONResponse;
import org.apache.openaz.xacml.util.ListUtil;
import org.junit.Test;

/**
 * Test JSON Response convert to object - Conformance tests TO RUN - use jUnit In Eclipse select this file or
 * the enclosing directory, right-click and select Run As/JUnit Test Note: some of the validation tests
 * comparing the XML-derived Results to the JSON-derived Results are high-level comparisons of Collections.
 * When this class was first created that was sufficient to pass all Conformance tests. However if this sees a
 * failure in a Conformance test, those validations may need to be upgraded to look at the individual data
 * elements to see what is wrong.
 */
public class ResponseConformanceTest {

    // where to find the conformance test XML files
    private final String CONFORMANCE_DIRECTORY_PATH = "testsets/conformance/xacml3.0-ct-v.0.4";

    // The request object output from each test conversion from JSON string
    Response response;

    // test just one of each top-level element.
    // For simple elements also test for incorrect type
    @Test
    public void testConformanceResponses() {

        List<File> filesInDirectory = null;

        File conformanceDirectory = null;

        File currentFile = null;

        try {
            conformanceDirectory = new File(CONFORMANCE_DIRECTORY_PATH);
            filesInDirectory = getRequestsInDirectory(conformanceDirectory);
        } catch (Exception e) {
            fail("Unable to set up Conformance tests for dir '" + conformanceDirectory.getAbsolutePath()
                 + "' e=" + e);
        }

        // run through each XML file
        // - load the file from XML into an internal Response object
        // - generate the JSON representation of that Response object
        // - load that JSON representation into a new Response object
        // - compare the 2 Request objects
        Response xmlResponse = null;
        Response jsonResponse = null;
        try {
            for (File f : filesInDirectory) {
                currentFile = f;

                // // This is a simple way to select just one file for debugging - comment out when not being
                // used
                // if ( ! f.getName().equals("IIIA030Response.xml") && !
                // f.getName().equals("IIIA330Response.xml")) { continue; }

                // during debugging it is helpful to know what file it is starting to work on
                // System.out.println("starting file="+currentFile.getName());

                try {
                    // load XML into a Response object
                    xmlResponse = DOMResponse.load(f);
                } catch (Exception e) {
                    // if XML does not load, just note it and continue with next file
                    System.out.println("XML file did not load: '" + f.getName() + "  e=" + e);
                    continue;
                }

                // some tests have JSON response files to load, most do not
                String jsonFileName = f.getName().replace(".xml", ".json");
                File jsonFile = new File(conformanceDirectory, jsonFileName);

                if (jsonFile.exists()) {
                    // System.out.println("found file "+jsonFile.getName());
                    // json version exists in file, so load it
                    jsonResponse = JSONResponse.load(jsonFile);
                } else {
                    // json does not exist in file, so create it from the XML response using a String
                    // intermediate version
                    String jsonResponseString = JSONResponse.toString(xmlResponse, false);
                    // System.out.println(jsonResponseString);
                    // System.out.println(JSONResponse.toString(xmlResponse, true));

                    jsonResponse = JSONResponse.load(jsonResponseString);
                }

                // System.out.println(JSONResponse.toString(xmlResponse, true));

                // compare the two Response objects

                // compare results
                assertEquals(xmlResponse.getResults().size(), jsonResponse.getResults().size());

                if (xmlResponse.getResults().size() == 0) {
                    fail("neither XML nor JSON response have any Results");
                }

                // Results are an un-ordered Collection.
                // There is no identifying information that is unique to a specific Result.
                // If there are more than one we cannot be sure which one corresponds with which.
                // The best we can do is say that one or more in the first list do not match any in the second
                // list
                if (xmlResponse.getResults().size() > 1) {
                    for (Result xmlResult : xmlResponse.getResults()) {
                        boolean found = false;
                        for (Result jsonResult : jsonResponse.getResults()) {
                            if (xmlResult.equals(jsonResult)) {
                                found = true;
                                break;
                            }
                        }
                        if (found) {
                            continue;
                        }
                        // no match found
                        System.out.println("No match for XML in " + f.getName());
                        System.out.println("XML =" + xmlResult.toString());
                        for (Result jsonResult : jsonResponse.getResults()) {
                            System.out.println("JSON=" + jsonResult.toString());
                        }
                        fail("JSON Response has no match for XML Result: " + xmlResult.toString());
                    }
                    // we've done the best we can for multiple decisions, so go to next file
                    continue;
                }

                // single Result in each
                Result xmlResult = xmlResponse.getResults().iterator().next();
                Result jsonResult = jsonResponse.getResults().iterator().next();

                // The following sections have not given us trouble, so checking is very high-level.
                // If we see a problem in one of these elements, the single line will need to be replaced with
                // detailed examination of the objects.
                assertEquals(f.getName() + " Decision", xmlResult.getDecision(), jsonResult.getDecision());
                assertEquals(f.getName() + " Status", xmlResult.getStatus(), jsonResult.getStatus());

                // Obligations
                if (xmlResult.getObligations() != jsonResult.getObligations()) {
                    Collection<Obligation> xmlObligations = xmlResult.getObligations();
                    Collection<Obligation> jsonObligations = jsonResult.getObligations();
                    // if both are null we do not get here
                    if (xmlObligations == null || jsonObligations == null) {
                        fail(f.getName() + " Obligations has null \nXML=" + xmlObligations + "\nJSON="
                             + jsonObligations);
                    }
                    if (!ListUtil.equalsAllowNulls(xmlObligations, jsonObligations)) {
                        // collections are not equal, so need to examine further
                        fail(f.getName() + " Obligation collections not equal\nXML=" + xmlObligations
                             + "\nJSON=" + jsonObligations);
                    }
                }

                // AssociatedAdvice
                if (xmlResult.getAssociatedAdvice() != jsonResult.getAssociatedAdvice()) {
                    Collection<Advice> xmlAdvice = xmlResult.getAssociatedAdvice();
                    Collection<Advice> jsonAdvice = jsonResult.getAssociatedAdvice();
                    // if both are null we do not get here
                    if (xmlAdvice == null || jsonAdvice == null) {
                        fail(f.getName() + " Advice has null \nXML=" + xmlAdvice + "\nJSON=" + jsonAdvice);
                    }
                    if (!ListUtil.equalsAllowNulls(xmlAdvice, jsonAdvice)) {
                        // collections are not equal, so need to examine further
                        fail(f.getName() + " Advice collections not equal\nXML=" + xmlAdvice + "\nJSON="
                             + jsonAdvice);
                    }
                }

                // check Attributes in more detail
                Collection<AttributeCategory> xmlAttributes = xmlResult.getAttributes();
                Collection<AttributeCategory> jsonAttributes = jsonResult.getAttributes();
                if (xmlAttributes == null && jsonAttributes != null || xmlAttributes != null
                    && jsonAttributes == null) {
                    fail(f.getName() + " XML Attributes=" + xmlAttributes + "  but JSON Attributes="
                         + jsonAttributes);
                }
                if (xmlAttributes != null) {
                    // both are non-null
                    if (xmlAttributes.size() != jsonAttributes.size()) {
                        String xmlAttributesString = "XML categorys=";
                        for (AttributeCategory ac : xmlAttributes) {
                            xmlAttributesString += " " + ac.getCategory().stringValue();
                        }
                        String jsonAttributesString = "JSON categorys=";
                        for (AttributeCategory ac : jsonAttributes) {
                            jsonAttributesString += " " + ac.getCategory().stringValue();
                        }
                        fail(f.getName() + " XML and JSON have different number of Category elements: "
                             + xmlAttributesString + ", " + jsonAttributesString);
                    }

                    // Attribute collections are the same size but may be in different orders.
                    // for each XML category try to find the corresponding JSON category.
                    // ASSUME that each category only shows up once!!!!
                    for (AttributeCategory xmlAttributeCategory : xmlAttributes) {
                        boolean attributeCategoryFound = false;
                        for (AttributeCategory jsonAttributeCategory : jsonAttributes) {
                            if (xmlAttributeCategory.equals(jsonAttributeCategory)) {
                                attributeCategoryFound = true;
                                break;
                            }
                            // not an exact match, but if same CategoryId then need to check individual
                            // Attribute objects
                            if (xmlAttributeCategory.getCategory()
                                .equals(jsonAttributeCategory.getCategory())) {
                                // same category
                                if (xmlAttributeCategory.getAttributes().size() != jsonAttributeCategory
                                    .getAttributes().size()) {
                                    System.out.println("XML =" + xmlAttributeCategory.getAttributes());
                                    System.out.println("JSON=" + jsonAttributeCategory.getAttributes());
                                    fail(f.getName() + " Attributes Category '"
                                         + xmlAttributeCategory.getCategory().stringValue()
                                         + "' size mismatch; XML="
                                         + xmlAttributeCategory.getAttributes().size() + ", JSON="
                                         + jsonAttributeCategory.getAttributes().size());
                                }
                                for (Attribute xmlAttr : xmlAttributeCategory.getAttributes()) {
                                    boolean attributeFound = false;
                                    for (Attribute jsonAttr : jsonAttributeCategory.getAttributes()) {
                                        if (xmlAttr.equals(jsonAttr)) {
                                            attributeFound = true;
                                            break;
                                        }
                                    }

                                    if (attributeFound) {
                                        // check next XML attribute
                                        continue;
                                    }
                                    System.out.println("Attribute not found in JSON, Category="
                                                       + xmlAttributeCategory.getCategory());
                                    System.out.println("XML Attribute =" + xmlAttr);
                                    System.out.println("JSON Attributes=" + jsonAttributeCategory.toString());
                                    fail(f.getName() + " Attribute not found in JSON, Category="
                                         + xmlAttributeCategory.getCategory() + "/nXML Attribute=" + xmlAttr
                                         + "\nJSON Category Attributes=" + jsonAttributeCategory.toString());
                                }

                            }
                        }
                        if (attributeCategoryFound) {
                            continue;
                        }
                        fail("XML Category not found in JSON; xml=" + xmlAttributeCategory.toString());
                    }

                }

                // PolicyIdentifiers
                if (xmlResult.getPolicyIdentifiers() != jsonResult.getPolicyIdentifiers()) {
                    Collection<IdReference> xmlIdReferences = xmlResult.getPolicyIdentifiers();
                    Collection<IdReference> jsonIdReferences = jsonResult.getPolicyIdentifiers();
                    // if both are null we do not get here
                    if (xmlIdReferences == null || jsonIdReferences == null) {
                        fail(f.getName() + " PolicyIdentifiers has null \nXML=" + xmlIdReferences + "\nJSON="
                             + jsonIdReferences);
                    }
                    if (!ListUtil.equalsAllowNulls(xmlIdReferences, jsonIdReferences)) {
                        // collections are not equal, so need to examine further
                        fail(f.getName() + " PolicyIdentifiers collections not equal\nXML=" + xmlIdReferences
                             + "\nJSON=" + jsonIdReferences);
                    }
                }

                // PolicySetIdentifiers
                if (xmlResult.getPolicySetIdentifiers() != jsonResult.getPolicySetIdentifiers()) {
                    Collection<IdReference> xmlIdReferences = xmlResult.getPolicySetIdentifiers();
                    Collection<IdReference> jsonIdReferences = jsonResult.getPolicySetIdentifiers();
                    // if both are null we do not get here
                    if (xmlIdReferences == null || jsonIdReferences == null) {
                        fail(f.getName() + " PolicySetIdentifiers has null \nXML=" + xmlIdReferences
                             + "\nJSON=" + jsonIdReferences);
                    }
                    if (!ListUtil.equalsAllowNulls(xmlIdReferences, jsonIdReferences)) {
                        // collections are not equal, so need to examine further
                        fail(f.getName() + " PolicySetIdentifiers collections not equal\nXML="
                             + xmlIdReferences + "\nJSON=" + jsonIdReferences);
                    }
                }

            }

        } catch (Exception e) {
            fail("Failed test with '" + currentFile.getName() + "', e=" + e);
        }

    }

    //
    // HELPER to get list of all Request files in the given directory
    //

    private List<File> getRequestsInDirectory(File directory) {
        List<File> fileList = new ArrayList<File>();

        File[] fileArray = directory.listFiles();
        for (File f : fileArray) {
            if (f.isDirectory()) {
                List<File> subDirList = getRequestsInDirectory(f);
                fileList.addAll(subDirList);
            }
            if (f.getName().endsWith("Response.xml")) {
                fileList.add(f);
            }
        }
        return fileList;

    }

}

/*
 * This is a place to copy the really long output from test rigs that need to be manually edited for
 * readability....
 * {"Response":[{"Status":{"StatusCode":{"Value":"urn:oasis:names:tc:xacml:1.0:status:ok"}},"Obligations"
 * :[{"Id":"urn:oasis:names:tc:xacml:2.0:conformance-test:IIIA030:obligation-1","AttributeAssignment":[
 * {"Value":"assignment1","DataType":"string","AttributeId":
 * "urn:oasis:names:tc:xacml:2.0:conformance-test:IIIA030:assignment1"},
 * {"Value":{"Namespaces":[{"Namespace":"urn:oasis:names:tc:xacml:3.0:core:schema:wd-17"
 * },{"Namespace":"http://www.w3.org/2001/XMLSchema-instance","Prefix":"xsi"}],
 * "XPathCategory":"urn:oasis:names:tc:xacml:3.0:attribute-category:resource",
 * "XPath":"//md:records/md:record"}, "DataType":"xpathExpression",
 * "AttributeId":"urn:oasis:names:tc:xacml:2.0:conformance-test:IIIA030:assignment2"
 * }]}],"Decision":"Permit"}]}
 */