import ReactGA from 'react-ga'

var coreActions = require('./actions.js');
var uiActions = require('../ui/actions.js');
var pusherActions = require('../pusher/actions.js');
var mopidyActions = require('../mopidy/actions.js');
var spotifyActions = require('../spotify/actions.js');
var lastfmActions = require('../lastfm/actions.js');
var helpers = require('../../helpers.js');

const CoreMiddleware = (function(){

    /**
     * The actual middleware inteceptor
     **/
    return store => next => action => {
        var core = store.getState().core;

        switch(action.type){

            case 'HANDLE_EXCEPTION':

                // Construct meaningful message and description
                var message = action.message;
                if (action.description){
                    var description = action.description;
                } else if (action.data.xhr && action.data.xhr.responseText){
                    var xhr_response = JSON.parse(action.data.xhr.responseText);
                    if (xhr_response.error && xhr_response.error.message){
                        var description = xhr_response.error.message;
                    }
                } else if (action.data.xhr){
                    var description = action.data.xhr.status+' '+action.data.xhr.statusText;
                } else {
                    var description = null;
                }

                // Prepare a summary dump of our state
                var state = store.getState();
                var exported_state = {
                    core: Object.assign({},state.core),
                    ui: Object.assign({},state.ui),
                    spotify: Object.assign({},state.spotify),
                    mopidy: Object.assign({},state.mopidy),
                    pusher: Object.assign({},state.pusher)
                }

                // Strip out non-essential store info
                delete exported_state.core.albums
                delete exported_state.core.artists
                delete exported_state.core.playlists
                delete exported_state.core.users
                delete exported_state.core.queue_metadata
                delete exported_state.core.current_tracklist
                delete exported_state.spotify.library_albums
                delete exported_state.spotify.library_artists
                delete exported_state.spotify.library_playlists
                delete exported_state.spotify.autocomplete_results
                delete exported_state.mopidy.library_albums
                delete exported_state.mopidy.library_artists
                delete exported_state.mopidy.library_playlists

                var data = Object.assign(
                    {},
                    action.data,
                    {
                        message: message,
                        description: description,
                        state: exported_state
                    }
                );

                // Log with Analytics
                if (store.getState().ui.allow_reporting){
	                ReactGA.event({
	                    category: "Error",
	                    action: message,
	                    label: description,
	                    nonInteraction: true
	                });
	            }

	            if (action.show_notification){
	                store.dispatch(uiActions.createNotification({content: message, type: 'bad', description: description}));
	            }

                console.error(message, description, data);
                
                break;

            case 'PLAY_PLAYLIST':
                if (store.getState().ui.allow_reporting){
	                ReactGA.event({ category: 'Playlist', action: 'Play', label: action.uri });
	            }
                next(action)
                break

            case 'SAVE_PLAYLIST':
                if (store.getState().ui.allow_reporting){
              		ReactGA.event({ category: 'Playlist', action: 'Save', label: action.key });
	            }
                next(action)
                break

            case 'CREATE_PLAYLIST':
                if (store.getState().ui.allow_reporting){
                	ReactGA.event({ category: 'Playlist', action: 'Create', label: +action.name });
	            }
                next(action)
                break

            case 'REORDER_PLAYLIST_TRACKS':
                if (store.getState().ui.allow_reporting){
                	ReactGA.event({ category: 'Playlist', action: 'Reorder tracks', label: action.key });
	            }
                next(action)
                break

            case 'ADD_PLAYLIST_TRACKS':
                if (store.getState().ui.allow_reporting){
                	ReactGA.event({ category: 'Playlist', action: 'Add tracks', label: action.playlist_uri });
	            }
                next(action)
                break

            case 'REMOVE_PLAYLIST_TRACKS':
                if (store.getState().ui.allow_reporting){
                	ReactGA.event({ category: 'Playlist', action: 'Remove tracks', label: action.playlist_uri });
	            }
                next(action)
                break

            case 'DELETE_PLAYLIST':
                if (store.getState().ui.allow_reporting){
                	ReactGA.event({ category: 'Playlist', action: 'Delete', label: action.uri });
	            }
                next(action)
                break

            case 'SEARCH_STARTED':
                if (store.getState().ui.allow_reporting){
                	ReactGA.event({ category: 'Search', action: 'Started', label: action.type+': '+action.query });
	            }
                next(action)

                var state = store.getState()
                if (state.ui.search_uri_schemes){
                    var uri_schemes = state.ui.search_uri_schemes
                } else {
                    var uri_schemes = state.mopidy.uri_schemes
                }

                // backends that can handle more than just track results
                // make sure they are available and respect our settings
                var available_full_uri_schemes = ['local:','file:','gmusic:']
                var full_uri_schemes = []
                for (var i = 0; i < available_full_uri_schemes.length; i++){
                    var index = uri_schemes.indexOf(available_full_uri_schemes[i])
                    if (index > -1){
                        full_uri_schemes.push(available_full_uri_schemes[i])
                    }
                }

                // initiate spotify searching
                if (!action.only_mopidy){
                    if (!state.ui.search_settings || state.ui.search_settings.spotify){
                        store.dispatch(spotifyActions.getSearchResults(action.query))
                    }
                }

                // backend searching (mopidy)
                if (state.mopidy.connected){
                    store.dispatch(mopidyActions.getSearchResults(action.search_type, action.query, 100, full_uri_schemes))
                }

                break

            // Get assets from all of our providers
            case 'GET_LIBRARY_PLAYLISTS':
                if (store.getState().spotify.connected){
                    store.dispatch(spotifyActions.getLibraryPlaylists())
                }
                if (store.getState().mopidy.connected){
                    store.dispatch(mopidyActions.getLibraryPlaylists())
                }
                next(action)
                break

            // Get assets from all of our providers
            case 'GET_LIBRARY_ALBUMS':
                if (store.getState().spotify.connected){
                    store.dispatch(spotifyActions.getLibraryAlbums())
                }
                if (store.getState().mopidy.connected){
                    store.dispatch(mopidyActions.getLibraryAlbums())
                }
                next(action)
                break

            // Get assets from all of our providers
            case 'GET_LIBRARY_ARTISTS':
                if (store.getState().spotify.connected){
                    store.dispatch(spotifyActions.getLibraryArtists())
                }
                if (store.getState().mopidy.connected){
                    store.dispatch(mopidyActions.getLibraryArtists())
                }
                next(action)
                break

            case 'RESTART':
                location.reload();
                break;


            /**
             * Playlist manipulation
             **/

            case 'PLAYLIST_TRACKS':
                var tracks = helpers.formatTracks(action.tracks);
                action.tracks_uris = helpers.arrayOf('uri', tracks);

                store.dispatch({
                    type: 'TRACKS_LOADED',
                    tracks: tracks
                });

                next(action);
                break;

            case 'PLAYLIST_TRACKS_ADDED':
                store.dispatch(uiActions.createNotification({type: 'info', content: 'Added '+action.tracks_uris.length+' tracks to playlist'}))
                switch(helpers.uriSource(action.key)){

                    case 'spotify':
                        store.dispatch(spotifyActions.getPlaylist(action.key));
                        break

                    case 'm3u':
                        if (store.getState().mopidy.connected ) store.dispatch(mopidyActions.getPlaylist(action.key));
                        break
                }
                next(action)
                break

            case 'PLAYLIST_TRACKS_REORDERED':
                var playlists = Object.assign({}, core.playlists);
                var playlist = Object.assign({}, playlists[action.key]);
                var tracks_uris = Object.assign([], playlist.tracks_uris);

                // handle insert_before offset if we're moving BENEATH where we're slicing tracks
                var insert_before = action.insert_before
                if (insert_before > action.range_start){
                    insert_before = insert_before - action.range_length;
                }

                // cut our moved tracks into a new array
                var tracks_to_move = tracks_uris.splice(action.range_start, action.range_length)
                tracks_to_move.reverse()

                for (i = 0; i < tracks_to_move.length; i++){
                    tracks_uris.splice(insert_before, 0, tracks_to_move[i])
                }

                var snapshot_id = null;
                if (action.snapshot_id){
                    snapshot_id = action.snapshot_id;
                }

                // Update our playlist
                playlist.tracks_uris = tracks_uris;
                playlist.snapshot_id = snapshot_id;

                // Trigger normal playlist updating
                store.dispatch({
                    type: 'PLAYLISTS_LOADED',
                    playlists: [playlist]
                });
                break;

            case 'PLAYLIST_TRACKS_REMOVED':
                var playlists = Object.assign({}, core.playlists);
                var playlist = Object.assign({}, playlists[action.key]);
                var tracks_uris = Object.assign([], playlist.tracks_uris);

                var indexes = action.tracks_indexes.reverse()
                for(var i = 0; i < indexes.length; i++){
                    tracks_uris.splice(indexes[i], 1);
                }

                var snapshot_id = null;
                if (action.snapshot_id){
                    snapshot_id = action.snapshot_id;
                }

                // Update our playlist
                playlist.tracks_uris = tracks_uris;
                playlist.snapshot_id = snapshot_id;

                // Trigger normal playlist updating
                store.dispatch({
                    type: 'PLAYLISTS_LOADED',
                    playlists: [playlist]
                });
                break;


            /**
             * Asset Load commands
             *
             * These are called from views and other middleware to load
             * assets. This is where we can return already indexed records
             * where appropriate
             **/

            case 'LOAD_TRACK':
            	if (
            		!action.force_reload &&
            		store.getState().core.tracks[action.uri]){
	            		console.info('Loading "'+action.uri+'" from index');
	            		break;
            	}
            	
                switch (helpers.uriSource(action.uri)){
                    case 'spotify':
                        store.dispatch(spotifyActions.getTrack(action.uri));
                        
                        if (store.getState().spotify.me){
	                        store.dispatch(spotifyActions.following(action.uri));
	                    }
                        break;

                    default:
                        if (store.getState().mopidy.connected){
                            store.dispatch(mopidyActions.getTrack(action.uri));
                        }
                        break;
                }

                next(action);
                break;

            case 'LOAD_ALBUM':
            	if (
            		!action.force_reload &&
            		store.getState().core.albums[action.uri] && 
            		store.getState().core.albums[action.uri].tracks_uris){
	            		console.info('Loading "'+action.uri+'" from index');
	            		break;
            	}
            	
                switch (helpers.uriSource(action.uri)){
                    case 'spotify':
                        store.dispatch(spotifyActions.getAlbum(action.uri));
                        
                        if (store.getState().spotify.me){
	                        store.dispatch(spotifyActions.following(action.uri));
	                    }
                        break;

                    default:
                        if (store.getState().mopidy.connected){
                            store.dispatch(mopidyActions.getAlbum(action.uri));
                        }
                        break;
                }

                next(action);
                break;

            case 'LOAD_ARTIST':
            	if (
            		!action.force_reload &&
            		store.getState().core.artists[action.uri] && 
            		store.getState().core.artists[action.uri].albums_uris && 
            		store.getState().core.artists[action.uri].tracks_uris){
	            		console.info('Loading "'+action.uri+'" from index');
	            		break;
            	}

                switch (helpers.uriSource(action.uri)){
                    case 'spotify':
                        store.dispatch(spotifyActions.getArtist(action.uri, true));
                        
                        if (store.getState().spotify.me){
	                        store.dispatch(spotifyActions.following(action.uri));
	                    }
                        break;

                    default:
                        if (store.getState().mopidy.connected){
                            store.dispatch(mopidyActions.getArtist(action.uri));
                        }
                        break;
                }

                next(action);
                break;

            case 'LOAD_PLAYLIST':
            	if (
            		!action.force_reload &&
            		store.getState().core.playlists[action.uri] && 
            		store.getState().core.playlists[action.uri].tracks_uris){
	            		console.info('Loading "'+action.uri+'" from index');
	            		break;
            	}

                switch (helpers.uriSource(action.uri)){
                    case 'spotify':
                        store.dispatch(spotifyActions.getPlaylist(action.uri));

                        if (store.getState().spotify.me){
	                        store.dispatch(spotifyActions.following(action.uri));
	                    }
                        break;

                    default:
                        if (store.getState().mopidy.connected){
                            store.dispatch(mopidyActions.getPlaylist(action.uri));
                        }
                        break;
                }

                next(action);
                break;

            case 'LOAD_USER':
            	if (
            		!action.force_reload &&
            		store.getState().core.users[action.uri] &&
            		store.getState().core.users[action.uri].playlists_uris ){
	            		console.info('Loading "'+action.uri+'" from index');
	            		break;
            	}

                switch (helpers.uriSource(action.uri)){
                    case 'spotify':
						store.dispatch(spotifyActions.getUser(action.uri));
                        
                        if (store.getState().spotify.me){
	                        store.dispatch(spotifyActions.following(action.uri));
	                    }
                        break;

                    default:
                        // No Mopidy mechanism for users
                        break;
                }

                next(action);
                break;

            case 'LOAD_USER_PLAYLISTS':
                if (
                    !action.force_reload &&
                    store.getState().core.users[action.uri] &&
                    store.getState().core.users[action.uri].playlists_uris ){
                        console.info('Loading "'+action.uri+'" playlists from index');
                        break;
                }

                switch (helpers.uriSource(action.uri)){
                    case 'spotify':
						store.dispatch(spotifyActions.getUserPlaylists(action.uri));
                        break;

                    default:
                        // No Mopidy mechanism for users
                        break;
                }

                next(action);
                break;


            /**
             * Index actions
             * These modify our asset indexes, which are used globally
             **/

            case 'CURRENT_TRACK_LOADED':
                store.dispatch(coreActions.trackLoaded(action.track));
                action.track = helpers.formatTrack(action.track);
                next(action);
                break;

            case 'QUEUE_LOADED':
                store.dispatch(coreActions.tracksLoaded(action.tracks));
                action.tracks = helpers.formatTracks(action.tracks);
                next(action);
                break;

            case 'TRACKS_LOADED':
                var tracks_index = Object.assign({}, core.tracks);
                var artists_index = core.artists;
                var albums_index = core.albums;
                var tracks_loaded = [];
                var artists_loaded = [];
                var albums_loaded = [];

                for (var raw_track of action.tracks){
                    var track = helpers.formatTrack(raw_track);

                    if (tracks_index[track.uri] !== undefined){
                        track = Object.assign({}, tracks_index[track.uri], track);
                    }
                    
                    if (raw_track.album){
                        track.album = helpers.formatSimpleObject(raw_track.album);

                        if (!albums_index[raw_track.album.uri]){
                            albums_loaded.push(raw_track.album);
                        }

                        // Copy the images to the track
                        /*
                        if (raw_track.album.images){
                            track.images = helpers.digestMopidyImages(store.getState().mopidy, raw_track.album.images);
                        }*/
                    }

                    if (raw_track.artists && raw_track.artists.length > 0){
                        track.artists = [];

                        for (var artist of raw_track.artists){
                            track.artists.push(helpers.formatSimpleObject(artist));

                            // Not already in our index, so let's add it
                            if (!artists_index[artist.uri]){
                                artists_loaded.push(artist);
                            }
                        }
                    }

                    tracks_loaded.push(track);
                };

                action.tracks = tracks_loaded;

                if (artists_loaded.length > 0){
                    store.dispatch(coreActions.artistsLoaded(artists_loaded));
                }
                if (albums_loaded.length > 0){
                    store.dispatch(coreActions.albumsLoaded(albums_loaded));
                }

                next(action);
                break;

            case 'ALBUMS_LOADED':
                var albums_index = Object.assign({}, core.albums);
                var albums_loaded = [];
                var artists_loaded = [];
                var tracks_loaded = [];

                for (var raw_album of action.albums){
                    var album = helpers.formatAlbum(raw_album);

                    if (albums_index[album.uri]){
                        album = Object.assign({}, albums_index[album.uri], album);
                    }
/*
                    if (raw_album.images && raw_album.images.length > 0){
                        album.images = helpers.digestMopidyImages(store.getState().mopidy, raw_album.images);
                    }*/

                    if (raw_album.tracks){
                        album.tracks_uris = [];

                        for (var track of raw_album.tracks){
                            if (!track.album){
                                track.album = helpers.formatSimpleObject(album);
                            }
                            album.tracks_uris.push(track.uri);
                            tracks_loaded.push(track);
                        }
                    }

                    if (raw_album.artists){
                        album.artists_uris = helpers.arrayOf('uri', raw_album.artists);
                        artists_loaded = [...artists_loaded, ...raw_album.artists];
                    }

                    albums_loaded.push(album);
                };

                action.albums = albums_loaded;

                if (artists_loaded.length > 0){
                    store.dispatch(coreActions.artistsLoaded(artists_loaded));
                }
                if (tracks_loaded.length > 0){
                    store.dispatch(coreActions.tracksLoaded(tracks_loaded));
                }

                next(action);
                break

            case 'ARTISTS_LOADED':
                var artists_index = Object.assign({}, core.artists);
                var artists_loaded = [];
                var tracks_loaded = [];
                
                for (var raw_artist of action.artists){
                	var artist = helpers.formatArtist(raw_artist);

                	// Already have an artist in the index
                    if (artists_index[artist.uri]){

                    	// And we've already got some images, make sure we merge the arrays,
                    	// rather than overwriting
                    	if (artists_index[artist.uri].images && artist.images){
                    		var existing_images = artists_index[artist.uri].images;
                    		var are_new_images = true;

                    		// loop all extisting images to make sure we're not adding one that
                    		// we already have
                    		for (var existing_image of existing_images){

                    			// We only need to check one size, the formatter should insist on consistency
                    			// Note that we depend on having a one-item array of images provided per action
                    			if (existing_image.huge == artist.images[0].huge){
                    				are_new_images = false;
                    			}
                    		}

                    		// Only if they're new images should we merge them in
                    		if (are_new_images){
	                    		artist.images = Object.assign([], [...existing_images, ...artist.images]);
	                    	}
                    	}

                        artist = Object.assign({}, artists_index[artist.uri], artist);
                    }

                    // Migrate nested tracks objects into references to our tracks index
                    if (raw_artist.tracks){
                        var tracks = helpers.formatTracks(raw_artist.tracks);
                        var tracks_uris = helpers.arrayOf('uri', tracks);
                        artist.tracks_uris = tracks_uris;
                        tracks_loaded = [...tracks_loaded, ...tracks];
                    }

                    artists_loaded.push(artist);
                };

                action.artists = artists_loaded;

                if (tracks_loaded.length > 0){
                    store.dispatch(coreActions.tracksLoaded(tracks_loaded));
                }

                next(action);
                break;

            case 'PLAYLISTS_LOADED':
                var playlists_index = Object.assign({}, core.playlists);
                var playlists_loaded = [];
                var tracks_loaded = [];

                for (var playlist of action.playlists){

                	playlist = helpers.formatPlaylist(playlist);

                    // Detect editability
                    switch (helpers.uriSource(playlist.uri)){

                        case 'm3u':
                            playlist.can_edit = true
                            break

                        case 'spotify':
                            if (store.getState().spotify.authorization && store.getState().spotify.me){
                                playlist.can_edit = (playlist.owner.id == store.getState().spotify.me.id)
                            }
                    }

                    // Already have this playlist partially in our index
                    if (playlists_index[playlist.uri]){
                        playlist = Object.assign({}, playlists_index[playlist.uri], playlist);

                        // Setup placeholder tracks_uris
                        if (playlist.tracks_uris === undefined){
                            playlist.tracks_uris = [];
                        }
                    }

                    // Load our tracks
                    if (playlist.tracks){
                        var tracks = helpers.formatTracks(playlist.tracks);
                        var tracks_uris = helpers.arrayOf('uri', tracks);
                        playlist.tracks_uris = tracks_uris;
                        delete playlist.tracks;
                        tracks_loaded = [...tracks_loaded, ...tracks];
                    }

                    // Update index
                    playlists_loaded.push(playlist);
                }

                action.playlists = playlists_loaded;

                if (tracks_loaded.length > 0){
                    store.dispatch(coreActions.tracksLoaded(tracks_loaded));
                }

                next(action);
                break;

            case 'USERS_LOADED':
                var users_index = Object.assign({}, core.users);
                var users_loaded = [];

                for (var user of action.users){
                    user = helpers.formatUser(user);
                    
                    if (users_index[user.uri]){
                        user = Object.assign({}, users_index[user.uri], user);
                    }

                    users_loaded.push(user);
                }

                action.users = users_loaded;

                next(action);
                break;

            case 'USER_PLAYLISTS_LOADED':
            	store.dispatch(coreActions.playlistsLoaded(action.playlists));
                next(action);
                break;

            /**
             * Loaded more linked assets
             * Often fired during lazy-loading or async asset grabbing.
             * We link the parent to these indexed records by {type}s_uris
             **/

            case 'LOADED_MORE':
                var parent_type_plural = action.parent_type+'s';
                var parent_index = Object.assign({}, core[action.parent_type+'s']);
                var parent = Object.assign({}, parent_index[action.parent_key]);

                if (action.records_data.items !== undefined){
                    var records = action.records_data.items;
                } else if (action.records_data.tracks !== undefined){
                    var records = action.records_data.tracks;
                } else if (action.records_data.artists !== undefined){
                    var records = action.records_data.artists;
                } else if (action.records_data.albums !== undefined){
                    var records = action.records_data.albums;
                } else if (action.records_data.playlists !== undefined){
                    var records = action.records_data.playlists;
                } else {
                    var records = action.records_data;
                }

                // Pre-emptively format tracks
                // Providers give us tracks in all kinds of structures, so this cleans things first
                if (action.records_type == 'track'){
                    records = helpers.formatTracks(records);
                }

                var records_type_plural = action.records_type+'s';
                var records_index = {};
                var records_uris = helpers.arrayOf('uri', records);

                // If we're a list of playlists, we need to manually filter Spotify's new URI structure
                // Really poor form because they haven't updated it everywhere, yet
                if (action.records_type == 'playlist'){
                	records_uris = helpers.upgradeSpotifyPlaylistUris(records_uris);
                }

                // Append our parent object's reference to these records
                var uris = records_uris;
                if (parent[records_type_plural+'_uris'] !== undefined){
                    uris = [...parent[records_type_plural+'_uris'], ...uris];
                }
                parent[records_type_plural+'_uris'] = uris;
                if (action.records_data.next !== undefined){
                    parent[records_type_plural+'_more'] = action.records_data.next;
                }

                // Parent loaded (well, changed)
                var parent_action = {
                    type: parent_type_plural.toUpperCase()+'_LOADED'
                };
                parent_action[parent_type_plural] = [parent];
                store.dispatch(parent_action);

                // Records loaded
                var records_action = {
                    type: records_type_plural.toUpperCase()+'_LOADED'
                };
                records_action[records_type_plural] = records;
                store.dispatch(records_action);

                next(action);
                break;

            // This action is irrelevant to us, pass it on to the next middleware
            default:
                return next(action)
        }
    }

})();

export default CoreMiddleware