/*
 * 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.tv.recommendation;

import android.app.job.JobInfo;
import android.app.job.JobParameters;
import android.app.job.JobScheduler;
import android.app.job.JobService;
import android.content.ComponentName;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Build;
import android.support.annotation.RequiresApi;
import android.text.TextUtils;
import android.util.Log;

import androidx.tvprovider.media.tv.TvContractCompat;

import com.android.tv.Starter;
import com.android.tv.TvSingletons;
import com.android.tv.data.PreviewDataManager;
import com.android.tv.data.PreviewProgramContent;
import com.android.tv.data.api.Channel;
import com.android.tv.data.api.Program;
import com.android.tv.parental.ParentalControlSettings;
import com.android.tv.util.Utils;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/** Class for updating the preview programs for {@link Channel}. */
@RequiresApi(Build.VERSION_CODES.O)
public class ChannelPreviewUpdater {
    private static final String TAG = "ChannelPreviewUpdater";
    private static final boolean DEBUG = false;

    private static final int UPATE_PREVIEW_PROGRAMS_JOB_ID = 1000001;
    private static final long ROUTINE_INTERVAL_MS = TimeUnit.MINUTES.toMillis(10);
    // The left time of a program should meet the threshold so that it could be recommended.
    private static final long RECOMMENDATION_THRESHOLD_LEFT_TIME_MS = TimeUnit.MINUTES.toMillis(10);
    private static final int RECOMMENDATION_THRESHOLD_PROGRESS = 90; // 90%
    private static final int RECOMMENDATION_COUNT = 6;
    private static final int MIN_COUNT_TO_ADD_ROW = 4;

    private static ChannelPreviewUpdater sChannelPreviewUpdater;

    /** Creates and returns the {@link ChannelPreviewUpdater}. */
    public static ChannelPreviewUpdater getInstance(Context context) {
        if (sChannelPreviewUpdater == null) {
            sChannelPreviewUpdater = new ChannelPreviewUpdater(context.getApplicationContext());
        }
        return sChannelPreviewUpdater;
    }

    private final Context mContext;
    private final Recommender mRecommender;
    private final PreviewDataManager mPreviewDataManager;
    private JobService mJobService;
    private JobParameters mJobParams;

    private final ParentalControlSettings mParentalControlSettings;

    private boolean mNeedUpdateAfterRecommenderReady = false;

    private Recommender.Listener mRecommenderListener =
            new Recommender.Listener() {
                @Override
                public void onRecommenderReady() {
                    if (mNeedUpdateAfterRecommenderReady) {
                        if (DEBUG) Log.d(TAG, "Recommender is ready");
                        updatePreviewDataForChannelsImmediately();
                        mNeedUpdateAfterRecommenderReady = false;
                    }
                }

                @Override
                public void onRecommendationChanged() {
                    updatePreviewDataForChannelsImmediately();
                }
            };

    private ChannelPreviewUpdater(Context context) {
        mContext = context;
        mRecommender = new Recommender(context, mRecommenderListener, true);
        mRecommender.registerEvaluator(new RandomEvaluator(), 0.1, 0.1);
        mRecommender.registerEvaluator(new FavoriteChannelEvaluator(), 0.5, 0.5);
        mRecommender.registerEvaluator(new RoutineWatchEvaluator(), 1.0, 1.0);
        TvSingletons tvSingleton = TvSingletons.getSingletons(context);
        mPreviewDataManager = tvSingleton.getPreviewDataManager();
        mParentalControlSettings =
                tvSingleton.getTvInputManagerHelper().getParentalControlSettings();
    }

    /** Starts the routine service for updating the preview programs. */
    public void startRoutineService() {
        JobScheduler jobScheduler =
                (JobScheduler) mContext.getSystemService(Context.JOB_SCHEDULER_SERVICE);
        if (jobScheduler.getPendingJob(UPATE_PREVIEW_PROGRAMS_JOB_ID) != null) {
            if (DEBUG) Log.d(TAG, "UPDATE_PREVIEW_JOB already exists");
            return;
        }
        JobInfo job =
                new JobInfo.Builder(
                                UPATE_PREVIEW_PROGRAMS_JOB_ID,
                                new ComponentName(mContext, ChannelPreviewUpdateService.class))
                        .setPeriodic(ROUTINE_INTERVAL_MS)
                        .setPersisted(true)
                        .build();
        if (jobScheduler.schedule(job) < 0) {
            Log.i(TAG, "JobScheduler failed to schedule the job");
        }
    }

    /** Called when {@link ChannelPreviewUpdateService} is started. */
    void onStartJob(JobService service, JobParameters params) {
        if (DEBUG) Log.d(TAG, "onStartJob");
        mJobService = service;
        mJobParams = params;
        updatePreviewDataForChannelsImmediately();
    }

    /** Updates the preview programs table. */
    public void updatePreviewDataForChannelsImmediately() {
        if (!mRecommender.isReady()) {
            mNeedUpdateAfterRecommenderReady = true;
            return;
        }

        if (!mPreviewDataManager.isLoadFinished()) {
            mPreviewDataManager.addListener(
                    new PreviewDataManager.PreviewDataListener() {
                        @Override
                        public void onPreviewDataLoadFinished() {
                            mPreviewDataManager.removeListener(this);
                            updatePreviewDataForChannels();
                        }

                        @Override
                        public void onPreviewDataUpdateFinished() {}
                    });
            return;
        }
        updatePreviewDataForChannels();
    }

    /** Called when {@link ChannelPreviewUpdateService} is stopped. */
    void onStopJob() {
        if (DEBUG) Log.d(TAG, "onStopJob");
        mJobService = null;
        mJobParams = null;
    }

    private void updatePreviewDataForChannels() {
        new AsyncTask<Void, Void, Set<Program>>() {
            @Override
            protected Set<Program> doInBackground(Void... params) {
                Set<Program> programs = new HashSet<>();
                try {
                    List<Channel> channels = new ArrayList<>(mRecommender.recommendChannels());
                    for (Channel channel : channels) {
                        if (channel.isPhysicalTunerChannel()) {
                            final Program program =
                                    Utils.getCurrentProgram(mContext, channel.getId());
                            if (program != null
                                    && isChannelRecommendationApplicable(channel, program)) {
                                programs.add(program);
                                if (programs.size() >= RECOMMENDATION_COUNT) {
                                    break;
                                }
                            }
                        }
                    }
                } catch (Exception e) {
                    Log.w(TAG, "Can't update preview data", e);
                }
                return programs;
            }

            private boolean isChannelRecommendationApplicable(Channel channel, Program program) {
                final long programDurationMs =
                        program.getEndTimeUtcMillis() - program.getStartTimeUtcMillis();
                if (programDurationMs <= 0) {
                    return false;
                }
                if (TextUtils.isEmpty(program.getPosterArtUri())) {
                    return false;
                }
                if (mParentalControlSettings.isParentalControlsEnabled()
                        && (channel.isLocked()
                                || mParentalControlSettings.isRatingBlocked(
                                        program.getContentRatings()))) {
                    return false;
                }
                long programLeftTimsMs = program.getEndTimeUtcMillis() - System.currentTimeMillis();
                final int programProgress =
                        (programDurationMs <= 0)
                                ? -1
                                : 100 - (int) (programLeftTimsMs * 100 / programDurationMs);

                // We recommend those programs that meet the condition only.
                return programProgress < RECOMMENDATION_THRESHOLD_PROGRESS
                        || programLeftTimsMs > RECOMMENDATION_THRESHOLD_LEFT_TIME_MS;
            }

            @Override
            protected void onPostExecute(Set<Program> programs) {
                updatePreviewDataForChannelsInternal(programs);
            }
        }.execute();
    }

    private void updatePreviewDataForChannelsInternal(Set<Program> programs) {
        long defaultPreviewChannelId =
                mPreviewDataManager.getPreviewChannelId(
                        PreviewDataManager.TYPE_DEFAULT_PREVIEW_CHANNEL);
        if (defaultPreviewChannelId == PreviewDataManager.INVALID_PREVIEW_CHANNEL_ID) {
            // Only create if there is enough programs
            if (programs.size() > MIN_COUNT_TO_ADD_ROW) {
                mPreviewDataManager.createDefaultPreviewChannel(
                        new PreviewDataManager.OnPreviewChannelCreationResultListener() {
                            @Override
                            public void onPreviewChannelCreationResult(
                                    long createdPreviewChannelId) {
                                if (createdPreviewChannelId
                                        != PreviewDataManager.INVALID_PREVIEW_CHANNEL_ID) {
                                    TvContractCompat.requestChannelBrowsable(
                                            mContext, createdPreviewChannelId);
                                    updatePreviewProgramsForPreviewChannel(
                                            createdPreviewChannelId,
                                            generatePreviewProgramContentsFromPrograms(
                                                    createdPreviewChannelId, programs));
                                }
                            }
                        });
            } else if (mJobService != null && mJobParams != null) {
                if (DEBUG) {
                    Log.d(
                            TAG,
                            "Preview channel not created because there is only "
                                    + programs.size()
                                    + " programs");
                }
                mJobService.jobFinished(mJobParams, false);
                mJobService = null;
                mJobParams = null;
            }
        } else {
            updatePreviewProgramsForPreviewChannel(
                    defaultPreviewChannelId,
                    generatePreviewProgramContentsFromPrograms(defaultPreviewChannelId, programs));
        }
    }

    private Set<PreviewProgramContent> generatePreviewProgramContentsFromPrograms(
            long previewChannelId, Set<Program> programs) {
        Set<PreviewProgramContent> result = new HashSet<>();
        for (Program program : programs) {
            PreviewProgramContent previewProgramContent =
                    PreviewProgramContent.createFromProgram(mContext, previewChannelId, program);
            if (previewProgramContent != null) {
                result.add(previewProgramContent);
            }
        }
        return result;
    }

    private void updatePreviewProgramsForPreviewChannel(
            long previewChannelId, Set<PreviewProgramContent> previewProgramContents) {
        PreviewDataManager.PreviewDataListener previewDataListener =
                new PreviewDataManager.PreviewDataListener() {
                    @Override
                    public void onPreviewDataLoadFinished() {}

                    @Override
                    public void onPreviewDataUpdateFinished() {
                        mPreviewDataManager.removeListener(this);
                        if (mJobService != null && mJobParams != null) {
                            if (DEBUG) Log.d(TAG, "UpdateAsyncTask.onPostExecute with JobService");
                            mJobService.jobFinished(mJobParams, false);
                            mJobService = null;
                            mJobParams = null;
                        } else {
                            if (DEBUG)
                                Log.d(TAG, "UpdateAsyncTask.onPostExecute without JobService");
                        }
                    }
                };
        mPreviewDataManager.updatePreviewProgramsForChannel(
                previewChannelId, previewProgramContents, previewDataListener);
    }

    /** Job to execute the update of preview programs. */
    public static class ChannelPreviewUpdateService extends JobService {
        private ChannelPreviewUpdater mChannelPreviewUpdater;

        @Override
        public void onCreate() {
            Starter.start(this);
            if (DEBUG) Log.d(TAG, "ChannelPreviewUpdateService.onCreate");
            mChannelPreviewUpdater = ChannelPreviewUpdater.getInstance(this);
        }

        @Override
        public boolean onStartJob(JobParameters params) {
            mChannelPreviewUpdater.onStartJob(this, params);
            return true;
        }

        @Override
        public boolean onStopJob(JobParameters params) {
            mChannelPreviewUpdater.onStopJob();
            return false;
        }

        @Override
        public void onDestroy() {
            if (DEBUG) Log.d(TAG, "ChannelPreviewUpdateService.onDestroy");
        }
    }
}