/*
 * 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.data.epg;

import android.Manifest;
import android.annotation.SuppressLint;
import android.content.ContentProviderOperation;
import android.content.ContentValues;
import android.content.Context;
import android.content.OperationApplicationException;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.location.Address;
import android.media.tv.TvContentRating;
import android.media.tv.TvContract;
import android.media.tv.TvContract.Programs;
import android.media.tv.TvContract.Programs.Genres;
import android.media.tv.TvInputInfo;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.preference.PreferenceManager;
import android.support.annotation.MainThread;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.os.BuildCompat;
import android.text.TextUtils;
import android.util.Log;

import com.android.tv.TvApplication;
import com.android.tv.common.WeakHandler;
import com.android.tv.data.Channel;
import com.android.tv.data.ChannelDataManager;
import com.android.tv.data.InternalDataUtils;
import com.android.tv.data.Lineup;
import com.android.tv.data.Program;
import com.android.tv.util.LocationUtils;
import com.android.tv.util.RecurringRunner;
import com.android.tv.util.Utils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * An utility class to fetch the EPG. This class isn't thread-safe.
 */
public class EpgFetcher {
    private static final String TAG = "EpgFetcher";
    private static final boolean DEBUG = false;

    private static final int MSG_FETCH_EPG = 1;

    private static final long EPG_PREFETCH_RECURRING_PERIOD_MS = TimeUnit.HOURS.toMillis(4);
    private static final long EPG_READER_INIT_WAIT_MS = TimeUnit.MINUTES.toMillis(1);
    private static final long LOCATION_INIT_WAIT_MS = TimeUnit.SECONDS.toMillis(10);
    private static final long LOCATION_ERROR_WAIT_MS = TimeUnit.HOURS.toMillis(1);
    private static final long PROGRAM_QUERY_DURATION = TimeUnit.DAYS.toMillis(30);

    private static final int BATCH_OPERATION_COUNT = 100;

    private static final String SUPPORTED_COUNTRY_CODE = Locale.US.getCountry();
    private static final String CONTENT_RATING_SEPARATOR = ",";

    // Value: Long
    private static final String KEY_LAST_UPDATED_EPG_TIMESTAMP =
            "com.android.tv.data.epg.EpgFetcher.LastUpdatedEpgTimestamp";
    // Value: String
    private static final String KEY_LAST_LINEUP_ID =
            "com.android.tv.data.epg.EpgFetcher.LastLineupId";

    private static EpgFetcher sInstance;

    private final Context mContext;
    private final ChannelDataManager mChannelDataManager;
    private final EpgReader mEpgReader;
    private EpgFetcherHandler mHandler;
    private RecurringRunner mRecurringRunner;
    private boolean mStarted;

    private long mLastEpgTimestamp = -1;
    private String mLineupId;

    public static synchronized EpgFetcher getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new EpgFetcher(context.getApplicationContext());
        }
        return sInstance;
    }

    /**
     * Creates and returns {@link EpgReader}.
     */
    public static EpgReader createEpgReader(Context context) {
        return new StubEpgReader(context);
    }

    private EpgFetcher(Context context) {
        mContext = context;
        mEpgReader = new StubEpgReader(mContext);
        mChannelDataManager = TvApplication.getSingletons(context).getChannelDataManager();
        mChannelDataManager.addListener(new ChannelDataManager.Listener() {
            @Override
            public void onLoadFinished() {
                if (DEBUG) Log.d(TAG, "ChannelDataManager.onLoadFinished()");
                handleChannelChanged();
            }

            @Override
            public void onChannelListUpdated() {
                if (DEBUG) Log.d(TAG, "ChannelDataManager.onChannelListUpdated()");
                handleChannelChanged();
            }

            @Override
            public void onChannelBrowsableChanged() {
                if (DEBUG) Log.d(TAG, "ChannelDataManager.onChannelBrowsableChanged()");
                handleChannelChanged();
            }
        });
    }

    private void handleChannelChanged() {
        if (mStarted) {
            if (needToStop()) {
                stop();
            }
        } else {
            start();
        }
    }

    private boolean needToStop() {
        return !canStart();
    }

    private boolean canStart() {
        if (DEBUG) Log.d(TAG, "canStart()");
        boolean hasInternalTunerChannel = false;
        for (TvInputInfo input : TvApplication.getSingletons(mContext).getTvInputManagerHelper()
                .getTvInputInfos(true, true)) {
            String inputId = input.getId();
            if (Utils.isInternalTvInput(mContext, inputId)
                    && mChannelDataManager.getChannelCountForInput(inputId) > 0) {
                hasInternalTunerChannel = true;
                break;
            }
        }
        if (!hasInternalTunerChannel) {
            if (DEBUG) Log.d(TAG, "No internal tuner channels.");
            return false;
        }

        if (!TextUtils.isEmpty(getLastLineupId())) {
            return true;
        }
        if (mContext.checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION)
                != PackageManager.PERMISSION_GRANTED) {
            if (DEBUG) Log.d(TAG, "No permission to check the current location.");
            return false;
        }

        try {
            Address address = LocationUtils.getCurrentAddress(mContext);
            if (address != null
                    && !TextUtils.equals(address.getCountryCode(), SUPPORTED_COUNTRY_CODE)) {
                if (DEBUG) Log.d(TAG, "Country not supported: " + address.getCountryCode());
                return false;
            }
        } catch (SecurityException e) {
            Log.w(TAG, "No permission to get the current location", e);
            return false;
        } catch (IOException e) {
            Log.w(TAG, "IO Exception when getting the current location", e);
        }
        return true;
    }

    /**
     * Starts fetching EPG.
     */
    @MainThread
    public void start() {
        if (DEBUG) Log.d(TAG, "start()");
        if (mStarted) {
            if (DEBUG) Log.d(TAG, "EpgFetcher thread already started.");
            return;
        }
        if (!canStart()) {
            return;
        }
        mStarted = true;
        if (DEBUG) Log.d(TAG, "Starting EpgFetcher thread.");
        HandlerThread handlerThread = new HandlerThread("EpgFetcher");
        handlerThread.start();
        mHandler = new EpgFetcherHandler(handlerThread.getLooper(), this);
        mRecurringRunner = new RecurringRunner(mContext, EPG_PREFETCH_RECURRING_PERIOD_MS,
                new EpgRunner(), null);
        mRecurringRunner.start();
        if (DEBUG) Log.d(TAG, "EpgFetcher thread started successfully.");
    }

    /**
     * Starts fetching EPG immediately if possible without waiting for the timer.
     */
    @MainThread
    public void startImmediately() {
        start();
        if (mStarted) {
            if (DEBUG) Log.d(TAG, "Starting fetcher immediately");
            fetchEpg();
        }
    }

    /**
     * Stops fetching EPG.
     */
    @MainThread
    public void stop() {
        if (DEBUG) Log.d(TAG, "stop()");
        if (!mStarted) {
            return;
        }
        mStarted = false;
        mRecurringRunner.stop();
        mHandler.removeCallbacksAndMessages(null);
        mHandler.getLooper().quit();
    }

    private void fetchEpg() {
        fetchEpg(0);
    }

    private void fetchEpg(long delay) {
        mHandler.removeMessages(MSG_FETCH_EPG);
        mHandler.sendEmptyMessageDelayed(MSG_FETCH_EPG, delay);
    }

    private void onFetchEpg() {
        if (DEBUG) Log.d(TAG, "Start fetching EPG.");
        if (!mEpgReader.isAvailable()) {
            if (DEBUG) Log.d(TAG, "EPG reader is not temporarily available.");
            fetchEpg(EPG_READER_INIT_WAIT_MS);
            return;
        }
        String lineupId = getLastLineupId();
        if (lineupId == null) {
            Address address;
            try {
                address = LocationUtils.getCurrentAddress(mContext);
            } catch (IOException e) {
                if (DEBUG) Log.d(TAG, "Couldn't get the current location.", e);
                fetchEpg(LOCATION_ERROR_WAIT_MS);
                return;
            } catch (SecurityException e) {
                Log.w(TAG, "No permission to get the current location.");
                return;
            }
            if (address == null) {
                if (DEBUG) Log.d(TAG, "Null address returned.");
                fetchEpg(LOCATION_INIT_WAIT_MS);
                return;
            }
            if (DEBUG) Log.d(TAG, "Current location is " + address);

            lineupId = getLineupForAddress(address);
            if (lineupId != null) {
                if (DEBUG) Log.d(TAG, "Saving lineup " + lineupId + "found for " + address);
                setLastLineupId(lineupId);
            } else {
                if (DEBUG) Log.d(TAG, "No lineup found for " + address);
                return;
            }
        }

        // Check the EPG Timestamp.
        long epgTimestamp = mEpgReader.getEpgTimestamp();
        if (epgTimestamp <= getLastUpdatedEpgTimestamp()) {
            if (DEBUG) Log.d(TAG, "No new EPG.");
            return;
        }

        boolean updated = false;
        List<Channel> channels = mEpgReader.getChannels(lineupId);
        for (Channel channel : channels) {
            List<Program> programs = new ArrayList<>(mEpgReader.getPrograms(channel.getId()));
            Collections.sort(programs);
            if (DEBUG) {
                Log.d(TAG, "Fetched " + programs.size() + " programs for channel " + channel);
            }
            if (updateEpg(channel.getId(), programs)) {
                updated = true;
            }
        }

        final boolean epgUpdated = updated;
        setLastUpdatedEpgTimestamp(epgTimestamp);
        mHandler.removeMessages(MSG_FETCH_EPG);
        if (DEBUG) Log.d(TAG, "Fetching EPG is finished.");
    }

    @Nullable
    private String getLineupForAddress(Address address) {
        String lineup = null;
        if (TextUtils.equals(address.getCountryCode(), SUPPORTED_COUNTRY_CODE)) {
            String postalCode = address.getPostalCode();
            if (!TextUtils.isEmpty(postalCode)) {
                lineup = getLineupForPostalCode(postalCode);
            }
        }
        return lineup;
    }

    @Nullable
    private String getLineupForPostalCode(String postalCode) {
        List<Lineup> lineups = mEpgReader.getLineups(postalCode);
        for (Lineup lineup : lineups) {
            // TODO(EPG): handle more than OTA digital
            if (lineup.type == Lineup.LINEUP_BROADCAST_DIGITAL) {
                if (DEBUG) Log.d(TAG, "Setting lineup to " + lineup.name  + "("  + lineup.id + ")");
                return lineup.id;
            }
        }
        return null;
    }

    private long getLastUpdatedEpgTimestamp() {
        if (mLastEpgTimestamp < 0) {
            mLastEpgTimestamp = PreferenceManager.getDefaultSharedPreferences(mContext).getLong(
                    KEY_LAST_UPDATED_EPG_TIMESTAMP, 0);
        }
        return mLastEpgTimestamp;
    }

    private void setLastUpdatedEpgTimestamp(long timestamp) {
        mLastEpgTimestamp = timestamp;
        PreferenceManager.getDefaultSharedPreferences(mContext).edit().putLong(
                KEY_LAST_UPDATED_EPG_TIMESTAMP, timestamp).commit();
    }

    private String getLastLineupId() {
        if (mLineupId == null) {
            mLineupId = PreferenceManager.getDefaultSharedPreferences(mContext)
                    .getString(KEY_LAST_LINEUP_ID, null);
        }
        if (DEBUG) Log.d(TAG, "Last lineup_id " + mLineupId);
        return mLineupId;
    }

    private void setLastLineupId(String lineupId) {
        mLineupId = lineupId;
        PreferenceManager.getDefaultSharedPreferences(mContext).edit()
                .putString(KEY_LAST_LINEUP_ID, lineupId).commit();
    }

    private boolean updateEpg(long channelId, List<Program> newPrograms) {
        final int fetchedProgramsCount = newPrograms.size();
        if (fetchedProgramsCount == 0) {
            return false;
        }
        boolean updated = false;
        long startTimeMs = System.currentTimeMillis();
        long endTimeMs = startTimeMs + PROGRAM_QUERY_DURATION;
        List<Program> oldPrograms = queryPrograms(channelId, startTimeMs, endTimeMs);
        Program currentOldProgram = oldPrograms.size() > 0 ? oldPrograms.get(0) : null;
        int oldProgramsIndex = 0;
        int newProgramsIndex = 0;
        // Skip the past programs. They will be automatically removed by the system.
        if (currentOldProgram != null) {
            long oldStartTimeUtcMillis = currentOldProgram.getStartTimeUtcMillis();
            for (Program program : newPrograms) {
                if (program.getEndTimeUtcMillis() > oldStartTimeUtcMillis) {
                    break;
                }
                newProgramsIndex++;
            }
        }
        // Compare the new programs with old programs one by one and update/delete the old one
        // or insert new program if there is no matching program in the database.
        ArrayList<ContentProviderOperation> ops = new ArrayList<>();
        while (newProgramsIndex < fetchedProgramsCount) {
            // TODO: Extract to method and make test.
            Program oldProgram = oldProgramsIndex < oldPrograms.size()
                    ? oldPrograms.get(oldProgramsIndex) : null;
            Program newProgram = newPrograms.get(newProgramsIndex);
            boolean addNewProgram = false;
            if (oldProgram != null) {
                if (oldProgram.equals(newProgram)) {
                    // Exact match. No need to update. Move on to the next programs.
                    oldProgramsIndex++;
                    newProgramsIndex++;
                } else if (isSameTitleAndOverlap(oldProgram, newProgram)) {
                    // Partial match. Update the old program with the new one.
                    // NOTE: Use 'update' in this case instead of 'insert' and 'delete'. There
                    // could be application specific settings which belong to the old program.
                    ops.add(ContentProviderOperation.newUpdate(
                            TvContract.buildProgramUri(oldProgram.getId()))
                            .withValues(toContentValues(newProgram))
                            .build());
                    oldProgramsIndex++;
                    newProgramsIndex++;
                } else if (oldProgram.getEndTimeUtcMillis()
                        < newProgram.getEndTimeUtcMillis()) {
                    // No match. Remove the old program first to see if the next program in
                    // {@code oldPrograms} partially matches the new program.
                    ops.add(ContentProviderOperation.newDelete(
                            TvContract.buildProgramUri(oldProgram.getId()))
                            .build());
                    oldProgramsIndex++;
                } else {
                    // No match. The new program does not match any of the old programs. Insert
                    // it as a new program.
                    addNewProgram = true;
                    newProgramsIndex++;
                }
            } else {
                // No old programs. Just insert new programs.
                addNewProgram = true;
                newProgramsIndex++;
            }
            if (addNewProgram) {
                ops.add(ContentProviderOperation
                        .newInsert(TvContract.Programs.CONTENT_URI)
                        .withValues(toContentValues(newProgram))
                        .build());
            }
            // Throttle the batch operation not to cause TransactionTooLargeException.
            if (ops.size() > BATCH_OPERATION_COUNT || newProgramsIndex >= fetchedProgramsCount) {
                try {
                    if (DEBUG) {
                        int size = ops.size();
                        Log.d(TAG, "Running " + size + " operations for channel " + channelId);
                        for (int i = 0; i < size; ++i) {
                            Log.d(TAG, "Operation(" + i + "): " + ops.get(i));
                        }
                    }
                    mContext.getContentResolver().applyBatch(TvContract.AUTHORITY, ops);
                    updated = true;
                } catch (RemoteException | OperationApplicationException e) {
                    Log.e(TAG, "Failed to insert programs.", e);
                    return updated;
                }
                ops.clear();
            }
        }
        if (DEBUG) {
            Log.d(TAG, "Updated " + fetchedProgramsCount + " programs for channel " + channelId);
        }
        return updated;
    }

    private List<Program> queryPrograms(long channelId, long startTimeMs, long endTimeMs) {
        try (Cursor c = mContext.getContentResolver().query(
                TvContract.buildProgramsUriForChannel(channelId, startTimeMs, endTimeMs),
                Program.PROJECTION, null, null, Programs.COLUMN_START_TIME_UTC_MILLIS)) {
            if (c == null) {
                return Collections.emptyList();
            }
            ArrayList<Program> programs = new ArrayList<>();
            while (c.moveToNext()) {
                programs.add(Program.fromCursor(c));
            }
            return programs;
        }
    }

    /**
     * Returns {@code true} if the {@code oldProgram} program needs to be updated with the
     * {@code newProgram} program.
     */
    private boolean isSameTitleAndOverlap(Program oldProgram, Program newProgram) {
        // NOTE: Here, we update the old program if it has the same title and overlaps with the
        // new program. The test logic is just an example and you can modify this. E.g. check
        // whether the both programs have the same program ID if your EPG supports any ID for
        // the programs.
        return Objects.equals(oldProgram.getTitle(), newProgram.getTitle())
                && oldProgram.getStartTimeUtcMillis() <= newProgram.getEndTimeUtcMillis()
                && newProgram.getStartTimeUtcMillis() <= oldProgram.getEndTimeUtcMillis();
    }

    @SuppressLint("InlinedApi")
    @SuppressWarnings("deprecation")
    private static ContentValues toContentValues(Program program) {
        ContentValues values = new ContentValues();
        values.put(TvContract.Programs.COLUMN_CHANNEL_ID, program.getChannelId());
        putValue(values, TvContract.Programs.COLUMN_TITLE, program.getTitle());
        putValue(values, TvContract.Programs.COLUMN_EPISODE_TITLE, program.getEpisodeTitle());
        if (BuildCompat.isAtLeastN()) {
            putValue(values, TvContract.Programs.COLUMN_SEASON_DISPLAY_NUMBER,
                    program.getSeasonNumber());
            putValue(values, TvContract.Programs.COLUMN_EPISODE_DISPLAY_NUMBER,
                    program.getEpisodeNumber());
        } else {
            putValue(values, TvContract.Programs.COLUMN_SEASON_NUMBER, program.getSeasonNumber());
            putValue(values, TvContract.Programs.COLUMN_EPISODE_NUMBER, program.getEpisodeNumber());
        }
        putValue(values, TvContract.Programs.COLUMN_SHORT_DESCRIPTION, program.getDescription());
        putValue(values, TvContract.Programs.COLUMN_POSTER_ART_URI, program.getPosterArtUri());
        putValue(values, TvContract.Programs.COLUMN_THUMBNAIL_URI, program.getThumbnailUri());
        String[] canonicalGenres = program.getCanonicalGenres();
        if (canonicalGenres != null && canonicalGenres.length > 0) {
            putValue(values, TvContract.Programs.COLUMN_CANONICAL_GENRE,
                    Genres.encode(canonicalGenres));
        } else {
            putValue(values, TvContract.Programs.COLUMN_CANONICAL_GENRE, "");
        }
        TvContentRating[] ratings = program.getContentRatings();
        if (ratings != null && ratings.length > 0) {
            StringBuilder sb = new StringBuilder(ratings[0].flattenToString());
            for (int i = 1; i < ratings.length; ++i) {
                sb.append(CONTENT_RATING_SEPARATOR);
                sb.append(ratings[i].flattenToString());
            }
            putValue(values, TvContract.Programs.COLUMN_CONTENT_RATING, sb.toString());
        } else {
            putValue(values, TvContract.Programs.COLUMN_CONTENT_RATING, "");
        }
        values.put(TvContract.Programs.COLUMN_START_TIME_UTC_MILLIS,
                program.getStartTimeUtcMillis());
        values.put(TvContract.Programs.COLUMN_END_TIME_UTC_MILLIS, program.getEndTimeUtcMillis());
        putValue(values, TvContract.Programs.COLUMN_INTERNAL_PROVIDER_DATA,
                InternalDataUtils.serializeInternalProviderData(program));
        return values;
    }

    private static void putValue(ContentValues contentValues, String key, String value) {
        if (TextUtils.isEmpty(value)) {
            contentValues.putNull(key);
        } else {
            contentValues.put(key, value);
        }
    }

    private static void putValue(ContentValues contentValues, String key, byte[] value) {
        if (value == null || value.length == 0) {
            contentValues.putNull(key);
        } else {
            contentValues.put(key, value);
        }
    }

    private static class EpgFetcherHandler extends WeakHandler<EpgFetcher> {
        public EpgFetcherHandler (@NonNull Looper looper, EpgFetcher ref) {
            super(looper, ref);
        }

        @Override
        public void handleMessage(Message msg, @NonNull EpgFetcher epgFetcher) {
            switch (msg.what) {
                case MSG_FETCH_EPG:
                    epgFetcher.onFetchEpg();
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }

    private class EpgRunner implements Runnable {
        @Override
        public void run() {
            fetchEpg();
        }
    }
}