import axios from 'axios';
import moment from 'moment';
import {showNotification} from "../../js/modules/notification";

axios.defaults.headers.post['Content-Type'] = 'application/json';
axios.defaults.headers.post['Accept'] = 'application/json';

export const api = {
    get: (url, params) => {
        let request = axios.get(url, params);
        request.catch(api.errorHandler);
        return request;
    },
    post: (url, data, params) => {
        let request = axios.post(url, data, params);
        request.catch(api.errorHandler);
        return request;
    },
    put: (url, data, params) => {
        let request = axios.put(url, data, params);
        request.catch(api.errorHandler);
        return request;
    },
    patch: (url, data, params) => {
        let request = axios.patch(url, data, params);
        request.catch(api.errorHandler);
        return request;
    },
    delete: (url, params) => {
        let request = axios.delete(url, params);
        request.catch(api.errorHandler);
        return request;
    },
    errorHandler: (error) => {
        console.log('всё очень плохо', error, error.response);
        if(error.response.status >= 500) {
            showNotification("error", "Ошибка сервера "+error.toString());
        }
    },
    getCurrentUser: (accessToken) => {
        return api.get('/api/v1/users/me/', {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    getUsers: (params, accessToken) => {
        return api.get('/api/v1/users/', {
            params: params,
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    getCategories: (accessToken) => {
        return api.get('/api/v1/categories/', {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    uploadImage: (imageData, accessToken) => {
        return api.post('/api/v1/image-objects/', {
            image: imageData,
        }, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    removeImage: (imageId, accessToken) => {
        return api.delete(`/api/v1/image-objects/${imageId}/`, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    removeGalleryImage: (galleryImageId, accessToken) => {
        return api.delete(`/api/v1/gallery-images/${galleryImageId}/`, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    loadCourse: (courseId, accessToken) => {
        return api.get(`/api/v1/courses/${courseId}/`, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    loadLive: (courseId, accessToken) => {
        return api.get(`/api/v1/live-lesson/${courseId}/`, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    saveCourse: (courseObject, accessToken) => {
        const isAdding = !courseObject.id;

        let deferredStart = null;
        if (courseObject.is_deferred) {
            if (courseObject.date && courseObject.time){
                let deferredStartTime = moment(courseObject.time, "HH:mm");
                let deferredStartDate = moment(courseObject.date).hour(deferredStartTime.hour()).minute(deferredStartTime.minute());
                deferredStart = deferredStartDate.format();
            }
        }

        const courseJson = {
            title: courseObject.title,
            status: courseObject.status,
            author: courseObject.author ? courseObject.author : null,
            short_description: courseObject.short_description,
            category: courseObject.category,
            price: courseObject.is_paid && courseObject.price || 0,
            old_price: courseObject.is_paid && courseObject.old_price || 0,
            age: courseObject.age,
            deferred_start_at: deferredStart,
            access_duration: courseObject.is_paid && courseObject.access_duration || 0,
            is_featured: courseObject.is_featured,
            slug: (courseObject.slug || '').toLowerCase(),
            date: (courseObject.date) ? courseObject.date.value : null,
            stream: courseObject.stream,
            cover: courseObject.coverImageId ? courseObject.coverImageId : null,
            gallery: {
                gallery_images: courseObject.gallery && courseObject.gallery.images || []
            },
            content: api.convertContentJson(courseObject.content, true),
            materials: courseObject.materials,
            tags: courseObject.tags,
        };

        if(courseObject.live) {
            if (isAdding) {
                return api.addLive(courseJson, accessToken);
            } else {
                return api.updateLive(courseObject.id, courseJson, accessToken);
            }
        } else {
            if (isAdding) {
                return api.addCourse(courseJson, accessToken);
            } else {
                return api.updateCourse(courseObject.id, courseJson, accessToken);
            }
        }


    },
    saveLesson: (lessonObject, accessToken) => {
        const isAdding = (!lessonObject.hasOwnProperty('id') || !lessonObject.hasOwnProperty('id'));

        const lessonJson = {
            cover: lessonObject.coverImageId ? lessonObject.coverImageId : null,
            title: lessonObject.title,
            short_description: lessonObject.short_description,
            course: lessonObject.course_id,
            position: lessonObject.position,
            content: api.convertContentJson(lessonObject.content, true),
        };

        if (isAdding) {
            return api.addLesson(lessonJson, accessToken);
        } else {
            return api.updateLesson(lessonObject.id, lessonJson, accessToken);
        }
    },
    convertLessonJson: (lessonJSON) => {
        return {
            id: lessonJSON.id,
            title: lessonJSON.title,
            short_description: lessonJSON.short_description,
            coverImageId: lessonJSON.cover && lessonJSON.cover.id ? lessonJSON.cover.id : null,
            coverImage: lessonJSON.cover && lessonJSON.cover.image ? lessonJSON.cover.image : null,
            content: api.convertContentJson(lessonJSON.content),
            position: lessonJSON.position,
        }
    },
    convertCourseJson: (courseJSON) => {
        let isDeferred = false;
        let deferredDate = null;
        let deferredTime = null;
        if (courseJSON.deferred_start_at) {
            let deferredDateTime = moment.utc(courseJSON.deferred_start_at).local();
            isDeferred = true;
            deferredDate = deferredDateTime.format('MM-DD-YYYY');
            deferredTime = deferredDateTime.format('HH:mm');
        }
        return {
            id: courseJSON.id,
            age: courseJSON.age,
            title: courseJSON.title,
            status: courseJSON.status,
            short_description: courseJSON.short_description,
            category: courseJSON.category && courseJSON.category.id ? courseJSON.category.id : courseJSON.category,
            author: courseJSON.author && courseJSON.author.id ? courseJSON.author.id : courseJSON.author,
            price: parseFloat(courseJSON.price),
            old_price: parseFloat(courseJSON.old_price),
            is_paid: parseFloat(courseJSON.price) > 0,
            is_deferred: isDeferred,
            date: deferredDate || courseJSON.date,
            time: deferredTime,
            access_duration: courseJSON.access_duration,
            is_featured: courseJSON.is_featured,
            slug: courseJSON.slug,
            stream: courseJSON.stream,
            coverImageId: courseJSON.cover && courseJSON.cover.id ? courseJSON.cover.id : null,
            coverImage: courseJSON.cover && courseJSON.cover.image ? courseJSON.cover.image : null,
            content: api.convertContentJson(courseJSON.content),
            gallery: {images: (courseJSON.gallery) ? courseJSON.gallery.gallery_images:[]},
            materials: courseJSON.materials,
            tags: courseJSON.tags,
        }
    },
    convertGalleryImagesJson: (images) => {
        return images.map((galleryImage) => {
            return {
                'id': galleryImage.id ? galleryImage.id : null,
                'img': galleryImage.image_id,
            }
        });
    },
    convertContentJson: (contentJson, forSaving) => {
        if(forSaving){
            let content = contentJson.map((block, index) => {
                if (block.type === 'text') {
                    return {
                        'type': 'text',
                        'data': {
                            'id': block.data.id ? block.data.id : null,
                            'uuid': block.uuid,
                            'position': index + 1,
                            'title': block.data.title,
                            'txt': block.data.text,
                        }
                    }
                } else if (block.type === 'image') {
                    return {
                        'type': 'image',
                        'data': {
                            'id': block.data.id ? block.data.id : null,
                            'uuid': block.uuid,
                            'position': index + 1,
                            'title': block.data.title,
                            'img': block.data.image_id,
                        }
                    }
                } else if (block.type === 'image-text') {
                    return {
                        'type': 'image-text',
                        'data': {
                            'id': block.data.id ? block.data.id : null,
                            'uuid': block.uuid,
                            'position': index + 1,
                            'title': block.data.title,
                            'img': block.data.image_id,
                            'txt': block.data.text,
                        }
                    }
                } else if (block.type === 'images') {
                    return {
                        'type': 'images',
                        'data': {
                            'id': block.data.id ? block.data.id : null,
                            'uuid': block.uuid,
                            'position': index + 1,
                            'title': block.data.title,
                            'images': api.convertGalleryImagesJson(block.data.images),
                        }
                    }
                } else if (block.type === 'video') {
                    return {
                        'type': 'video',
                        'data': {
                            'id': block.data.id ? block.data.id : null,
                            'uuid': block.uuid,
                            'position': ++index,
                            'title': block.data.title,
                            'url': block.data.video_url,
                        }
                    }
                }
            });
            return content;
        }
        return contentJson.sort((a, b) => {
            if (a.position < b.position) {
                return -1;
            }
            if (a.position > b.position) {
                return 1;
            }
            return 0;
        }).map((contentItem) => {
            if (contentItem.type === 'text') {
                return {
                    'type': 'text',
                    'uuid': contentItem.uuid,
                    'data': {
                        'id': contentItem.id ? contentItem.id : null,
                        'title': contentItem.title,
                        'text': contentItem.txt,
                    }
                }
            } else if (contentItem.type === 'image') {
                return {
                    'type': 'image',
                    'uuid': contentItem.uuid,
                    'data': {
                        'id': contentItem.id ? contentItem.id : null,
                        'title': contentItem.title,
                        'image_id': (contentItem.img) ? contentItem.img.id:null,
                        'image_url': (contentItem.img) ? contentItem.img.image:null,
                        'image_thumbnail_url': (contentItem.img) ? contentItem.img.image_thumbnail:null,
                    }
                }
            } else if (contentItem.type === 'image-text') {
                return {
                    'type': 'image-text',
                    'uuid': contentItem.uuid,
                    'data': {
                        'id': contentItem.id ? contentItem.id : null,
                        'title': contentItem.title,
                        'image_id': (contentItem.img) ? contentItem.img.id:null,
                        'image_url': (contentItem.img) ? contentItem.img.image:null,
                        'image_thumbnail_url': (contentItem.img) ? contentItem.img.image_thumbnail:null,
                        'text': contentItem.txt,
                    }
                }
            } else if (contentItem.type === 'images') {
                return {
                    'type': 'images',
                    'uuid': contentItem.uuid,
                    'data': {
                        'id': contentItem.id ? contentItem.id : null,
                        'title': contentItem.title,
                        'images': contentItem.gallery_images.map((galleryImage) => {
                            return {
                                'id': galleryImage.id,
                                'image_id': galleryImage.img.id,
                                'image_url': galleryImage.img.image,
                                'image_thumbnail_url': galleryImage.img.image_thumbnail,
                            }
                        }),
                    }
                }
            } else if (contentItem.type === 'video') {
                return {
                    'type': 'video',
                    'uuid': contentItem.uuid,
                    'data': {
                        'id': contentItem.id ? contentItem.id : null,
                        'title': contentItem.title,
                        'video_url': contentItem.url,
                    }
                }
            }
        });
    },
    addCourse: (courseJson, accessToken) => {
        return api.post('/api/v1/courses/', courseJson, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    updateCourse: (courseId, courseJson, accessToken) => {
        return api.put(`/api/v1/courses/${courseId}/`, courseJson, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    addLive: (courseJson, accessToken) => {
        return api.post('/api/v1/live-lesson/', courseJson, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    updateLive: (courseId, courseJson, accessToken) => {
        return api.put(`/api/v1/live-lesson/${courseId}/`, courseJson, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    getCourseLessons: (courseId, accessToken) => {
        return api.get(`/api/v1/lessons/?course=${courseId}`, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    removeCourseLesson: (lessonId, accessToken) => {
        return api.delete(`/api/v1/lessons/${lessonId}/`, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    addLesson: (lessonJson, accessToken) => {
        return api.post('/api/v1/lessons/', lessonJson, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    updateLesson: (lessonId, lessonJson, accessToken) => {
        return api.put(`/api/v1/lessons/${lessonId}/`, lessonJson, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    removeContentBlock: (blockData, accessToken) => {
        let removeUrl;
        switch(blockData.type) {
            case 'text':
                removeUrl = `/api/v1/texts/${blockData.data.id}/`;
                break;
            case 'image':
                removeUrl = `/api/v1/images/${blockData.data.id}/`;
                break;
            case 'image-text':
                removeUrl = `/api/v1/image-texts/${blockData.data.id}/`;
                break;
            case 'images':
                removeUrl = `/api/v1/galleries/${blockData.data.id}/`;
                break;
            case 'video':
                removeUrl = `/api/v1/videos/${blockData.data.id}/`;
                break;
        }
        if (!removeUrl) {
            return;
        }
        return api.delete(removeUrl, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    getCourseDraft: (accessToken) => {
        return api.get('/api/v1/courses/draft/', {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    publishCourse: (course, accessToken) => {
        course.status = 1;
        return api.patch(`/api/v1/courses/${course.id}/`, course, {
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    getSchedule: (accessToken, params) => {
        return api.get('/api/v1/school-schedules/', {
            params: params,
            headers: {
                'Authorization': `Token ${accessToken}`,
            }
        });
    },
    getPaymentAmount: (params) => {
        return api.get('/api/v1/payments/calc-amount', {
            params: params,
            headers: {
                'Authorization': `Token ${window.LIL_STORE.accessToken}`,
            }
        });
    },
    getObjComments: (objId, objType, ordering) => {
        return api.get('/api/v1/obj-comments/', {
            params: {
              obj_id: objId,
              obj_type: objType,
              ordering: ordering || '',
            }
        });
    },
    addObjComment: (objId, objType, commentJson) => {
        let data = commentJson;
        data.obj_id = objId;
        data.obj_type = objType;
        return api.post('/api/v1/obj-comments/', data, {
            headers: {
                'Authorization': `Token ${window.LIL_STORE.accessToken}`,
            }
        });
    },
    removeObjComment: (commentId) => {
        return api.delete(`/api/v1/obj-comments/${commentId}/`, {
            headers: {
                'Authorization': `Token ${window.LIL_STORE.accessToken}`,
            }
        });
    },
    captureEmail: (email) => {
        return api.post('/api/v1/capture-email/', {email}, {
            headers: {
                'Authorization': `Token ${window.LIL_STORE.accessToken}`,
            }
        });
    },
    saveUserGallery: (images) => {
        return api.patch(`/api/v1/user-gallery/${window.LIL_STORE.user.id}/`, {
          images: api.convertGalleryImagesJson(images),
        }, {
            headers: {
                'Authorization': `Token ${window.LIL_STORE.accessToken}`,
            }
        });
    },
    getTags: params => {
        return api.get('/api/v1/tags/', {params});
    },
    addTag: data => {
        return api.post('/api/v1/tags/', data, {
            headers: {
                'Authorization': `Token ${window.LIL_STORE.accessToken}`,
            }
        });
    },
    removeTag: tagId => {
        return api.delete(`/api/v1/tags/${tagId}/`, {
            headers: {
                'Authorization': `Token ${window.LIL_STORE.accessToken}`,
            }
        });
    }
};