/*
 * Copyright (C) 2018 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.ui;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.text.TextUtils;

import androidx.leanback.app.DetailsFragment;
import androidx.leanback.widget.Action;
import androidx.leanback.widget.ArrayObjectAdapter;
import androidx.leanback.widget.ClassPresenterSelector;
import androidx.leanback.widget.DetailsOverviewRow;
import androidx.leanback.widget.DetailsOverviewRowPresenter;
import androidx.leanback.widget.OnActionClickedListener;
import androidx.leanback.widget.PresenterSelector;
import androidx.leanback.widget.SparseArrayObjectAdapter;
import androidx.leanback.widget.VerticalGridView;

import com.android.tv.R;
import com.android.tv.TvSingletons;
import com.android.tv.common.feature.CommonFeatures;
import com.android.tv.common.flags.DvrFlags;
import com.android.tv.data.ProgramImpl;
import com.android.tv.data.api.Channel;
import com.android.tv.dvr.DvrDataManager;
import com.android.tv.dvr.DvrManager;
import com.android.tv.dvr.DvrScheduleManager;
import com.android.tv.dvr.data.ScheduledRecording;
import com.android.tv.dvr.ui.DvrUiHelper;
import com.android.tv.dvr.ui.browse.ActionPresenterSelector;
import com.android.tv.dvr.ui.browse.DetailsContent;
import com.android.tv.dvr.ui.browse.DetailsContentPresenter;
import com.android.tv.dvr.ui.browse.DetailsViewBackgroundHelper;
import com.android.tv.util.images.ImageLoader;

import javax.inject.Inject;
import dagger.android.AndroidInjection;

/** A fragment shows the details of a Program */
public class ProgramDetailsFragment extends DetailsFragment
        implements DvrDataManager.ScheduledRecordingListener,
                DvrScheduleManager.OnConflictStateChangeListener {
    private static final int LOAD_LOGO_IMAGE = 1;
    private static final int LOAD_BACKGROUND_IMAGE = 2;

    private static final int ACTION_VIEW_SCHEDULE = 1;
    private static final int ACTION_CANCEL = 2;
    private static final int ACTION_SCHEDULE_RECORDING = 3;

    protected DetailsViewBackgroundHelper mBackgroundHelper;
    private ArrayObjectAdapter mRowsAdapter;
    private DetailsOverviewRow mDetailsOverview;
    private ProgramImpl mProgram;
    private String mInputId;
    private ScheduledRecording mScheduledRecording;
    private DvrManager mDvrManager;
    private DvrDataManager mDvrDataManager;
    private DvrScheduleManager mDvrScheduleManager;
    @Inject DvrFlags mDvrFlags;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (!onLoadDetails(getArguments())) {
            getActivity().finish();
        }
    }

    @Override
    public void onAttach(Context context) {
        AndroidInjection.inject(this);
        super.onAttach(context);
    }

    @Override
    public void onDestroy() {
        mDvrDataManager.removeScheduledRecordingListener(this);
        mDvrScheduleManager.removeOnConflictStateChangeListener(this);
        super.onDestroy();
    }

    @Override
    public void onStart() {
        super.onStart();
        VerticalGridView container =
                (VerticalGridView) getActivity().findViewById(R.id.container_list);
        // Need to manually modify offset. Please refer DetailsFragment.setVerticalGridViewLayout.
        container.setItemAlignmentOffset(0);
        container.setWindowAlignmentOffset(
                getResources().getDimensionPixelSize(R.dimen.lb_details_rows_align_top));
    }

    private void setupAdapter() {
        DetailsOverviewRowPresenter rowPresenter =
                new DetailsOverviewRowPresenter(new DetailsContentPresenter(getActivity()));
        rowPresenter.setBackgroundColor(
                getResources().getColor(R.color.common_tv_background, null));
        rowPresenter.setSharedElementEnterTransition(
                getActivity(), DetailsActivity.SHARED_ELEMENT_NAME);
        rowPresenter.setOnActionClickedListener(onCreateOnActionClickedListener());
        mRowsAdapter = new ArrayObjectAdapter(onCreatePresenterSelector(rowPresenter));
        setAdapter(mRowsAdapter);
    }

    /** Sets details overview. */
    protected void setDetailsOverviewRow(DetailsContent detailsContent) {
        mDetailsOverview = new DetailsOverviewRow(detailsContent);
        mDetailsOverview.setActionsAdapter(onCreateActionsAdapter());
        mRowsAdapter.add(mDetailsOverview);
        onLoadLogoAndBackgroundImages(detailsContent);
    }

    /** Creates and returns presenter selector will be used by rows adaptor. */
    protected PresenterSelector onCreatePresenterSelector(
            DetailsOverviewRowPresenter rowPresenter) {
        ClassPresenterSelector presenterSelector = new ClassPresenterSelector();
        presenterSelector.addClassPresenter(DetailsOverviewRow.class, rowPresenter);
        return presenterSelector;
    }

    /** Updates actions of details overview. */
    protected void updateActions() {
        mDetailsOverview.setActionsAdapter(onCreateActionsAdapter());
    }

    /**
     * Loads program details according to the arguments the fragment got.
     *
     * @return false if cannot find valid programs, else return true. If the return value is false,
     *     the detail activity and fragment will be ended.
     */
    private boolean onLoadDetails(Bundle args) {
        ProgramImpl program = args.getParcelable(DetailsActivity.PROGRAM);
        long channelId = args.getLong(DetailsActivity.CHANNEL_ID);
        String inputId = args.getString(DetailsActivity.INPUT_ID);
        if (program != null && channelId != Channel.INVALID_ID && !TextUtils.isEmpty(inputId)) {
            mProgram = program;
            mInputId = inputId;
            TvSingletons singletons = TvSingletons.getSingletons(getContext());
            mDvrDataManager = singletons.getDvrDataManager();
            mDvrManager = singletons.getDvrManager();
            mDvrScheduleManager = singletons.getDvrScheduleManager();
            mScheduledRecording =
                    mDvrDataManager.getScheduledRecordingForProgramId(program.getId());
            mBackgroundHelper = new DetailsViewBackgroundHelper(getActivity());
            setupAdapter();
            setDetailsOverviewRow(DetailsContent.createFromProgram(getContext(), mProgram));
            mDvrDataManager.addScheduledRecordingListener(this);
            mDvrScheduleManager.addOnConflictStateChangeListener(this);
            return true;
        }
        return false;
    }

    private int getScheduleIconId() {
        if (mDvrManager.isConflicting(mScheduledRecording)) {
            return R.drawable.ic_warning_white_32dp;
        } else {
            return R.drawable.ic_schedule_32dp;
        }
    }

    /** Creates actions users can interact with and their adaptor for this fragment. */
    private SparseArrayObjectAdapter onCreateActionsAdapter() {
        SparseArrayObjectAdapter adapter =
                new SparseArrayObjectAdapter(new ActionPresenterSelector());
        Resources res = getResources();
        if (mScheduledRecording != null) {
            adapter.set(
                    ACTION_VIEW_SCHEDULE,
                    new Action(
                            ACTION_VIEW_SCHEDULE,
                            res.getString(R.string.dvr_detail_view_schedule),
                            null,
                            res.getDrawable(getScheduleIconId())));
            adapter.set(
                    ACTION_CANCEL,
                    new Action(
                            ACTION_CANCEL,
                            res.getString(R.string.dvr_detail_cancel_recording),
                            null,
                            res.getDrawable(R.drawable.ic_dvr_cancel_32dp)));
        } else if (CommonFeatures.DVR.isEnabled(getActivity())
                && mDvrManager.isProgramRecordable(mProgram)) {
            adapter.set(
                    ACTION_SCHEDULE_RECORDING,
                    new Action(
                            ACTION_SCHEDULE_RECORDING,
                            res.getString(R.string.dvr_detail_schedule_recording),
                            null,
                            res.getDrawable(R.drawable.ic_schedule_32dp)));
        }
        return adapter;
    }

    /**
     * Creates actions listeners to implement the behavior of the fragment after users click some
     * action buttons.
     */
    private OnActionClickedListener onCreateOnActionClickedListener() {
        return new OnActionClickedListener() {
            @Override
            public void onActionClicked(Action action) {
                long actionId = action.getId();
                if (actionId == ACTION_VIEW_SCHEDULE) {
                    DvrUiHelper.startSchedulesActivity(getContext(), mScheduledRecording);
                } else if (actionId == ACTION_CANCEL) {
                    mDvrManager.removeScheduledRecording(mScheduledRecording);
                } else if (actionId == ACTION_SCHEDULE_RECORDING) {
                    if (!mProgram.isEpisodic() && mDvrFlags.startEarlyEndLateEnabled()) {
                        DvrUiHelper.startRecordingSettingsActivity(getContext(), mProgram);
                    } else {
                        DvrUiHelper.checkStorageStatusAndShowErrorMessage(
                                getActivity(),
                                mInputId,
                                () ->
                                        DvrUiHelper.requestRecordingFutureProgram(
                                                getActivity(), mProgram, false));
                    }
                }
            }
        };
    }

    /** Loads logo and background images for detail fragments. */
    protected void onLoadLogoAndBackgroundImages(DetailsContent detailsContent) {
        Drawable logoDrawable = null;
        Drawable backgroundDrawable = null;
        if (TextUtils.isEmpty(detailsContent.getLogoImageUri())) {
            logoDrawable =
                    getContext().getResources().getDrawable(R.drawable.dvr_default_poster, null);
            mDetailsOverview.setImageDrawable(logoDrawable);
        }
        if (TextUtils.isEmpty(detailsContent.getBackgroundImageUri())) {
            backgroundDrawable =
                    getContext().getResources().getDrawable(R.drawable.dvr_default_poster, null);
            mBackgroundHelper.setBackground(backgroundDrawable);
        }
        if (logoDrawable != null && backgroundDrawable != null) {
            return;
        }
        if (logoDrawable == null
                && backgroundDrawable == null
                && detailsContent
                        .getLogoImageUri()
                        .equals(detailsContent.getBackgroundImageUri())) {
            ImageLoader.loadBitmap(
                    getContext(),
                    detailsContent.getLogoImageUri(),
                    new MyImageLoaderCallback(
                            this, LOAD_LOGO_IMAGE | LOAD_BACKGROUND_IMAGE, getContext()));
            return;
        }
        if (logoDrawable == null) {
            int imageWidth = getResources().getDimensionPixelSize(R.dimen.dvr_details_poster_width);
            int imageHeight =
                    getResources().getDimensionPixelSize(R.dimen.dvr_details_poster_height);
            ImageLoader.loadBitmap(
                    getContext(),
                    detailsContent.getLogoImageUri(),
                    imageWidth,
                    imageHeight,
                    new MyImageLoaderCallback(this, LOAD_LOGO_IMAGE, getContext()));
        }
        if (backgroundDrawable == null) {
            ImageLoader.loadBitmap(
                    getContext(),
                    detailsContent.getBackgroundImageUri(),
                    new MyImageLoaderCallback(this, LOAD_BACKGROUND_IMAGE, getContext()));
        }
    }

    @Override
    public void onScheduledRecordingAdded(ScheduledRecording... scheduledRecordings) {
        for (ScheduledRecording recording : scheduledRecordings) {
            if (recording.getProgramId() == mProgram.getId()) {
                mScheduledRecording = recording;
                updateActions();
                return;
            }
        }
    }

    @Override
    public void onScheduledRecordingRemoved(ScheduledRecording... scheduledRecordings) {
        if (mScheduledRecording == null) {
            return;
        }
        for (ScheduledRecording recording : scheduledRecordings) {
            if (recording.getId() == mScheduledRecording.getId()) {
                mScheduledRecording = null;
                updateActions();
                return;
            }
        }
    }

    @Override
    public void onScheduledRecordingStatusChanged(ScheduledRecording... scheduledRecordings) {
        if (mScheduledRecording == null) {
            return;
        }
        for (ScheduledRecording recording : scheduledRecordings) {
            if (recording.getId() == mScheduledRecording.getId()) {
                mScheduledRecording = recording;
                updateActions();
                return;
            }
        }
    }

    @Override
    public void onConflictStateChange(boolean conflict, ScheduledRecording... scheduledRecordings) {
        onScheduledRecordingStatusChanged(scheduledRecordings);
    }

    private static class MyImageLoaderCallback
            extends ImageLoader.ImageLoaderCallback<ProgramDetailsFragment> {
        private final Context mContext;
        private final int mLoadType;

        public MyImageLoaderCallback(
                ProgramDetailsFragment fragment, int loadType, Context context) {
            super(fragment);
            mLoadType = loadType;
            mContext = context;
        }

        @Override
        public void onBitmapLoaded(ProgramDetailsFragment fragment, @Nullable Bitmap bitmap) {
            Drawable drawable;
            int loadType = mLoadType;
            if (bitmap == null) {
                Resources res = mContext.getResources();
                drawable = res.getDrawable(R.drawable.dvr_default_poster, null);
                if ((loadType & LOAD_BACKGROUND_IMAGE) != 0 && !fragment.isDetached()) {
                    loadType &= ~LOAD_BACKGROUND_IMAGE;
                    fragment.mBackgroundHelper.setBackgroundColor(
                            res.getColor(R.color.dvr_detail_default_background));
                    fragment.mBackgroundHelper.setScrim(
                            res.getColor(R.color.dvr_detail_default_background_scrim));
                }
            } else {
                drawable = new BitmapDrawable(mContext.getResources(), bitmap);
            }
            if (!fragment.isDetached()) {
                if ((loadType & LOAD_LOGO_IMAGE) != 0) {
                    fragment.mDetailsOverview.setImageDrawable(drawable);
                }
                if ((loadType & LOAD_BACKGROUND_IMAGE) != 0) {
                    fragment.mBackgroundHelper.setBackground(drawable);
                }
            }
        }
    }
}