/*!
 * Copyright (C) 2017 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.
 */
import RestAPIUtil from 'nfvo-utils/RestAPIUtil.js';
import Configuration from 'sdc-app/config/Configuration.js';
import i18n from 'nfvo-utils/i18n/i18n.js';
import { actionTypes } from './computeComponents/computeFlavor/ComputeFlavorConstants.js';
import { modalContentMapper } from 'sdc-app/common/modal/ModalContentMapper.js';
import {
    actionTypes as globalModalActionTypes,
    modalSizes
} from 'nfvo-components/modal/GlobalModalConstants.js';
import ValidationHelper from 'sdc-app/common/helpers/ValidationHelper.js';
import { COMPONENTS_COMPUTE_QUESTIONNAIRE } from 'sdc-app/onboarding/softwareProduct/components/SoftwareProductComponentsConstants.js';

function baseUrl(softwareProductId, componentId, version) {
    const versionId = version.id;
    const restPrefix = Configuration.get('restPrefix');
    return `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${versionId}/components/${componentId}/compute-flavors`;
}

function baseUrlVSPLevel(softwareProductId, version) {
    const versionId = version.id;
    const restPrefix = Configuration.get('restPrefix');
    return `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${versionId}/compute-flavors`;
}

function fetchComputesList(softwareProductId, componentId, version) {
    return RestAPIUtil.fetch(
        `${baseUrl(softwareProductId, componentId, version)}`
    );
}

function fetchComputesListForVSP(softwareProductId, version) {
    return RestAPIUtil.fetch(`${baseUrlVSPLevel(softwareProductId, version)}`);
}

function fetchCompute(softwareProductId, componentId, computeId, version) {
    return RestAPIUtil.fetch(
        `${baseUrl(softwareProductId, componentId, version)}/${computeId}`
    );
}

function fetchComputeQuestionnaire({
    softwareProductId,
    componentId,
    computeId,
    version
}) {
    return RestAPIUtil.fetch(
        `${baseUrl(
            softwareProductId,
            componentId,
            version
        )}/${computeId}/questionnaire`
    );
}

function postCompute({ softwareProductId, componentId, compute, version }) {
    return RestAPIUtil.post(
        baseUrl(softwareProductId, componentId, version),
        compute
    );
}

function putCompute({ softwareProductId, componentId, compute, version }) {
    const computeData = {
        name: compute.name,
        description: compute.description
    };
    return RestAPIUtil.put(
        `${baseUrl(softwareProductId, componentId, version)}/${compute.id}`,
        computeData
    );
}

function putComputeQuestionnaire({
    softwareProductId,
    componentId,
    computeId,
    qdata,
    version
}) {
    return RestAPIUtil.put(
        `${baseUrl(
            softwareProductId,
            componentId,
            version
        )}/${computeId}/questionnaire`,
        qdata
    );
}

function deleteCompute({ softwareProductId, componentId, computeId, version }) {
    return RestAPIUtil.destroy(
        `${baseUrl(softwareProductId, componentId, version)}/${computeId}`
    );
}

const ComputeFlavorActionHelper = {
    openComputeEditor(dispatch, { props }) {
        dispatch({
            type: actionTypes.computeEditor.LOAD_EDITOR_DATA,
            compute: props.compute || {}
        });
        dispatch({
            type: globalModalActionTypes.GLOBAL_MODAL_SHOW,
            data: {
                modalComponentName:
                    modalContentMapper.COMPONENT_COMPUTE_FLAVOR_EDITOR,
                modalClassName: `compute-flavor-editor-modal-${
                    props.compute ? 'edit' : 'create'
                }`,
                modalComponentProps: {
                    ...props,
                    size: props.compute ? modalSizes.LARGE : undefined,
                    dialogClassName: 'compute-flavor-editor-modal'
                },
                title: `${
                    props.compute
                        ? i18n('Edit Compute Flavor')
                        : i18n('Create New Compute Flavor')
                }`
            }
        });
    },

    closeComputeEditor(dispatch) {
        dispatch({
            type: globalModalActionTypes.GLOBAL_MODAL_CLOSE
        });
        dispatch({
            type: actionTypes.computeEditor.CLEAR_DATA
        });
    },

    fetchComputesList(dispatch, { softwareProductId, componentId, version }) {
        return fetchComputesList(softwareProductId, componentId, version).then(
            response =>
                dispatch({
                    type: actionTypes.COMPUTE_FLAVORS_LIST_LOADED,
                    response
                })
        );
    },

    fetchComputesListForVSP(dispatch, { softwareProductId, version }) {
        return fetchComputesListForVSP(softwareProductId, version).then(
            response =>
                dispatch({
                    type: actionTypes.COMPUTE_FLAVORS_LIST_LOADED,
                    response
                })
        );
    },

    loadComputeData({ softwareProductId, componentId, computeId, version }) {
        return fetchCompute(softwareProductId, componentId, computeId, version);
    },

    loadComputeQuestionnaire(
        dispatch,
        { softwareProductId, componentId, computeId, version }
    ) {
        return fetchComputeQuestionnaire({
            softwareProductId,
            componentId,
            computeId,
            version
        }).then(response =>
            ValidationHelper.qDataLoaded(dispatch, {
                qName: COMPONENTS_COMPUTE_QUESTIONNAIRE,
                response: {
                    qdata: response.data ? JSON.parse(response.data) : {},
                    qschema: JSON.parse(response.schema)
                }
            })
        );
    },

    loadCompute(
        dispatch,
        { softwareProductId, componentId, version, computeId, isReadOnlyMode }
    ) {
        return ComputeFlavorActionHelper.loadComputeData({
            softwareProductId,
            componentId,
            computeId,
            version
        }).then(({ data }) =>
            ComputeFlavorActionHelper.loadComputeQuestionnaire(dispatch, {
                softwareProductId,
                componentId,
                computeId,
                version
            }).then(() =>
                ComputeFlavorActionHelper.openComputeEditor(dispatch, {
                    props: {
                        softwareProductId,
                        componentId,
                        version,
                        isReadOnlyMode,
                        compute: { id: computeId, ...data }
                    }
                })
            )
        );
    },

    saveComputeDataAndQuestionnaire(
        dispatch,
        { softwareProductId, componentId, data: compute, qdata, version }
    ) {
        ComputeFlavorActionHelper.closeComputeEditor(dispatch);
        if (compute.id) {
            return Promise.all([
                putComputeQuestionnaire({
                    softwareProductId,
                    componentId,
                    computeId: compute.id,
                    qdata,
                    version
                }),
                putCompute({
                    softwareProductId,
                    componentId,
                    compute,
                    version
                }).then(() => {
                    dispatch({
                        type: actionTypes.COMPUTE_LIST_EDIT,
                        compute
                    });
                })
            ]);
        } else {
            return postCompute({
                softwareProductId,
                componentId,
                compute,
                version
            }).then(response =>
                dispatch({
                    type: actionTypes.ADD_COMPUTE,
                    compute: {
                        ...compute,
                        id: response.id,
                        componentId
                    }
                })
            );
        }
    },

    deleteCompute(
        dispatch,
        { softwareProductId, componentId, computeId, version }
    ) {
        return deleteCompute({
            softwareProductId,
            componentId,
            computeId,
            version
        }).then(() =>
            dispatch({
                type: actionTypes.DELETE_COMPUTE,
                computeId
            })
        );
    }
};

export default ComputeFlavorActionHelper;