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

import android.content.Context;
import android.media.tv.TvTrackInfo;
import android.os.Build;
import android.os.LocaleList;
import android.text.TextUtils;
import android.util.Log;

import com.android.tv.R;

import com.google.common.collect.Iterables;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.Set;

/** Static utilities for {@link TvTrackInfo}. */
public class TvTrackInfoUtils {

    private static final String TAG = "TvTrackInfoUtils";
    private static final int AUDIO_CHANNEL_NONE = 0;
    private static final int AUDIO_CHANNEL_MONO = 1;
    private static final int AUDIO_CHANNEL_STEREO = 2;
    private static final int AUDIO_CHANNEL_SURROUND_6 = 6;
    private static final int AUDIO_CHANNEL_SURROUND_8 = 8;

    /**
     * Compares how closely two {@link android.media.tv.TvTrackInfo}s match {@code languages},
     * {@code channelCount} and {@code id} in that precedence. A listed sorted with this comparator
     * has the worst matches first.
     *
     * @param id The track id to match.
     * @param languages The prioritized list of languages. Languages earlier in the list are a
     *     better match.
     * @param channelCount The channel count to match.
     * @return -1 if lhs is a worse match, 0 if lhs and rhs match equally and 1 if lhs is a better
     *     match.
     */
    public static Comparator<TvTrackInfo> createComparator(
            final String id, final List<String> languages, final int channelCount) {
        return (TvTrackInfo lhs, TvTrackInfo rhs) -> {
            if (Objects.equals(lhs, rhs)) {
                return 0;
            }
            if (lhs == null) {
                return -1;
            }
            if (rhs == null) {
                return 1;
            }
            // Find the first language that matches the lhs and rhs tracks. The  earlier match is
            // better. If there is no match set the index to the size of the language list since
            // its the worst match.
            int lhsLangIndex =
                    Iterables.indexOf(languages, s -> Utils.isEqualLanguage(lhs.getLanguage(), s));
            if (lhsLangIndex == -1) {
                lhsLangIndex = languages.size();
            }
            int rhsLangIndex =
                    Iterables.indexOf(languages, s -> Utils.isEqualLanguage(rhs.getLanguage(), s));
            if (rhsLangIndex == -1) {
                rhsLangIndex = languages.size();
            }
            if (lhsLangIndex != rhsLangIndex) {
                // Return the track with lower index as best
                return Integer.compare(rhsLangIndex, lhsLangIndex);
            }
            boolean lhsCountMatch =
                    lhs.getType() != TvTrackInfo.TYPE_AUDIO
                            || lhs.getAudioChannelCount() == channelCount;
            boolean rhsCountMatch =
                    rhs.getType() != TvTrackInfo.TYPE_AUDIO
                            || rhs.getAudioChannelCount() == channelCount;
            if (lhsCountMatch && rhsCountMatch) {
                return Boolean.compare(lhs.getId().equals(id), rhs.getId().equals(id));
            } else if (lhsCountMatch || rhsCountMatch) {
                return Boolean.compare(lhsCountMatch, rhsCountMatch);
            } else {
                return Integer.compare(lhs.getAudioChannelCount(), rhs.getAudioChannelCount());
            }
        };
    }

    /**
     * Selects the best TvTrackInfo available or the first if none matches.
     *
     * @param tracks The tracks to choose from
     * @param id The track id to match.
     * @param language The language to match.
     * @param channelCount The channel count to match.
     * @return the best matching track or the first one if none matches.
     */
    public static TvTrackInfo getBestTrackInfo(
            List<TvTrackInfo> tracks, String id, String language, int channelCount) {
        if (tracks == null) {
            return null;
        }
        List<String> languages = new ArrayList<>();
        if (language == null) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                LocaleList locales = LocaleList.getDefault();
                for (int i = 0; i < locales.size(); i++) {
                    languages.add(locales.get(i).getLanguage());
                }
            } else {
                languages.add(Locale.getDefault().getLanguage());
            }
        } else {
            languages.add(language);
        }
        Comparator<TvTrackInfo> comparator = createComparator(id, languages, channelCount);
        TvTrackInfo best = null;
        for (TvTrackInfo track : tracks) {
            if (comparator.compare(track, best) > 0) {
                best = track;
            }
        }
        return best;
    }

    public static boolean needToShowSampleRate(Context context, List<TvTrackInfo> tracks) {
        Set<String> multiAudioStrings = new HashSet<>();
        for (TvTrackInfo track : tracks) {
            String multiAudioString = getMultiAudioString(context, track, false);
            if (multiAudioStrings.contains(multiAudioString)) {
                return true;
            }
            multiAudioStrings.add(multiAudioString);
        }
        return false;
    }

    public static String getMultiAudioString(
            Context context, TvTrackInfo track, boolean showSampleRate) {
        if (track.getType() != TvTrackInfo.TYPE_AUDIO) {
            throw new IllegalArgumentException("Not an audio track: " + toString(track));
        }
        String language = context.getString(R.string.multi_audio_unknown_language);
        if (!TextUtils.isEmpty(track.getLanguage())) {
            language = new Locale(track.getLanguage()).getDisplayName();
        } else {
            Log.d(TAG, "No language information found for the audio track: " + toString(track));
        }

        StringBuilder metadata = new StringBuilder();
        switch (track.getAudioChannelCount()) {
            case AUDIO_CHANNEL_NONE:
                break;
            case AUDIO_CHANNEL_MONO:
                metadata.append(context.getString(R.string.multi_audio_channel_mono));
                break;
            case AUDIO_CHANNEL_STEREO:
                metadata.append(context.getString(R.string.multi_audio_channel_stereo));
                break;
            case AUDIO_CHANNEL_SURROUND_6:
                metadata.append(context.getString(R.string.multi_audio_channel_surround_6));
                break;
            case AUDIO_CHANNEL_SURROUND_8:
                metadata.append(context.getString(R.string.multi_audio_channel_surround_8));
                break;
            default:
                if (track.getAudioChannelCount() > 0) {
                    metadata.append(
                            context.getString(
                                    R.string.multi_audio_channel_suffix,
                                    track.getAudioChannelCount()));
                } else {
                    Log.d(
                            TAG,
                            "Invalid audio channel count ("
                                    + track.getAudioChannelCount()
                                    + ") found for the audio track: "
                                    + toString(track));
                }
                break;
        }
        if (showSampleRate) {
            int sampleRate = track.getAudioSampleRate();
            if (sampleRate > 0) {
                if (metadata.length() > 0) {
                    metadata.append(", ");
                }
                int integerPart = sampleRate / 1000;
                int tenths = (sampleRate % 1000) / 100;
                metadata.append(integerPart);
                if (tenths != 0) {
                    metadata.append(".");
                    metadata.append(tenths);
                }
                metadata.append("kHz");
            }
        }

        if (metadata.length() == 0) {
            return language;
        }
        return context.getString(
                R.string.multi_audio_display_string_with_channel, language, metadata.toString());
    }

    private static String trackTypeToString(int trackType) {
        switch (trackType) {
            case TvTrackInfo.TYPE_AUDIO:
                return "Audio";
            case TvTrackInfo.TYPE_VIDEO:
                return "Video";
            case TvTrackInfo.TYPE_SUBTITLE:
                return "Subtitle";
            default:
                return "Invalid Type";
        }
    }

    public static String toString(TvTrackInfo info) {
        int trackType = info.getType();
        return "TvTrackInfo{"
                + "type="
                + trackTypeToString(trackType)
                + ", id="
                + info.getId()
                + ", language="
                + info.getLanguage()
                + ", description="
                + info.getDescription()
                + (trackType == TvTrackInfo.TYPE_AUDIO
                        ? (", audioChannelCount="
                                + info.getAudioChannelCount()
                                + ", audioSampleRate="
                                + info.getAudioSampleRate())
                        : "")
                + (trackType == TvTrackInfo.TYPE_VIDEO
                        ? (", videoWidth="
                                + info.getVideoWidth()
                                + ", videoHeight="
                                + info.getVideoHeight()
                                + ", videoFrameRate="
                                + info.getVideoFrameRate()
                                + ", videoPixelAspectRatio="
                                + info.getVideoPixelAspectRatio())
                        : "")
                + "}";
    }

    private TvTrackInfoUtils() {}
}