/*-
 * ============LICENSE_START=======================================================
 * ONAP-PAP-REST
 * ================================================================================
 * Copyright (C) 2018-2019 AT&T Intellectual Property. All rights reserved.
 * ================================================================================
 * 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.
 * ============LICENSE_END=========================================================
 */

package org.onap.policy.pap.xacml.rest;

import com.att.research.xacml.util.XACMLProperties;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.json.JSONObject;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.pap.xacml.rest.adapters.UpdateObjectData;
import org.onap.policy.pap.xacml.rest.components.Policy;
import org.onap.policy.pap.xacml.rest.util.JsonMessage;
import org.onap.policy.rest.XACMLRestProperties;
import org.onap.policy.rest.dao.CommonClassDao;
import org.onap.policy.rest.jpa.ActionBodyEntity;
import org.onap.policy.rest.jpa.ConfigurationDataEntity;
import org.onap.policy.rest.jpa.PolicyDBDaoEntity;
import org.onap.policy.utils.PeCryptoUtils;
import org.onap.policy.xacml.api.XACMLErrorConstants;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;

@Controller
public class UpdateOthersPAPS {

    private static final Logger policyLogger = FlexLogger.getLogger(UpdateOthersPAPS.class);

    private static CommonClassDao commonClassDao;

    private static final String contentType = "application/json";
    private static String configType =".Config_";
    private static String actionType =".Action_";
    private static String error ="error";
    public static CommonClassDao getCommonClassDao() {
        return commonClassDao;
    }

    public static void setCommonClassDao(CommonClassDao commonClassDao) {
        UpdateOthersPAPS.commonClassDao = commonClassDao;
    }

    @Autowired
    private UpdateOthersPAPS(CommonClassDao commonClassDao) {
        UpdateOthersPAPS.commonClassDao = commonClassDao;
    }

    public UpdateOthersPAPS() {
        //Empty Constructor
    }

    @RequestMapping(value="/notifyOtherPAPs", method= RequestMethod.POST)
    public void  notifyOthersPAPsToUpdateConfigurations(HttpServletRequest request, HttpServletResponse response){
        Map<String, Object> model = new HashMap<>();
        ObjectMapper mapper = new ObjectMapper();
        UpdateObjectData body = new UpdateObjectData();
        body.setAction(request.getParameter("action"));
        body.setNewPolicyName(request.getParameter("newPolicyName"));
        body.setOldPolicyName(request.getParameter("oldPolicyName"));

        String currentPap = XACMLRestProperties.getProperty("xacml.rest.pap.url");
        List<Object> getPAPUrls = commonClassDao.getData(PolicyDBDaoEntity.class);
        if(getPAPUrls != null && !getPAPUrls.isEmpty()){
            for(int i = 0; i < getPAPUrls.size(); i++){
                PolicyDBDaoEntity papId = (PolicyDBDaoEntity) getPAPUrls.get(i);
                String papUrl = papId.getPolicyDBDaoUrl();
                if(!papUrl.equals(currentPap)){
                    String userName = papId.getUsername();
                    String password = papId.getPassword();
                    Base64.Encoder encoder = Base64.getEncoder();
                    String txt;
                    try {
                        PeCryptoUtils.initAesKey(XACMLProperties.getProperty(XACMLRestProperties.PROP_AES_KEY));
                        txt = PeCryptoUtils.decrypt(password);
                    } catch (Exception e) {
                        policyLogger.debug(e);
                        //if we can't decrypt, might as well try it anyway
                        txt = password;
                    }
                    String encoding = encoder.encodeToString((userName + ":" + txt).getBytes(StandardCharsets.UTF_8));
                    HttpHeaders headers = new HttpHeaders();
                    headers.set("Authorization", "Basic " + encoding);
                    headers.set("Content-Type", contentType);

                    RestTemplate restTemplate = new RestTemplate();
                    HttpEntity<?> requestEntity = new HttpEntity<>(body, headers);
                    HttpClientErrorException exception = null;

                    try{
                        restTemplate.exchange(papUrl + "onap/updateConfiguration", HttpMethod.POST, requestEntity, String.class);
                    }catch(Exception e){
                        policyLogger.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error while connecting to " + papUrl, e);
                        exception = new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage());
                        if("409 Conflict".equals(e.getMessage())){
                            policyLogger.error(e.getMessage());
                            response.addHeader(error, e.getMessage());
                        }
                    }
                    if(exception != null && exception.getStatusCode()!=null){
                        String message;
                        if(exception.getStatusCode().equals(HttpStatus.UNAUTHORIZED)){
                            message = XACMLErrorConstants.ERROR_PERMISSIONS +":"+exception.getStatusCode()+":" + "ERROR_AUTH_GET_PERM" ;
                            policyLogger.error(message);
                        }else if(exception.getStatusCode().equals(HttpStatus.BAD_REQUEST)){
                            message = XACMLErrorConstants.ERROR_DATA_ISSUE + ":"+exception.getStatusCode()+":" + exception.getResponseBodyAsString();
                            policyLogger.error(message);
                        }else if(exception.getStatusCode().equals(HttpStatus.NOT_FOUND)){
                            message = XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error while connecting to " + papUrl + exception;
                            policyLogger.error(message);
                        }else{
                            message = XACMLErrorConstants.ERROR_PROCESS_FLOW + ":"+exception.getStatusCode()+":" + exception.getResponseBodyAsString();
                            policyLogger.error(message);
                        }
                        model.put(papUrl, message);
                    }else{
                        model.put(papUrl, "Success");
                    }
                }
            }
            JsonMessage msg;
            try {
                msg = new JsonMessage(mapper.writeValueAsString(model));
                JSONObject j = new JSONObject(msg);
                response.getWriter().write(j.toString());
            } catch (Exception e) {
                policyLogger.error("Exception Occured"+e);
            }
        }
    }

    @RequestMapping(value="/updateConfiguration", method= RequestMethod.POST)
    @ResponseBody
    public void updateConfiguration(@RequestBody UpdateObjectData data, HttpServletResponse response){
        String action = data.getAction();
        String newPolicyName = data.getNewPolicyName();
        String oldPolicyName = data.getOldPolicyName();
        try{
            if("rename".equals(action)){
                if(oldPolicyName.contains(configType) || oldPolicyName.contains(actionType)){
                    File file;
                    if(oldPolicyName.contains(configType)){
                        file = new File(Policy.getConfigHome() + File.separator + oldPolicyName);
                    }else{
                        file = new File(Policy.getActionHome() + File.separator + oldPolicyName);
                    }
                    if(file.exists()){
                        File renamefile;
                        if(oldPolicyName.contains(configType)){
                            renamefile = new File(Policy.getConfigHome() + File.separator + newPolicyName);
                        }else{
                            renamefile = new File(Policy.getActionHome() + File.separator + newPolicyName);
                        }
                        if(file.renameTo(renamefile)){
                            policyLogger.info("Policy has been renamed Successfully"+newPolicyName);
                            response.addHeader("rename", "Success");
                        }else{
                            response.addHeader("rename", "Failure");
                        }
                    }
                }
            }else if("delete".equals(action)){
                if(oldPolicyName.contains(configType)){
                    Files.deleteIfExists(Paths.get(Policy.getConfigHome() + File.separator + oldPolicyName));
                }else if(oldPolicyName.contains("Action_")){
                    Files.deleteIfExists(Paths.get(Policy.getActionHome() + File.separator + oldPolicyName));
                }
            }else if("clonePolicy".equals(action) || "exportPolicy".equals(action)){
                if(newPolicyName.contains(configType)){
                    ConfigurationDataEntity configEntiy = (ConfigurationDataEntity) commonClassDao.getEntityItem(ConfigurationDataEntity.class, "configurationName", newPolicyName);
                    saveConfigurationData(configEntiy, newPolicyName);
                }else if(newPolicyName.contains(actionType)){
                    ActionBodyEntity actionEntiy = (ActionBodyEntity) commonClassDao.getEntityItem(ActionBodyEntity.class, "actionBodyName", newPolicyName);
                    saveActionBodyData(actionEntiy, newPolicyName);
                }
            }
        } catch (IOException e) {
            policyLogger.error("Exception Occured While updating Configuration"+e);
        }
    }

    private void saveConfigurationData(ConfigurationDataEntity configEntiy, String newPolicyName){
        try(FileWriter fw = new FileWriter(Policy.getConfigHome() + File.separator + newPolicyName)){
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write(configEntiy.getConfigBody());
            bw.close();
        }catch (IOException e) {
            policyLogger.error("Exception Occured While closing the File input stream"+e);
        }
    }

    private void saveActionBodyData(ActionBodyEntity actionEntiy , String newPolicyName){
        try(FileWriter fw  = new FileWriter(Policy.getActionHome() + File.separator + newPolicyName)){
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write(actionEntiy.getActionBody());
            bw.close();
        }catch (IOException e) {
            policyLogger.error("Exception Occured While closing the File input stream"+e);
        }
    }
}