/*
 * Copyright (C) 2019 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 android.media;

import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;

import com.android.internal.util.Preconditions;

import java.util.ArrayList;

/**
 * The HwAudioSource represents the audio playback directly from a source audio device.
 * It currently supports {@link HwAudioSource#start()} and {@link HwAudioSource#stop()} only
 * corresponding to {@link AudioSystem#startAudioSource(AudioPortConfig, AudioAttributes)}
 * and {@link AudioSystem#stopAudioSource(int)}.
 *
 * @hide
 */
@SystemApi
public class HwAudioSource extends PlayerBase {
    private final AudioDeviceInfo mAudioDeviceInfo;
    private final AudioAttributes mAudioAttributes;

    /**
     * The value of the native handle encodes the HwAudioSource state.
     * The native handle returned by {@link AudioSystem#startAudioSource} is either valid
     * (aka > 0, so successfully started) or hosting an error code (negative).
     * 0 corresponds to an untialized or stopped HwAudioSource.
     */
    private int mNativeHandle = 0;

    /**
     * Class constructor for a hardware audio source based player.
     *
     * Use the {@link Builder} class to construct a {@link HwAudioSource} instance.
     *
     * @param device {@link AudioDeviceInfo} instance of the source audio device.
     * @param attributes {@link AudioAttributes} instance for this player.
     */
    private HwAudioSource(@NonNull AudioDeviceInfo device, @NonNull AudioAttributes attributes) {
        super(attributes, AudioPlaybackConfiguration.PLAYER_TYPE_HW_SOURCE);
        Preconditions.checkNotNull(device);
        Preconditions.checkNotNull(attributes);
        Preconditions.checkArgument(device.isSource(), "Requires a source device");
        mAudioDeviceInfo = device;
        mAudioAttributes = attributes;
        baseRegisterPlayer(AudioSystem.AUDIO_SESSION_ALLOCATE);
    }

    /**
     * TODO: sets the gain on {@link #mAudioDeviceInfo}.
     *
     * @param muting if true, the player is to be muted, and the volume values can be ignored
     * @param leftVolume the left volume to use if muting is false
     * @param rightVolume the right volume to use if muting is false
     */
    @Override
    void playerSetVolume(boolean muting, float leftVolume, float rightVolume) {
    }

    /**
     * TODO: applies {@link VolumeShaper} on {@link #mAudioDeviceInfo}.
     *
     * @param configuration a {@code VolumeShaper.Configuration} object
     *        created by {@link VolumeShaper.Configuration.Builder} or
     *        an created from a {@code VolumeShaper} id
     *        by the {@link VolumeShaper.Configuration} constructor.
     * @param operation a {@code VolumeShaper.Operation}.
     * @return
     */
    @Override
    int playerApplyVolumeShaper(
            @NonNull VolumeShaper.Configuration configuration,
            @NonNull VolumeShaper.Operation operation) {
        return 0;
    }

    /**
     * TODO: gets the {@link VolumeShaper} by a given id.
     *
     * @param id the {@code VolumeShaper} id returned from
     *           sending a fully specified {@code VolumeShaper.Configuration}
     *           through {@link #playerApplyVolumeShaper}
     * @return
     */
    @Override
    @Nullable
    VolumeShaper.State playerGetVolumeShaperState(int id) {
        return new VolumeShaper.State(1f, 1f);
    }

    /**
     * TODO: sets the level on {@link #mAudioDeviceInfo}.
     *
     * @param muting
     * @param level
     * @return
     */
    @Override
    int playerSetAuxEffectSendLevel(boolean muting, float level) {
        return AudioSystem.SUCCESS;
    }

    @Override
    void playerStart() {
        start();
    }

    @Override
    void playerPause() {
        // Pause is equivalent to stop for hardware audio source based players.
        stop();
    }

    @Override
    void playerStop() {
        stop();
    }

    /**
     * Starts the playback from {@link AudioDeviceInfo}.
     * Starts does not return any error code, caller must check {@link HwAudioSource#isPlaying} to
     * ensure the state of the HwAudioSource encoded in {@link mNativeHandle}.
     */
    public void start() {
        Preconditions.checkState(!isPlaying(), "HwAudioSource is currently playing");
        mNativeHandle = AudioSystem.startAudioSource(
                mAudioDeviceInfo.getPort().activeConfig(),
                mAudioAttributes);
        if (isPlaying()) {
            // FIXME: b/174876389 clean up device id reporting
            baseStart(getDeviceId());
        }
    }

    private int getDeviceId() {
        ArrayList<AudioPatch> patches = new ArrayList<AudioPatch>();
        if (AudioManager.listAudioPatches(patches) != AudioManager.SUCCESS) {
            return 0;
        }

        for (int i = 0; i < patches.size(); i++) {
            AudioPatch patch = patches.get(i);
            AudioPortConfig[] sources = patch.sources();
            AudioPortConfig[] sinks = patch.sinks();
            if ((sources != null) && (sources.length > 0)) {
                for (int c = 0;  c < sources.length; c++) {
                    if (sources[c].port().id() == mAudioDeviceInfo.getId()) {
                        return sinks[c].port().id();
                    }
                }
            }
        }
        return 0;
    }

    /**
     * Checks whether the HwAudioSource player is playing.
     * It checks the state of the HwAudioSource encoded in {@link HwAudioSource#isPlaying}.
     * 0 corresponds to a stopped or uninitialized HwAudioSource.
     * Negative value corresponds to a status reported by {@link AudioSystem#startAudioSource} to
     * indicate a failure when trying to start the HwAudioSource.
     *
     * @return true if currently playing, false otherwise
     */
    public boolean isPlaying() {
        return mNativeHandle > 0;
    }

    /**
     * Stops the playback from {@link AudioDeviceInfo}.
     */
    public void stop() {
        if (mNativeHandle > 0) {
            baseStop();
            AudioSystem.stopAudioSource(mNativeHandle);
            mNativeHandle = 0;
        }
    }

    /**
     * Builder class for {@link HwAudioSource} objects.
     * Use this class to configure and create a <code>HwAudioSource</code> instance.
     * <p>Here is an example where <code>Builder</code> is used to specify an audio
     * playback directly from a source device as media usage, to be used by a new
     * <code>HwAudioSource</code> instance:
     *
     * <pre class="prettyprint">
     * HwAudioSource player = new HwAudioSource.Builder()
     *              .setAudioAttributes(new AudioAttributes.Builder()
     *                       .setUsage(AudioAttributes.USAGE_MEDIA)
     *                       .build())
     *              .setAudioDeviceInfo(device)
     *              .build()
     * </pre>
     * <p>
     * If the audio attributes are not set with {@link #setAudioAttributes(AudioAttributes)},
     * attributes comprising {@link AudioAttributes#USAGE_MEDIA} will be used.
     */
    public static final class Builder {
        private AudioAttributes mAudioAttributes;
        private AudioDeviceInfo mAudioDeviceInfo;

        /**
         * Constructs a new Builder with default values.
         */
        public Builder() {
        }

        /**
         * Sets the {@link AudioAttributes}.
         * @param attributes a non-null {@link AudioAttributes} instance that describes the audio
         *     data to be played.
         * @return the same Builder instance.
         */
        public @NonNull Builder setAudioAttributes(@NonNull AudioAttributes attributes) {
            Preconditions.checkNotNull(attributes);
            mAudioAttributes = attributes;
            return this;
        }

        /**
         * Sets the {@link AudioDeviceInfo}.
         * @param info a non-null {@link AudioDeviceInfo} instance that describes the audio
         *     data come from.
         * @return the same Builder instance.
         */
        public @NonNull Builder setAudioDeviceInfo(@NonNull AudioDeviceInfo info) {
            Preconditions.checkNotNull(info);
            Preconditions.checkArgument(info.isSource());
            mAudioDeviceInfo = info;
            return this;
        }

        /**
         * Builds an {@link HwAudioSource} instance initialized with all the parameters set
         * on this <code>Builder</code>.
         * @return a new successfully initialized {@link HwAudioSource} instance.
         */
        public @NonNull HwAudioSource build() {
            Preconditions.checkNotNull(mAudioDeviceInfo);
            if (mAudioAttributes == null) {
                mAudioAttributes = new AudioAttributes.Builder()
                        .setUsage(AudioAttributes.USAGE_MEDIA)
                        .build();
            }
            return new HwAudioSource(mAudioDeviceInfo, mAudioAttributes);
        }
    }
}