/*
 * Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
 *
 * WSO2 Inc. 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.
 */

package org.wso2.carbon.mdm.services.android.exception;

import com.google.gson.JsonParseException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.mdm.services.android.util.AndroidDeviceUtils;

import javax.naming.AuthenticationException;
import javax.validation.ConstraintViolationException;
import javax.ws.rs.ClientErrorException;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;

/**
 * Handle the cxf level exceptions.
 */
public class GlobalThrowableMapper implements ExceptionMapper {
    private static final Log log = LogFactory.getLog(GlobalThrowableMapper.class);

    private ErrorDTO e500 = new ErrorDTO();

    GlobalThrowableMapper() {
        e500.setCode((long) 500);
        e500.setMessage("Internal server error.");
        e500.setMoreInfo("");
        e500.setDescription("The server encountered an internal error. Please contact administrator.");

    }

    @Override
    public Response toResponse(Throwable e) {

        if (e instanceof JsonParseException) {
            String errorMessage = "Malformed request body.";
            if (log.isDebugEnabled()) {
                log.debug(errorMessage, e);
            }
            return AndroidDeviceUtils.buildBadRequestException(errorMessage).getResponse();
        }
        if (e instanceof NotFoundException) {
                return ((NotFoundException) e).getResponse();
        }
        if (e instanceof BadRequestException) {
            return ((BadRequestException) e).getResponse();
        }
        if (e instanceof UnexpectedServerErrorException) {
            if (log.isDebugEnabled()) {
                log.debug("Unexpected server error", e);
            }
            return ((UnexpectedServerErrorException) e).getResponse();
        }
        if (e instanceof ConstraintViolationException) {
            if (log.isDebugEnabled()) {
                log.debug("Constraint violation issue.", e);
                return ((ParameterValidationException) e).getResponse();
            }
        }
        if (e instanceof IllegalArgumentException) {
            ErrorDTO errorDetail = new ErrorDTO();
            errorDetail.setCode((long) 400);
            errorDetail.setMoreInfo("");
            errorDetail.setMessage("");
            errorDetail.setDescription(e.getMessage());
            return Response
                    .status(Response.Status.BAD_REQUEST)
                    .entity(errorDetail)
                    .build();
        }
        if (e instanceof ClientErrorException) {
            if (log.isDebugEnabled()) {
                log.debug("Client error", e);
            }
            return ((ClientErrorException) e).getResponse();
        }
        if (e instanceof AuthenticationException) {
            ErrorDTO errorDetail = new ErrorDTO();
            errorDetail.setCode((long) 401);
            errorDetail.setMoreInfo("");
            errorDetail.setMessage("");
            errorDetail.setDescription(e.getMessage());
            return Response
                    .status(Response.Status.UNAUTHORIZED)
                    .entity(errorDetail)
                    .build();
        }
        if (e instanceof ForbiddenException) {
            if (log.isDebugEnabled()) {
                log.debug("Resource forbidden", e);
            }
            return ((ForbiddenException) e).getResponse();
        }
        //unknown exception log and return
            log.error("An Unknown exception has been captured by global exception mapper.", e);
        return Response.status(Response.Status.INTERNAL_SERVER_ERROR).header("Content-Type", "application/json")
                .entity(e500).build();
    }
}
