/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * 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.
 */
package com.android.car.media.drawer;

import android.content.ComponentName;
import android.content.Context;
import android.media.browse.MediaBrowser;
import android.media.session.MediaController;
import android.media.session.MediaSession;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

import androidx.annotation.Nullable;
import androidx.car.drawer.CarDrawerAdapter;
import androidx.car.drawer.CarDrawerController;
import androidx.drawerlayout.widget.DrawerLayout;

import com.android.car.media.MediaManager;
import com.android.car.media.MediaPlaybackModel;
import com.android.car.media.R;

/**
 * Manages drawer navigation and item selection.
 * <p>
 * Maintains separate MediaPlaybackModel for media browsing and control. Sets up root Drawer
 * adapter with root of media-browse tree (using MediaBrowserItemsFetcher). Supports switching the
 * rootAdapter to show the queue-items (using MediaQueueItemsFetcher).
 */
public class MediaDrawerController implements MediaDrawerAdapter.MediaFetchCallback,
        MediaItemOnClickListener {
    private static final String TAG = "MediaDrawerController";

    private static final String EXTRA_ICON_SIZE =
            "com.google.android.gms.car.media.BrowserIconSize";

    private final Context mContext;
    private final CarDrawerController mDrawerController;
    private final MediaPlaybackModel mMediaPlaybackModel;
    private MediaDrawerAdapter mRootAdapter;

    public MediaDrawerController(Context context, CarDrawerController drawerController) {
        mContext = context;
        mDrawerController = drawerController;

        Bundle extras = new Bundle();
        extras.putInt(EXTRA_ICON_SIZE,
                mContext.getResources().getDimensionPixelSize(R.dimen.car_primary_icon_size));

        mMediaPlaybackModel = new MediaPlaybackModel(mContext, extras);
        mMediaPlaybackModel.addListener(mModelListener);

        mRootAdapter = new MediaDrawerAdapter(mContext, mDrawerController);
        // Start with a empty title since we depend on the mMediaManagerListener callback to
        // know which app is being used and set the actual title there.
        mRootAdapter.setTitle("");
        mRootAdapter.setFetchCallback(this);

        // Kick off MediaBrowser/MediaController connection.
        mMediaPlaybackModel.start();
    }

    @Override
    public void onQueueItemClicked(MediaSession.QueueItem queueItem) {
        MediaController.TransportControls controls = mMediaPlaybackModel.getTransportControls();

        if (controls != null) {
            controls.skipToQueueItem(queueItem.getQueueId());
        }

        mDrawerController.closeDrawer();
    }

    @Override
    public void onMediaItemClicked(MediaBrowser.MediaItem item) {
        if (item.isBrowsable()) {
            MediaItemsFetcher fetcher;
            if (MediaBrowserItemsFetcher.PLAY_QUEUE_MEDIA_ID.equals(item.getMediaId())) {
                fetcher = createMediaQueueItemsFetcher();
            } else {
                fetcher = createMediaBrowserItemFetcher(item.getMediaId(),
                        false /* showQueueItem */);
            }
            setupAdapterAndSwitch(fetcher, item.getDescription().getTitle());
        } else if (item.isPlayable()) {
            MediaController.TransportControls controls = mMediaPlaybackModel.getTransportControls();
            if (controls != null) {
                controls.playFromMediaId(item.getMediaId(), item.getDescription().getExtras());
            }
            mDrawerController.closeDrawer();
        } else {
            Log.w(TAG, "Unknown item type; don't know how to handle!");
        }
    }

    @Override
    public void onFetchStart() {
        // Initially there will be no items and we don't want to show empty-list indicator
        // briefly until items are fetched.
        mDrawerController.showLoadingProgressBar(true);
    }

    @Override
    public void onFetchEnd() {
        mDrawerController.showLoadingProgressBar(false);
    }

    /**
     * Creates a new sub-level in the drawer and switches to that as the currently displayed view.
     *
     * @param fetcher The {@link MediaItemsFetcher} that is responsible for fetching the items to be
     *                displayed in the new view.
     * @param title The title text of the new view in the drawer.
     */
    private void setupAdapterAndSwitch(MediaItemsFetcher fetcher, CharSequence title) {
        MediaDrawerAdapter subAdapter = new MediaDrawerAdapter(mContext, mDrawerController);
        subAdapter.setFetcher(fetcher);
        subAdapter.setTitle(title);
        subAdapter.setFetchCallback(this);
        mDrawerController.pushAdapter(subAdapter);
    }

    /**
     * Opens the drawer and displays the current playing queue of items. When the drawer is closed,
     * the view is switched back to the drawer root.
     */
    public void showPlayQueue() {
        mRootAdapter.setFetcherAndInvoke(createMediaQueueItemsFetcher());
        mRootAdapter.setTitle(mMediaPlaybackModel.getQueueTitle());
        mDrawerController.openDrawer();
        mRootAdapter.scrollToCurrent();
        mDrawerController.addDrawerListener(mQueueDrawerListener);
    }

    public void cleanup() {
        mDrawerController.removeDrawerListener(mQueueDrawerListener);
        mRootAdapter.cleanup();
        mMediaPlaybackModel.removeListener(mModelListener);
        mMediaPlaybackModel.stop();
    }

    /**
     * @return Adapter to display root items of MediaBrowse tree. {@link #showPlayQueue()} can
     *      be used to display items from the queue.
     */
    public CarDrawerAdapter getRootAdapter() {
        return mRootAdapter;
    }

    /**
     * Creates a {@link MediaBrowserItemsFetcher} that whose root is the given {@code mediaId}.
     */
    private MediaBrowserItemsFetcher createMediaBrowserItemFetcher(String mediaId,
            boolean showQueueItem) {
        return new MediaBrowserItemsFetcher(mContext, mMediaPlaybackModel, this /* listener */,
                mediaId, showQueueItem);
    }

    /**
     * Creates a {@link MediaQueueItemsFetcher} that is responsible for fetching items in the user's
     * current play queue.
     */
    private MediaQueueItemsFetcher createMediaQueueItemsFetcher() {
        return new MediaQueueItemsFetcher(mContext, mMediaPlaybackModel, this /* listener */);
    }

    /**
     * Creates a {@link MediaItemsFetcher} that will display the top-most level of the drawer.
     */
    private MediaItemsFetcher createRootMediaItemsFetcher() {
        return createMediaBrowserItemFetcher(mMediaPlaybackModel.getMediaBrowser().getRoot(),
                true /* showQueueItem */);
    }

    /**
     * A {@link androidx.drawerlayout.widget.DrawerLayout.DrawerListener} specifically to be used when
     * the play queue has been shown in the drawer. When the drawer is closed following this
     * display, this listener will reset the drawer to display the root view.
     */
    private final DrawerLayout.DrawerListener mQueueDrawerListener =
            new DrawerLayout.DrawerListener() {
        @Override
        public void onDrawerClosed(View drawerView) {
            mRootAdapter.setFetcherAndInvoke(createRootMediaItemsFetcher());
            mRootAdapter.setTitle(
                    MediaManager.getInstance(mContext).getMediaClientName());
            mDrawerController.removeDrawerListener(this);
        }

        @Override
        public void onDrawerSlide(View drawerView, float slideOffset) {}
        @Override
        public void onDrawerOpened(View drawerView) {}
        @Override
        public void onDrawerStateChanged(int newState) {}
    };

    private final MediaPlaybackModel.Listener mModelListener =
            new MediaPlaybackModel.AbstractListener() {
        @Override
        public void onMediaAppChanged(@Nullable ComponentName currentName,
                @Nullable ComponentName newName) {
            // Only store MediaManager instance to a local variable when it is short lived.
            MediaManager mediaManager = MediaManager.getInstance(mContext);
            mRootAdapter.cleanup();
            mRootAdapter.setTitle(mediaManager.getMediaClientName());
        }

        @Override
        public void onMediaConnected() {
            mRootAdapter.setFetcherAndInvoke(createRootMediaItemsFetcher());
        }
    };
}