export const SHOW_ALL_APPLICATIONS = 'SHOW_ALL_APPLICATIONS';
export const SHOW_ALL_APPLICATIONS_ERROR = 'SHOW_ALL_APPLICATIONS_ERROR';
export const SHOW_MY_APPLICATIONS = 'SHOW_MY_APPLICATIONS';
export const SHOW_MY_APPLICATIONS_ERROR = 'SHOW_MY_APPLICATIONS_ERROR';
export const CREATE_NEW_APPLICATION_SUCCESS = 'CREATE_NEW_APPLICATION_SUCCESS';
export const CREATE_NEW_APPLICATION_ERROR = 'CREATE_NEW_APPLICATION_ERROR';
export const EDIT_APPLICATION_SUCCESS = 'EDIT_APPLICATION_SUCCESS';
export const EDIT_APPLICATION_ERROR = 'EDIT_APPLICATION_ERROR';
export const DELETE_APPLICATION_SUCCESS = 'DELETE_APPLICATION_SUCCESS';
export const DELETE_APPLICATION_ERROR = 'DELETE_APPLICATION_ERROR'

export const SHOW_DELETE_APPLICATION_MODAL = 'SHOW_DELETE_APPLICATION_MODAL'
export const HIDE_DELETE_APPLICATION_MODAL = 'HIDE_DELETE_APPLICATION_MODAL'
export const PRESS_EDIT_BUTTON = 'PRESS_EDIT_BUTTON';

const URL = process.env.REACT_APP_SERVER

export function getShowDeleteApplicationModalAction(deleteModalData) {
    return {
        type: SHOW_DELETE_APPLICATION_MODAL,
        deleteApplicationModalData: deleteModalData
    }
}

export function getHideDeleteApplicationModalAction() {
    return {
        type: HIDE_DELETE_APPLICATION_MODAL
    }
}


export function getCreateNewApplicationSuccessAction(applicationData) {
    return {
        type: CREATE_NEW_APPLICATION_SUCCESS,
        newApplicationData: applicationData
    }
}

export function getCreateNewApplicationErrorAction(error) {
    return {
        type: CREATE_NEW_APPLICATION_ERROR,
        error: error
    }
}

export function createNewApplication(applicationData, token) {

    const requestOptions = {
        method: 'POST',
        headers: {
            'Authorization': token,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(applicationData)
    }

    return fetch(URL + '/degreeCourseApplications', requestOptions)
        .then(response => {
            return response.json().then(body => {
                if (response.status === 201) {
                    return body
                }
            })
        })
}

export function passNewApplication(applicationData, token) {

    return dispatch => {
        dispatch(getCreateNewApplicationSuccessAction());
        createNewApplication(applicationData, token)
            .then(newApplication => {
                const action = getCreateNewApplicationSuccessAction(newApplication)
                dispatch(action);
            },
                error => {
                    dispatch(getCreateNewApplicationErrorAction(error));
                }
            )
            .catch(error => {
                dispatch(getCreateNewApplicationErrorAction(error))
            })
    }
}




export function getAllApplicationsAction(applications) {
    return {
        type: SHOW_ALL_APPLICATIONS,
        applicationList: applications
    }
}

export function getMyApplicationsAction(applications) {
    return {
        type: SHOW_MY_APPLICATIONS,
        applicationList: applications
    }
}


export function getAllApplicationsErrorAction(error) {
    return {
        type: SHOW_ALL_APPLICATIONS_ERROR,
        error: error
    }
}

export function getMyApplicationsErrorAction(error) {
    return {
        type: SHOW_MY_APPLICATIONS_ERROR,
        error: error
    }
}


export function getAllApplications(token) {

    const requestOptions = {
        method: 'GET',
        headers: { 'Authorization': token }
    };

    return fetch(URL + '/degreeCourseApplications', requestOptions)
        .then(response => {
            return response.json().then(body => {
                if (response.status === 200) {
                    return body
                }
            })
        })
}

export function getMyApplications(token) {
    const requestOptions = {
        method: 'GET',
        headers: { 'Authorization': token }
    };

    return fetch(URL + '/degreeCourseApplications/myApplications', requestOptions)
        .then(response => {
            return response.json().then(body => {
                if (response.status === 200) {
                    return body
                }
            })
        })
}


export function displayAllApplications(token) {

    return dispatch => {
        dispatch(getAllApplicationsAction());
        getAllApplications(token)
            .then(applications => {
                const action = getAllApplicationsAction(applications)
                dispatch(action);
            },
                error => {
                    dispatch(getAllApplicationsErrorAction(error));
                }
            )
            .catch(error => {
                dispatch(getAllApplicationsErrorAction(error))
            })
    }
}

export function displayMyApplications(token) {

    return dispatch => {
        dispatch(getMyApplicationsAction());
        getMyApplications(token)
            .then(applications => {
                const action = getMyApplicationsAction(applications);
                dispatch(action);
            },
                error => {
                    dispatch(getMyApplicationsErrorAction(error));
                }
            )
            .catch(error => {
                dispatch(getMyApplicationsErrorAction(error));
            })
    }
}


export function getEditApplicationSuccessAction() {
    return {
        type: EDIT_APPLICATION_SUCCESS
    }
}

export function getEditApplicationErrorAction() {
    return {
        type: EDIT_APPLICATION_ERROR
    }
}

export function updateApplication(updateData, applicationID, token) {
    const requestOptions = {
        method: 'PUT',
        headers: {
            'Authorization': token,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(updateData)
    }

    return fetch(URL + `/degreeCourseApplications/${applicationID}`, requestOptions)
        .then(response => {
            return response.json().then(body => {
                if (response.status === 200) {
                    return body
                }
            })
        })
}

export function editApplicationWithID(updateData, applicationID, token) {
    return dispatch => {
        dispatch(getEditApplicationSuccessAction());
        updateApplication(updateData, applicationID, token)
            .then(application => {
                const action = getEditApplicationSuccessAction(application)
                dispatch(action);
                getAllApplications(token)
                    .then(applications => {
                        const action = getAllApplicationsAction(applications)
                        dispatch(action)
                    })
            },
                error => {
                    dispatch(getEditApplicationErrorAction(error));
                }
            )
            .catch(error => {
                dispatch(getEditApplicationErrorAction(error))
            })
    }
}




export function getDeleteApplicationSuccessAction() {
    return {
        type: DELETE_APPLICATION_SUCCESS
    }
}

export function getDeleteApplicationErrorAction(error) {
    return {
        type: DELETE_APPLICATION_ERROR,
        error: error
    }
}

export function deleteApplication(applicationID, token) {
    const requestOptions = {
        method: 'DELETE',
        headers: {
            'Authorization': token
        }
    }

    return fetch(URL + '/degreeCourseApplications/' + applicationID, requestOptions)
        .then(response => {
            if (response.status === 204) {
                return response.status
            }
        })
}

export function deleteApplicationWithID(applicationID, token) {
    return dispatch => {
        dispatch(getDeleteApplicationSuccessAction(applicationID));
        deleteApplication(applicationID, token)
            .then(deleteApplication => {
                const action = getDeleteApplicationSuccessAction(deleteApplication)
                dispatch(action);
                getAllApplications(token)
                    .then(applications => {
                        const action = getAllApplicationsAction(applications)
                        dispatch(action)
                    })
            },
                error => {
                    dispatch(getDeleteApplicationErrorAction(error));
                }
            )
            .catch(error => {
                dispatch(getDeleteApplicationErrorAction(error))
            })
    }
}