/*******************************************************************************
 * Copyright 2014 Federal Chancellery Austria
 * MOA-ID has been developed in a cooperation between BRZ, the Federal
 * Chancellery Austria - ICT staff unit, and Graz University of Technology.
 *
 * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 * http://www.osor.eu/eupl/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 *
 * This product combines work with different licenses. See the "NOTICE" text
 * file for details on the various modules and licenses.
 * The "NOTICE" text file is part of the distribution. Any derivative works
 * that you distribute must include a readable copy of the "NOTICE" text file.
 *******************************************************************************/
package at.gv.egovernment.moa.id.protocols.stork2;

import at.gv.egovernment.moa.id.auth.builder.BPKBuilder;
import at.gv.egovernment.moa.id.auth.data.IdentityLink;
import at.gv.egovernment.moa.id.auth.exception.BuildException;
import at.gv.egovernment.moa.id.data.AuthenticationRole;
import at.gv.egovernment.moa.id.data.IAuthData;
import at.gv.egovernment.moa.id.util.PVPtoSTORKRoleMapper;
import at.gv.egovernment.moa.logging.Logger;
import at.gv.egovernment.moa.util.MiscUtil;
import eu.stork.peps.auth.commons.PersonalAttribute;
import eu.stork.peps.auth.commons.PersonalAttributeList;
import eu.stork.peps.auth.commons.STORKStatusCode;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import javassist.expr.Instanceof;

/**
 * @author bsuzic
 *         Date: 2/19/14, Time: 4:42 PM
 *         
 * @author tlenz
 * 		   Date: 23.10.14
 */
public class MOAAttributeProvider {
    private final IAuthData authData;
    private static final Map<String, String> storkAttributeSimpleMapping;
    private static final Map<String, String> storkAttributeFunctionMapping;
    private final MOASTORKRequest moastorkRequest;

    static {
        Map<String, String> tempSimpleMap = new HashMap<String, String>();
        tempSimpleMap.put("givenName", "getGivenName");
        tempSimpleMap.put("surname", "getFamilyName");
        storkAttributeSimpleMapping = Collections.unmodifiableMap(tempSimpleMap);
        Map<String, String> tempFunctionMap = new HashMap<String, String>();
        tempFunctionMap.put("eIdentifier", "geteIdentifier");
        tempFunctionMap.put("ECApplicationRole","getECApplicationRole");
        tempSimpleMap.put("dateOfBirth", "getFormatedDateOfBirth");
        storkAttributeFunctionMapping = Collections.unmodifiableMap(tempFunctionMap);
    }

    public MOAAttributeProvider(IAuthData authData, MOASTORKRequest moastorkRequest) {
        this.authData = authData;
        this.moastorkRequest = moastorkRequest;
        Logger.debug("identity " + authData.getIdentificationType() + " " + authData.getIdentificationValue());
    }

    public void populateAttribute(PersonalAttributeList attributeList, PersonalAttribute requestedAttribute ) {
        String storkAttribute = requestedAttribute.getName();
        if (storkAttributeSimpleMapping.containsKey(storkAttribute)) {
            Logger.debug("Trying to get value for attribute using simple mapping [" + storkAttribute + "]");
            try {
                Method method = authData.getClass().getDeclaredMethod(storkAttributeSimpleMapping.get(storkAttribute));
                populateAttributeWithMethod(method, authData, attributeList, storkAttribute, requestedAttribute.isRequired());
            } catch (NoSuchMethodException e) {
                Logger.error("Could not found MOA extraction method while getting attribute: " + storkAttribute);
                e.printStackTrace();
            }

        } else if (storkAttributeFunctionMapping.containsKey(storkAttribute)) {

            Logger.debug("Trying to get value for attribute using function mapping [" + storkAttribute + "]");
            try {
                Method method = this.getClass().getDeclaredMethod(storkAttributeFunctionMapping.get(storkAttribute));
                populateAttributeWithMethod(method, this, attributeList, storkAttribute, requestedAttribute.isRequired());
            } catch (NoSuchMethodException e) {
                Logger.error("Could not found MOA extraction method while getting attribute: " + storkAttribute);
                e.printStackTrace();
            }
        } else {
            Logger.debug("MOA method for extraction of attribute " + storkAttribute + " not defined.");
        }
    }

    private String geteIdentifier() {
        Logger.debug("Using base urn for identification value: " + authData.getIdentificationType() + " and target country: " + moastorkRequest.getStorkAuthnRequest().getSpCountry());
        try {
            return new BPKBuilder().buildStorkeIdentifier(authData.getIdentificationType(), authData.getIdentificationValue(), 
            			moastorkRequest.getStorkAuthnRequest().getSpCountry());
        } catch (BuildException be) {
            Logger.error("Stork eid could not be constructed; " + be.getMessage());
            return null; // TODO error
        }
    }

    private List<String> getECApplicationRole() {    	
    	List<String> storkRoles = null;
    	    	
    	if (true || authData.getAuthenticationRoles() != null 
    			&& authData.getAuthenticationRoles().size() > 0) {

    		storkRoles = new ArrayList<String>();
    		PVPtoSTORKRoleMapper mapper = PVPtoSTORKRoleMapper.getInstance();
    		for (AuthenticationRole el : authData.getAuthenticationRoles()) {
    			String storkRole = mapper.map(el);
    			if (MiscUtil.isNotEmpty(storkRole))
    				storkRoles.add(storkRole);
    			
    		}    		
    	}    	
    	return storkRoles;
    }

    private String getFormatedDateOfBirth() {
		if (authData.getDateOfBirth() != null) {
			DateFormat fmt = new SimpleDateFormat("yyyyMMdd");
    		return  fmt.format(authData.getDateOfBirth());
    		
		}
   		else
   			return null;
    	
    }
    
    private void populateAttributeWithMethod(Method method, Object object, PersonalAttributeList attributeList, String storkAttribute, Boolean isRequired) {
        try {
            Object attributeValue = method.invoke(object, new Class[]{});
            
            PersonalAttribute newAttribute = new PersonalAttribute();
            newAttribute.setName(storkAttribute);
            newAttribute.setIsRequired(isRequired);
            
            if (attributeValue != null) {
            	newAttribute.setStatus(STORKStatusCode.STATUS_AVAILABLE.name());            	
            	Logger.info("Got attribute value: " + attributeValue);
            
            	if (attributeValue instanceof String)            
            		newAttribute.setValue(new ArrayList<String>(Collections.singletonList((String)attributeValue)));
            
            	else if (attributeValue instanceof List<?>) {
            		List<?> attributeValueList = (List<?>) attributeValue;
            		if (attributeValueList.size() > 0 && attributeValueList.get(0) instanceof String) {
            			newAttribute.setValue((List<String>) attributeValueList);
            		
            		} else {
            			Logger.info("Attribute " + storkAttribute + " is not available.");
                    	newAttribute.setStatus(STORKStatusCode.STATUS_NOT_AVAILABLE.name());
            			
            		}
            			            	
            	} else {
            		Logger.error("Receive an unsupported type for attribute " + storkAttribute);
            	
            	}            
            	attributeList.add(newAttribute);
            	
            } else {
            	Logger.info("Attribute " + storkAttribute + " is not available.");
            	newAttribute.setStatus(STORKStatusCode.STATUS_NOT_AVAILABLE.name());
            }
            
        } catch (InvocationTargetException e) {
            Logger.error("Invocation target exception while getting attribute: " + storkAttribute);
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            Logger.error("Illegal access exception while getting attribute: " + storkAttribute);
            e.printStackTrace();
        }
    }


}