Audinaut-subsonic-app-android/app/src/main/java/net/nullsum/audinaut/fragments/SelectDirectoryFragment.java

package net.nullsum.audinaut.fragments;

import android.os.Bundle;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;

import net.nullsum.audinaut.R;
import net.nullsum.audinaut.adapter.AlphabeticalAlbumAdapter;
import net.nullsum.audinaut.adapter.EntryGridAdapter;
import net.nullsum.audinaut.adapter.EntryInfiniteGridAdapter;
import net.nullsum.audinaut.adapter.SectionAdapter;
import net.nullsum.audinaut.domain.MusicDirectory;
import net.nullsum.audinaut.service.CachedMusicService;
import net.nullsum.audinaut.service.MusicService;
import net.nullsum.audinaut.service.MusicServiceFactory;
import net.nullsum.audinaut.service.OfflineException;
import net.nullsum.audinaut.util.Constants;
import net.nullsum.audinaut.util.LoadingTask;
import net.nullsum.audinaut.util.Pair;
import net.nullsum.audinaut.util.TabBackgroundTask;
import net.nullsum.audinaut.util.Util;
import net.nullsum.audinaut.view.FastScroller;
import net.nullsum.audinaut.view.UpdateView;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import static net.nullsum.audinaut.domain.MusicDirectory.Entry;

public class SelectDirectoryFragment extends SubsonicFragment implements SectionAdapter.OnItemClickedListener<Entry> {
    private String id;
    private String name;
    private Entry directory;
    private String playlistId;
    private String playlistName;
    private boolean playlistOwner;
    private String albumListType;
    private String albumListExtra;
    private int albumListSize;
    private boolean refreshListing = false;
    private boolean restoredInstance = false;
    private boolean lookupParent = false;
    private boolean largeAlbums = false;
    private boolean topTracks = false;
    private String lookupEntry;
    private RecyclerView recyclerView;
    private FastScroller fastScroller;
    private EntryGridAdapter entryGridAdapter;
    private List<Entry> albums;
    private List<Entry> entries;
    private LoadTask currentTask;

    public SelectDirectoryFragment() {
        super();
    }

    @Override
    public void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        if (bundle != null) {
            entries = (List<Entry>) bundle.getSerializable(Constants.FRAGMENT_LIST);
            albums = (List<Entry>) bundle.getSerializable(Constants.FRAGMENT_LIST2);
            if (albums == null) {
                albums = new ArrayList<>();
            }
            restoredInstance = true;
        }
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putSerializable(Constants.FRAGMENT_LIST, (Serializable) entries);
        outState.putSerializable(Constants.FRAGMENT_LIST2, (Serializable) albums);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle bundle) {
        Bundle args = getArguments();
        if (args != null) {
            id = args.getString(Constants.INTENT_EXTRA_NAME_ID);
            name = args.getString(Constants.INTENT_EXTRA_NAME_NAME);
            directory = (Entry) args.getSerializable(Constants.INTENT_EXTRA_NAME_DIRECTORY);
            playlistId = args.getString(Constants.INTENT_EXTRA_NAME_PLAYLIST_ID);
            playlistName = args.getString(Constants.INTENT_EXTRA_NAME_PLAYLIST_NAME);
            playlistOwner = args.getBoolean(Constants.INTENT_EXTRA_NAME_PLAYLIST_OWNER, false);
            albumListType = args.getString(Constants.INTENT_EXTRA_NAME_ALBUM_LIST_TYPE);
            albumListExtra = args.getString(Constants.INTENT_EXTRA_NAME_ALBUM_LIST_EXTRA);
            albumListSize = args.getInt(Constants.INTENT_EXTRA_NAME_ALBUM_LIST_SIZE, 0);
            refreshListing = args.getBoolean(Constants.INTENT_EXTRA_REFRESH_LISTINGS);
            artist = args.getBoolean(Constants.INTENT_EXTRA_NAME_ARTIST, false);
            lookupEntry = args.getString(Constants.INTENT_EXTRA_SEARCH_SONG);
            topTracks = args.getBoolean(Constants.INTENT_EXTRA_TOP_TRACKS);

            String childId = args.getString(Constants.INTENT_EXTRA_NAME_CHILD_ID);
            if (childId != null) {
                id = childId;
                lookupParent = true;
            }
            if (entries == null) {
                entries = (List<Entry>) args.getSerializable(Constants.FRAGMENT_LIST);
                albums = (List<Entry>) args.getSerializable(Constants.FRAGMENT_LIST2);

                if (albums == null) {
                    albums = new ArrayList<>();
                }
            }
        }

        rootView = inflater.inflate(R.layout.abstract_recycler_fragment, container, false);

        refreshLayout = rootView.findViewById(R.id.refresh_layout);
        refreshLayout.setOnRefreshListener(this);

        if (Util.getPreferences(context).getBoolean(Constants.PREFERENCES_KEY_LARGE_ALBUM_ART, true)) {
            largeAlbums = true;
        }

        recyclerView = rootView.findViewById(R.id.fragment_recycler);
        recyclerView.setHasFixedSize(true);
        fastScroller = rootView.findViewById(R.id.fragment_fast_scroller);
        setupScrollList(recyclerView);
        setupLayoutManager(recyclerView, largeAlbums);

        if (entries == null) {
            if (primaryFragment || secondaryFragment) {
                load(false);
            } else {
                invalidated = true;
            }
        } else {
            finishLoading();
        }

        if (name != null) {
            setTitle(name);
        }

        return rootView;
    }

    @Override
    public void setIsOnlyVisible(boolean isOnlyVisible) {
        boolean update = this.isOnlyVisible != isOnlyVisible;
        super.setIsOnlyVisible(isOnlyVisible);
        if (update && entryGridAdapter != null) {
            RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
            if (layoutManager instanceof GridLayoutManager) {
                ((GridLayoutManager) layoutManager).setSpanCount(getRecyclerColumnCount());
            }
        }
    }

    @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater menuInflater) {
        if (albumListType != null) {
            menuInflater.inflate(R.menu.select_album_list, menu);
        } else if (artist) {
            menuInflater.inflate(R.menu.select_album, menu);
        } else {
            if (Util.isOffline(context)) {
                menuInflater.inflate(R.menu.select_song_offline, menu);
            } else {
                menuInflater.inflate(R.menu.select_song, menu);

                if (playlistId == null || !playlistOwner) {
                    menu.removeItem(R.id.menu_remove_playlist);
                }
            }
        }
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_remove_playlist:
                removeFromPlaylist(playlistId, playlistName, getSelectedIndexes());
                return true;
        }

        return super.onOptionsItemSelected(item);

    }

    @Override
    public void onCreateContextMenu(Menu menu, MenuInflater menuInflater, UpdateView updateView, Entry entry) {
        onCreateContextMenuSupport(menu, menuInflater, updateView, entry);
        if (!Util.isOffline(context) && (playlistId == null || !playlistOwner)) {
            menu.removeItem(R.id.song_menu_remove_playlist);
        }

        recreateContextMenu(menu);
    }

    @Override
    public boolean onContextItemSelected(MenuItem menuItem, UpdateView<Entry> updateView, Entry entry) {
        if (onContextItemSelected(menuItem, entry)) {
            return true;
        }

        switch (menuItem.getItemId()) {
            case R.id.song_menu_remove_playlist:
                removeFromPlaylist(playlistId, playlistName, Collections.singletonList(entries.indexOf(entry)));
                break;
        }

        return true;
    }

    @Override
    public void onItemClicked(UpdateView<Entry> updateView, Entry entry) {
        if (entry.isDirectory()) {
            SubsonicFragment fragment = new SelectDirectoryFragment();
            Bundle args = new Bundle();
            args.putString(Constants.INTENT_EXTRA_NAME_ID, entry.getId());
            args.putString(Constants.INTENT_EXTRA_NAME_NAME, entry.getTitle());
            args.putSerializable(Constants.INTENT_EXTRA_NAME_DIRECTORY, entry);
            if ("newest".equals(albumListType)) {
                args.putBoolean(Constants.INTENT_EXTRA_REFRESH_LISTINGS, true);
            }
            if (!entry.isAlbum()) {
                args.putBoolean(Constants.INTENT_EXTRA_NAME_ARTIST, true);
            }
            fragment.setArguments(args);

            replaceFragment(fragment);
        } else {
            onSongPress(entries, entry, albumListType == null);
        }
    }

    @Override
    protected void refresh(boolean refresh) {
        load(refresh);
    }

    @Override
    protected boolean isShowArtistEnabled() {
        return albumListType != null;
    }

    private void load(boolean refresh) {
        if (refreshListing) {
            refresh = true;
        }

        if (currentTask != null) {
            currentTask.cancel();
        }

        recyclerView.setVisibility(View.INVISIBLE);
        if (playlistId != null) {
            getPlaylist(playlistId, playlistName, refresh);
        } else if (albumListType != null) {
            getAlbumList(albumListType, albumListSize, refresh);
        } else {
            getMusicDirectory(id, name, refresh);
        }
    }

    private void getMusicDirectory(final String id, final String name, final boolean refresh) {
        setTitle(name);

        new LoadTask() {
            @Override
            protected MusicDirectory load(MusicService service) throws Exception {
                MusicDirectory dir = getMusicDirectory(id, name, refresh, service, this);

                if (lookupParent && dir.getParent() != null) {
                    dir = getMusicDirectory(dir.getParent(), name, refresh, service, this);

                    // Update the fragment pointers so other stuff works correctly
                    SelectDirectoryFragment.this.id = dir.getId();
                    SelectDirectoryFragment.this.name = dir.getName();
                } else if (id != null && directory == null && dir.getParent() != null && !artist) {
                    MusicDirectory parentDir = getMusicDirectory(dir.getParent(), name, refresh, true, service, this);
                    for (Entry child : parentDir.getChildren()) {
                        if (id.equals(child.getId())) {
                            directory = child;
                            break;
                        }
                    }
                }

                return dir;
            }

            @Override
            protected void done(Pair<MusicDirectory, Boolean> result) {
                SelectDirectoryFragment.this.name = result.getFirst().getName();
                setTitle(SelectDirectoryFragment.this.name);
                super.done(result);
            }
        }.execute();
    }

    private void getPlaylist(final String playlistId, final String playlistName, final boolean refresh) {
        setTitle(playlistName);

        new LoadTask() {
            @Override
            protected MusicDirectory load(MusicService service) throws Exception {
                return service.getPlaylist(refresh, playlistId, playlistName, context, this);
            }
        }.execute();
    }

    private void getAlbumList(final String albumListType, final int size, final boolean refresh) {
        if ("random".equals(albumListType)) {
            setTitle(R.string.main_albums_random);
        } else if ("recent".equals(albumListType)) {
            setTitle(R.string.main_albums_recent);
        } else if ("frequent".equals(albumListType)) {
            setTitle(R.string.main_albums_frequent);
        } else if ("genres".equals(albumListType) || "years".equals(albumListType)) {
            setTitle(albumListExtra);
        } else if ("alphabeticalByName".equals(albumListType)) {
            setTitle(R.string.main_albums_alphabetical);
        }
        if (MainFragment.SONGS_NEWEST.equals(albumListType)) {
            setTitle(R.string.main_songs_newest);
        } else if (MainFragment.SONGS_TOP_PLAYED.equals(albumListType)) {
            setTitle(R.string.main_songs_top_played);
        } else if (MainFragment.SONGS_RECENT.equals(albumListType)) {
            setTitle(R.string.main_songs_recent);
        } else if (MainFragment.SONGS_FREQUENT.equals(albumListType)) {
            setTitle(R.string.main_songs_frequent);
        }

        new LoadTask() {
            @Override
            protected MusicDirectory load(MusicService service) throws Exception {
                MusicDirectory result;
                if ("genres".equals(albumListType) || "years".equals(albumListType)) {
                    result = service.getAlbumList(albumListType, albumListExtra, size, 0, refresh, context, this);
                    if (result.getChildrenSize() == 0 && "genres".equals(albumListType)) {
                        SelectDirectoryFragment.this.albumListType = "genres-songs";
                        result = service.getSongsByGenre(albumListExtra, size, 0, context, this);
                    }
                } else if ("genres".equals(albumListType) || "genres-songs".equals(albumListType)) {
                    result = service.getSongsByGenre(albumListExtra, size, 0, context, this);
                } else if (albumListType.contains(MainFragment.SONGS_LIST_PREFIX)) {
                    result = service.getSongList(albumListType, size, 0, context, this);
                } else {
                    result = service.getAlbumList(albumListType, size, 0, refresh, context, this);
                }
                return result;
            }
        }.execute();
    }

    @Override
    public SectionAdapter<Entry> getCurrentAdapter() {
        return entryGridAdapter;
    }

    @Override
    public GridLayoutManager.SpanSizeLookup getSpanSizeLookup(final GridLayoutManager gridLayoutManager) {
        return new GridLayoutManager.SpanSizeLookup() {
            @Override
            public int getSpanSize(int position) {
                int viewType = entryGridAdapter.getItemViewType(position);
                if (viewType == EntryGridAdapter.VIEW_TYPE_SONG || viewType == EntryGridAdapter.VIEW_TYPE_HEADER || viewType == EntryInfiniteGridAdapter.VIEW_TYPE_LOADING) {
                    return gridLayoutManager.getSpanCount();
                } else {
                    return 1;
                }
            }
        };
    }

    private void finishLoading() {
        boolean validData = !entries.isEmpty() || !albums.isEmpty();
        if (!validData) {
            setEmpty(true);
        }

        if (validData) {
            recyclerView.setVisibility(View.VISIBLE);
        }

        if (albumListType == null) {
            entryGridAdapter = new EntryGridAdapter(context, entries, getImageLoader(), largeAlbums);
            entryGridAdapter.setRemoveFromPlaylist(playlistId != null);
        } else {
            if ("alphabeticalByName".equals(albumListType)) {
                entryGridAdapter = new AlphabeticalAlbumAdapter(context, entries, getImageLoader(), largeAlbums);
            } else {
                entryGridAdapter = new EntryInfiniteGridAdapter(context, entries, getImageLoader(), largeAlbums);
            }

            // Setup infinite loading based on scrolling
            final EntryInfiniteGridAdapter infiniteGridAdapter = (EntryInfiniteGridAdapter) entryGridAdapter;
            infiniteGridAdapter.setData(albumListType, albumListExtra, albumListSize);

            recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {

                @Override
                public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
                    super.onScrolled(recyclerView, dx, dy);

                    RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
                    int totalItemCount = layoutManager.getItemCount();
                    int lastVisibleItem;
                    if (layoutManager instanceof GridLayoutManager) {
                        lastVisibleItem = ((GridLayoutManager) layoutManager).findLastVisibleItemPosition();
                    } else if (layoutManager instanceof LinearLayoutManager) {
                        lastVisibleItem = ((LinearLayoutManager) layoutManager).findLastVisibleItemPosition();
                    } else {
                        return;
                    }

                    if (totalItemCount > 0 && lastVisibleItem >= totalItemCount - 2) {
                        infiniteGridAdapter.loadMore();
                    }
                }
            });
        }
        entryGridAdapter.setOnItemClickedListener(this);
        // Always show artist if this is not a artist we are viewing
        if (!artist) {
            entryGridAdapter.setShowArtist();
        }
        if (topTracks) {
            entryGridAdapter.setShowAlbum();
        }

        int scrollToPosition = -1;
        if (lookupEntry != null) {
            for (int i = 0; i < entries.size(); i++) {
                if (lookupEntry.equals(entries.get(i).getTitle())) {
                    scrollToPosition = i;
                    entryGridAdapter.addSelected(entries.get(i));
                    lookupEntry = null;
                    break;
                }
            }
        }

        recyclerView.setAdapter(entryGridAdapter);
        fastScroller.attachRecyclerView(recyclerView);
        context.supportInvalidateOptionsMenu();

        if (scrollToPosition != -1) {
            recyclerView.scrollToPosition(scrollToPosition);
        }

        Bundle args = getArguments();
        boolean playAll = args.getBoolean(Constants.INTENT_EXTRA_NAME_AUTOPLAY, false);
        if (playAll && !restoredInstance) {
            playAll(args.getBoolean(Constants.INTENT_EXTRA_NAME_SHUFFLE, false), false, false);
        }
    }

    @Override
    protected void playNow(final boolean shuffle, final boolean append, final boolean playNext) {
        List<Entry> songs = getSelectedEntries();
        if (!songs.isEmpty()) {
            download(songs, append, !append, playNext, shuffle);
            entryGridAdapter.clearSelected();
        } else {
            playAll(shuffle, append, playNext);
        }
    }

    private void playAll(final boolean shuffle, final boolean append, final boolean playNext) {
        boolean hasSubFolders = albums != null && !albums.isEmpty();

        if (hasSubFolders && id != null) {
            downloadRecursively(id, false, append, !append, shuffle, false, playNext);
        } else if (hasSubFolders && albumListType != null) {
            downloadRecursively(albums, shuffle, append, playNext);
        } else {
            download(entries, append, !append, playNext, shuffle);
        }
    }

    private List<Integer> getSelectedIndexes() {
        List<Entry> selected = entryGridAdapter.getSelected();
        List<Integer> indexes = new ArrayList<>();

        for (Entry entry : selected) {
            indexes.add(entries.indexOf(entry));
        }

        return indexes;
    }

    @Override
    protected void downloadBackground(final boolean save) {
        List<Entry> songs = getSelectedEntries();
        if (playlistId != null) {
            songs = entries;
        }

        if (songs.isEmpty()) {
            // Get both songs and albums
            downloadRecursively(id, save, false, false, false, true, false);
        } else {
            downloadBackground(save, songs);
        }
    }

    @Override
    void downloadBackground(final boolean save, final List<Entry> entries) {
        if (getDownloadService() == null) {
            return;
        }

        warnIfStorageUnavailable();
        new RecursiveLoader(context) {
            @Override
            protected Boolean doInBackground() throws Throwable {
                getSongsRecursively(entries);
                getDownloadService().downloadBackground(songs, save);
                return null;
            }

            @Override
            protected void done(Boolean result) {
                Util.toast(context, context.getResources().getQuantityString(R.plurals.select_album_n_songs_downloading, songs.size(), songs.size()));
            }
        };
    }

    @Override
    void download(List<Entry> entries, boolean append, boolean autoplay, boolean playNext, boolean shuffle) {
        download(entries, append, autoplay, playNext, shuffle, playlistName, playlistId);
    }

    @Override
    protected void delete() {
        List<Entry> songs = getSelectedEntries();
        if (songs.isEmpty()) {
            for (Entry entry : entries) {
                if (entry.isDirectory()) {
                    deleteRecursively(entry);
                } else {
                    songs.add(entry);
                }
            }
        }
        if (getDownloadService() != null) {
            getDownloadService().delete(songs);
        }
    }

    private void removeFromPlaylist(final String id, final String name, final List<Integer> indexes) {
        new LoadingTask<Void>(context, true) {
            @Override
            protected Void doInBackground() throws Throwable {
                MusicService musicService = MusicServiceFactory.getMusicService(context);
                musicService.removeFromPlaylist(id, indexes, context, null);
                return null;
            }

            @Override
            protected void done(Void result) {
                for (Integer index : indexes) {
                    entryGridAdapter.removeAt(index);
                }
                Util.toast(context, context.getResources().getString(R.string.removed_playlist, indexes.size(), name));
            }

            @Override
            protected void error(Throwable error) {
                String msg;
                if (error instanceof OfflineException) {
                    msg = getErrorMessage(error);
                } else {
                    msg = context.getResources().getString(R.string.updated_playlist_error, name) + " " + getErrorMessage(error);
                }

                Util.toast(context, msg, false);
            }
        }.execute();
    }

    private abstract class LoadTask extends TabBackgroundTask<Pair<MusicDirectory, Boolean>> {

        public LoadTask() {
            super(SelectDirectoryFragment.this);

            currentTask = this;
        }

        protected abstract MusicDirectory load(MusicService service) throws Exception;

        @Override
        protected Pair<MusicDirectory, Boolean> doInBackground() throws Throwable {
            MusicService musicService = MusicServiceFactory.getMusicService(context);
            MusicDirectory dir = load(musicService);

            albums = dir.getChildren(true, false);
            entries = dir.getChildren();

            // This isn't really an artist if no albums on it!
            if (albums.size() == 0) {
                artist = false;
            }

            return new Pair<>(dir, true);
        }

        @Override
        protected void done(Pair<MusicDirectory, Boolean> result) {
            finishLoading();
            currentTask = null;
        }

        @Override
        public void updateCache(int changeCode) {
            if (entryGridAdapter != null && changeCode == CachedMusicService.CACHE_UPDATE_LIST) {
                entryGridAdapter.notifyDataSetChanged();
            }
        }
    }
}