#!/usr/bin/env python3
#
#   Copyright 2016 - Google
#
#   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.

#   Utilities that can be used for testing media related usecases.

# Events dispatched from the RPC Server
EVENT_PLAY_RECEIVED = "playReceived"
EVENT_PAUSE_RECEIVED = "pauseReceived"
EVENT_SKIP_NEXT_RECEIVED = "skipNextReceived"
EVENT_SKIP_PREV_RECEIVED = "skipPrevReceived"

# Passthrough Commands sent to the RPC Server
CMD_MEDIA_PLAY = "play"
CMD_MEDIA_PAUSE = "pause"
CMD_MEDIA_SKIP_NEXT = "skipNext"
CMD_MEDIA_SKIP_PREV = "skipPrev"

# MediaMetaData keys. Keep them the same as in BluetoothMediaFacade.
MEDIA_KEY_TITLE = "keyTitle"
MEDIA_KEY_ALBUM = "keyAlbum"
MEDIA_KEY_ARTIST = "keyArtist"
MEDIA_KEY_DURATION = "keyDuration"
MEDIA_KEY_NUM_TRACKS = "keyNumTracks"

class PlaybackState:
    PAUSE = 2
    PLAY = 3

def verifyEventReceived(log, device, event, timeout):
    """
    Verify if the event was received from the given device.
    When a fromDevice talks to a toDevice and expects an event back,
    this util function can be used to see if the toDevice posted it.
    Args:
        log:        The logging object
        device:     The device to pop the event from
        event:      The event we are interested in.
        timeout:    The time in seconds before we timeout
    Returns:
        True        if the event was received
        False       if we timed out waiting for the event
    """
    try:
        device.ed.pop_event(event, timeout)
    except Exception:
        log.info(" {} Event Not received".format(event))
        return False
    log.info("Event Received : {}".format(event))
    return True


def send_media_passthrough_cmd(log,
                               fromDevice,
                               toDevice,
                               cmd,
                               expctEvent,
                               timeout=1.0):
    """
    Send a media passthrough command from one device to another
    via bluetooth.
    Args:
        log:        The logging object
        fromDevice: The device to send the command from
        toDevice:   The device the command is sent to
        cmd:        The passthrough command to send
        expctEvent: The expected event
        timeout:    The time in seconds before we timeout, deafult = 1sec
    Returns:
        True        if the event was received
        False       if we timed out waiting for the event
    """
    log.info("Sending passthru : {}".format(cmd))
    fromDevice.droid.bluetoothMediaPassthrough(cmd)
    return verifyEventReceived(log, toDevice, expctEvent, timeout)


def log_metadata(log, metadata):
    """
    Log the Metadata to the console.
    Args:
        log:        The logging object
        metadata:   Dictionary of the song's metadata
    """
    title = metadata[MEDIA_KEY_TITLE]
    album = metadata[MEDIA_KEY_ALBUM]
    artist = metadata[MEDIA_KEY_ARTIST]
    duration = metadata[MEDIA_KEY_DURATION]
    numTracks = metadata[MEDIA_KEY_NUM_TRACKS]
    log.info("Playing Artist: {}, Album: {}, Title: {}".format(artist, album,
                                                               title))
    log.info("Duration: {}, NumTracks: {}".format(duration, numTracks))


def compare_metadata(log, metadata1, metadata2):
    """
    Compares the Metadata between the two devices
    Args:
        log:        The logging object
        metadata1    Media Metadata of device1
        metadata2    Media Metadata of device2
    Returns:
        True        if the Metadata matches
        False       if the Metadata do not match
    """
    log.info("Device1 metadata:")
    log_metadata(log, metadata1)
    log.info("Device2 metadata:")
    log_metadata(log, metadata2)

    if not (metadata1[MEDIA_KEY_TITLE] == metadata2[MEDIA_KEY_TITLE]):
        log.info("Song Titles do not match")
        return False

    if not (metadata1[MEDIA_KEY_ALBUM] == metadata2[MEDIA_KEY_ALBUM]):
        log.info("Song Albums do not match")
        return False

    if not (metadata1[MEDIA_KEY_ARTIST] == metadata2[MEDIA_KEY_ARTIST]):
        log.info("Song Artists do not match")
        return False

    if not (metadata1[MEDIA_KEY_DURATION] == metadata2[MEDIA_KEY_DURATION]):
        log.info("Song Duration do not match")
        return False

    if not (metadata1[MEDIA_KEY_NUM_TRACKS] == metadata2[MEDIA_KEY_NUM_TRACKS]
    ):
        log.info("Song Num Tracks do not match")
        return False

    return True


def check_metadata(log, device1, device2):
    """
    Gets the now playing metadata from 2 devices and checks if they are the same
    Args:
        log:        The logging object
        device1     Device 1
        device2     Device 2
    Returns:
        True        if the Metadata matches
        False       if the Metadata do not match
    """
    metadata1 = device1.droid.bluetoothMediaGetCurrentMediaMetaData()
    if metadata1 is None:
        return False

    metadata2 = device2.droid.bluetoothMediaGetCurrentMediaMetaData()
    if metadata2 is None:
        return False
    return compare_metadata(log, metadata1, metadata2)


def isMediaSessionActive(log, device, mediaSession):
    """
    Checks if the passed mediaSession is active.
    Used to see if the device is playing music.
    Args:
        log:            The logging object
        device          Device to check
        mediaSession    MediaSession to check if it is active
    Returns:
        True            if the given mediaSession is active
        False           if the given mediaSession is not active
    """
    # Get a list of MediaSession tags (String) that is currently active
    activeSessions = device.droid.bluetoothMediaGetActiveMediaSessions()
    if len(activeSessions) > 0:
        for session in activeSessions:
            log.info(session)
            if (session == mediaSession):
                return True
    log.info("No Media Sessions")
    return False