/*
 * Copyright (C) 2016 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.tv.dvr.ui.playback;

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.media.MediaMetadata;
import android.media.session.MediaController;
import android.media.session.MediaSession;
import android.media.session.PlaybackState;
import android.media.tv.TvContract;
import android.os.AsyncTask;
import android.support.annotation.Nullable;
import android.text.TextUtils;

import com.android.tv.R;
import com.android.tv.TvApplication;
import com.android.tv.common.SoftPreconditions;
import com.android.tv.data.Channel;
import com.android.tv.data.ChannelDataManager;
import com.android.tv.dvr.DvrWatchedPositionManager;
import com.android.tv.dvr.data.RecordedProgram;
import com.android.tv.util.ImageLoader;
import com.android.tv.util.TimeShiftUtils;
import com.android.tv.util.Utils;

class DvrPlaybackMediaSessionHelper {
    private static final String TAG = "DvrPlaybackMediaSessionHelper";
    private static final boolean DEBUG = false;

    private int mNowPlayingCardWidth;
    private int mNowPlayingCardHeight;
    private int mSpeedLevel;
    private long mProgramDurationMs;

    private Activity mActivity;
    private DvrPlayer mDvrPlayer;
    private MediaSession mMediaSession;
    private final DvrWatchedPositionManager mDvrWatchedPositionManager;
    private final ChannelDataManager mChannelDataManager;

    public DvrPlaybackMediaSessionHelper(Activity activity, String mediaSessionTag,
            DvrPlayer dvrPlayer, DvrPlaybackOverlayFragment overlayFragment) {
        mActivity = activity;
        mDvrPlayer = dvrPlayer;
        mDvrWatchedPositionManager =
                TvApplication.getSingletons(activity).getDvrWatchedPositionManager();
        mChannelDataManager = TvApplication.getSingletons(activity).getChannelDataManager();
        mDvrPlayer.setCallback(new DvrPlayer.DvrPlayerCallback() {
            @Override
            public void onPlaybackStateChanged(int playbackState, int playbackSpeed) {
                updateMediaSessionPlaybackState();
            }

            @Override
            public void onPlaybackPositionChanged(long positionMs) {
                updateMediaSessionPlaybackState();
                if (mDvrPlayer.isPlaybackPrepared()) {
                    mDvrWatchedPositionManager
                            .setWatchedPosition(mDvrPlayer.getProgram().getId(), positionMs);
                }
            }

            @Override
            public void onPlaybackEnded() {
                // TODO: Deal with watched over recordings in DVR library
                RecordedProgram nextEpisode =
                        overlayFragment.getNextEpisode(mDvrPlayer.getProgram());
                if (nextEpisode == null) {
                    mDvrPlayer.reset();
                    mActivity.finish();
                } else {
                    Intent intent = new Intent(activity, DvrPlaybackActivity.class);
                    intent.putExtra(Utils.EXTRA_KEY_RECORDED_PROGRAM_ID, nextEpisode.getId());
                    mActivity.startActivity(intent);
                }
            }
        });
        initializeMediaSession(mediaSessionTag);
    }

    /**
     * Stops DVR player and release media session.
     */
    public void release() {
        if (mDvrPlayer != null) {
            mDvrPlayer.reset();
        }
        if (mMediaSession != null) {
            mMediaSession.release();
            mMediaSession = null;
        }
    }

    /**
     * Updates media session's playback state and speed.
     */
    public void updateMediaSessionPlaybackState() {
        mMediaSession.setPlaybackState(new PlaybackState.Builder()
                .setState(mDvrPlayer.getPlaybackState(), mDvrPlayer.getPlaybackPosition(),
                        mSpeedLevel).build());
    }

    /**
     * Sets the recorded program for playback.
     *
     * @param program The recorded program to play. {@code null} to reset the DVR player.
     */
    public void setupPlayback(RecordedProgram program, long seekPositionMs) {
        if (program != null) {
            mDvrPlayer.setProgram(program, seekPositionMs);
            setupMediaSession(program);
        } else {
            mDvrPlayer.reset();
            mMediaSession.setActive(false);
        }
    }

    /**
     * Returns the recorded program now playing.
     */
    public RecordedProgram getProgram() {
        return mDvrPlayer.getProgram();
    }

    /**
     * Checks if the recorded program is the same as now playing one.
     */
    public boolean isCurrentProgram(RecordedProgram program) {
        return program != null && program.equals(getProgram());
    }

    /**
     * Returns playback state.
     */
    public int getPlaybackState() {
        return mDvrPlayer.getPlaybackState();
    }

    /**
     * Returns the underlying DVR player.
     */
    public DvrPlayer getDvrPlayer() {
        return mDvrPlayer;
    }

    private void initializeMediaSession(String mediaSessionTag) {
        mMediaSession = new MediaSession(mActivity, mediaSessionTag);
        mMediaSession.setFlags(MediaSession.FLAG_HANDLES_MEDIA_BUTTONS
                | MediaSession.FLAG_HANDLES_TRANSPORT_CONTROLS);
        mNowPlayingCardWidth = mActivity.getResources()
                .getDimensionPixelSize(R.dimen.notif_card_img_max_width);
        mNowPlayingCardHeight = mActivity.getResources()
                .getDimensionPixelSize(R.dimen.notif_card_img_height);
        mMediaSession.setCallback(new MediaSessionCallback());
        mActivity.setMediaController(
                new MediaController(mActivity, mMediaSession.getSessionToken()));
        updateMediaSessionPlaybackState();
    }

    private void setupMediaSession(RecordedProgram program) {
        mProgramDurationMs = program.getDurationMillis();
        String cardTitleText = program.getTitle();
        if (TextUtils.isEmpty(cardTitleText)) {
            Channel channel = mChannelDataManager.getChannel(program.getChannelId());
            cardTitleText = (channel != null) ? channel.getDisplayName()
                    : mActivity.getString(R.string.no_program_information);
        }
        final MediaMetadata currentMetadata = updateMetadataTextInfo(program.getId(), cardTitleText,
                program.getDescription(), mProgramDurationMs);
        String posterArtUri = program.getPosterArtUri();
        if (posterArtUri == null) {
            posterArtUri = TvContract.buildChannelLogoUri(program.getChannelId()).toString();
        }
        updatePosterArt(program, currentMetadata, null, posterArtUri);
        mMediaSession.setActive(true);
    }

    private void updatePosterArt(RecordedProgram program, MediaMetadata currentMetadata,
            @Nullable Bitmap posterArt, @Nullable String posterArtUri) {
        if (posterArt != null) {
            updateMetadataImageInfo(program, currentMetadata, posterArt, 0);
        } else if (posterArtUri != null) {
            ImageLoader.loadBitmap(mActivity, posterArtUri, mNowPlayingCardWidth,
                    mNowPlayingCardHeight,
                    new ProgramPosterArtCallback(mActivity, program, currentMetadata));
        } else {
            updateMetadataImageInfo(program, currentMetadata, null, R.drawable.default_now_card);
        }
    }

    private class ProgramPosterArtCallback extends
            ImageLoader.ImageLoaderCallback<Activity> {
        private final RecordedProgram mRecordedProgram;
        private final MediaMetadata mCurrentMetadata;

        public ProgramPosterArtCallback(Activity activity, RecordedProgram program,
                MediaMetadata metadata) {
            super(activity);
            mRecordedProgram = program;
            mCurrentMetadata = metadata;
        }

        @Override
        public void onBitmapLoaded(Activity activity, @Nullable Bitmap posterArt) {
            if (isCurrentProgram(mRecordedProgram)) {
                updatePosterArt(mRecordedProgram, mCurrentMetadata, posterArt, null);
            }
        }
    }

    private MediaMetadata updateMetadataTextInfo(final long programId, final String title,
            final String subtitle, final long duration) {
        MediaMetadata.Builder builder = new MediaMetadata.Builder();
        builder.putString(MediaMetadata.METADATA_KEY_MEDIA_ID, Long.toString(programId))
                .putString(MediaMetadata.METADATA_KEY_TITLE, title)
                .putLong(MediaMetadata.METADATA_KEY_DURATION, duration);
        if (subtitle != null) {
            builder.putString(MediaMetadata.METADATA_KEY_DISPLAY_SUBTITLE, subtitle);
        }
        MediaMetadata metadata = builder.build();
        mMediaSession.setMetadata(metadata);
        return metadata;
    }

    private void updateMetadataImageInfo(final RecordedProgram program,
            final MediaMetadata currentMetadata, final Bitmap posterArt, final int imageResId) {
        if (mMediaSession != null && (posterArt != null || imageResId != 0)) {
            MediaMetadata.Builder builder = new MediaMetadata.Builder(currentMetadata);
            if (posterArt != null) {
                builder.putBitmap(MediaMetadata.METADATA_KEY_ART, posterArt);
                mMediaSession.setMetadata(builder.build());
            } else {
                new AsyncTask<Void, Void, Bitmap>() {
                    @Override
                    protected Bitmap doInBackground(Void... arg0) {
                        return BitmapFactory.decodeResource(mActivity.getResources(), imageResId);
                    }

                    @Override
                    protected void onPostExecute(Bitmap programPosterArt) {
                        if (mMediaSession != null && programPosterArt != null
                                && isCurrentProgram(program)) {
                            builder.putBitmap(MediaMetadata.METADATA_KEY_ART, programPosterArt);
                            mMediaSession.setMetadata(builder.build());
                        }
                    }
                }.execute();
            }
        }
    }

    // An event was triggered by MediaController.TransportControls and must be handled here.
    // Here we update the media itself to act on the event that was triggered.
    private class MediaSessionCallback extends MediaSession.Callback {
        @Override
        public void onPrepare() {
            if (!mDvrPlayer.isPlaybackPrepared()) {
                mDvrPlayer.prepare(true);
            }
        }

        @Override
        public void onPlay() {
            if (mDvrPlayer.isPlaybackPrepared()) {
                mDvrPlayer.play();
            }
        }

        @Override
        public void onPause() {
            if (mDvrPlayer.isPlaybackPrepared()) {
                mDvrPlayer.pause();
            }
        }

        @Override
        public void onFastForward() {
            if (!mDvrPlayer.isPlaybackPrepared()) {
                return;
            }
            if (mDvrPlayer.getPlaybackState() == PlaybackState.STATE_FAST_FORWARDING) {
                if (mSpeedLevel < TimeShiftUtils.MAX_SPEED_LEVEL) {
                    mSpeedLevel++;
                } else {
                    return;
                }
            } else {
                mSpeedLevel = 0;
            }
            mDvrPlayer.fastForward(
                    TimeShiftUtils.getPlaybackSpeed(mSpeedLevel, mProgramDurationMs));
        }

        @Override
        public void onRewind() {
            if (!mDvrPlayer.isPlaybackPrepared()) {
                return;
            }
            if (mDvrPlayer.getPlaybackState() == PlaybackState.STATE_REWINDING) {
                if (mSpeedLevel < TimeShiftUtils.MAX_SPEED_LEVEL) {
                    mSpeedLevel++;
                } else {
                    return;
                }
            } else {
                mSpeedLevel = 0;
            }
            mDvrPlayer.rewind(TimeShiftUtils.getPlaybackSpeed(mSpeedLevel, mProgramDurationMs));
        }

        @Override
        public void onSeekTo(long positionMs) {
            if (mDvrPlayer.isPlaybackPrepared()) {
                mDvrPlayer.seekTo(positionMs);
            }
        }
    }
}