/*

 * This file is part of libbluray

 * Copyright (C) 2010  William Hahne

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library. If not, see

 * <http://www.gnu.org/licenses/>.

 */

package org.videolan.media.content.playlist;

import java.awt.Component;

import java.util.LinkedList;

import javax.media.Control;

import javax.tv.locator.InvalidLocatorException;

import javax.tv.locator.Locator;

import javax.tv.media.MediaSelectFailedEvent;

import javax.tv.media.MediaSelectSucceededEvent;

import javax.tv.media.MediaSelectListener;

import javax.tv.service.selection.InsufficientResourcesException;

import javax.tv.service.selection.InvalidServiceComponentException;

import org.bluray.media.AsynchronousPiPControl;

import org.bluray.net.BDLocator;

import org.dvb.media.DVBMediaSelectControl;

import org.videolan.BDJListeners;

import org.videolan.Logger;

import org.videolan.PlaylistInfo;

import org.videolan.TIClip;

public class DVBMediaSelectControlImpl implements DVBMediaSelectControl {

    protected DVBMediaSelectControlImpl(Handler player) {

        this.player = player;

    }

    public void add(Locator component)

                throws InvalidLocatorException, InvalidServiceComponentException,

                InsufficientResourcesException, SecurityException {

        if (!checkLocator(component))

            throw new InvalidLocatorException(component);

        BDLocator locator = (BDLocator)component;

        if (locator.getSecondaryVideoStreamNumber() <= 0)

            throw new InvalidServiceComponentException(component);

        AsynchronousPiPControl control = (AsynchronousPiPControl)

            player.getControl("org.bluray.media.AsynchronousPiPControl");

        if (control.getCurrentStreamNumber() > 0)

            throw new InsufficientResourcesException();

        try {

            control.selectStreamNumber(locator.getSecondaryVideoStreamNumber());

        } catch (Exception e) {

            System.err.println("" + e + "\n" + Logger.dumpStack(e));

            postMediaSelectFailedEvent(new Locator[] { component });

        }

    }

    public void remove(Locator component)

                throws InvalidLocatorException, InvalidServiceComponentException,

                SecurityException {

        if (!checkLocator(component))

            throw new InvalidLocatorException(component);

        BDLocator locator = (BDLocator)component;

        if (locator.getSecondaryVideoStreamNumber() <= 0)

            throw new InvalidServiceComponentException(component);

        AsynchronousPiPControl control = (AsynchronousPiPControl)

            player.getControl("org.bluray.media.AsynchronousPiPControl");

        if (control.getCurrentStreamNumber() != locator.getSecondaryVideoStreamNumber())

            throw new InvalidLocatorException(component);

        try {

            control.stop();

        } catch (Exception e) {

            System.err.println("" + e + "\n" + Logger.dumpStack(e));

            postMediaSelectFailedEvent(new Locator[] { component });

        }

    }

    public void select(Locator component)

                throws InvalidLocatorException, InvalidServiceComponentException,

            InsufficientResourcesException, SecurityException {

        if (!checkLocator(component))

            throw new InvalidLocatorException(component);

        Control control = getControl((BDLocator)component);

        if (control == null)

            throw new InvalidLocatorException(component);

        if (!(control instanceof StreamControl))

            return;

        int stream = getStream((BDLocator)component);

        if (stream <= 0)

            throw new InvalidLocatorException(component);

        try {

            ((StreamControl)control).selectStreamNumber(stream);

        } catch (Exception e) {

            postMediaSelectFailedEvent(new Locator[] { component });

            throw new InvalidLocatorException(component);

        }

    }

    public void select(Locator[] components)

                throws InvalidLocatorException, InvalidServiceComponentException,

                InsufficientResourcesException, SecurityException {

        for (int i = 0; i < components.length; i++)

            select(components[i]);

    }

    public void replace(Locator fromComponent, Locator toComponent)

               throws InvalidLocatorException, InvalidServiceComponentException,

               InsufficientResourcesException, SecurityException {

        if (!checkLocator(fromComponent))

            throw new InvalidLocatorException(fromComponent);

        if (!checkLocator(toComponent))

            throw new InvalidLocatorException(toComponent);

        Control fromControl = getControl((BDLocator)fromComponent);

        if (fromControl == null)

            throw new InvalidLocatorException(fromComponent);

        Control toControl = getControl((BDLocator)toComponent);

        if (toControl == null)

            throw new InvalidLocatorException(toComponent);

        if (fromControl != toControl)

            throw new InvalidLocatorException(fromComponent);

        int fromStream = getStream((BDLocator)fromComponent);

        if ((fromStream <= 0) || (fromStream != ((StreamControl)fromControl).getCurrentStreamNumber()))

            throw new InvalidLocatorException(fromComponent);

        int toStream = getStream((BDLocator)toComponent);

        if (toStream <= 0)

            throw new InvalidLocatorException(toComponent);

        try {

            ((StreamControl)fromControl).selectStreamNumber(toStream);

        } catch (Exception e) {

            postMediaSelectFailedEvent(new Locator[] { toComponent });

            throw new InvalidLocatorException(toComponent);

        }

    }

    public void addMediaSelectListener(MediaSelectListener listener) {

        listeners.add(listener);

    }

    public void removeMediaSelectListener(MediaSelectListener listener) {

        listeners.remove(listener);

    }

    private void postMediaSelectFailedEvent(Locator[] selection) {

        listeners.putCallback(new MediaSelectFailedEvent(player, selection));

    }

    protected void postMediaSelectSucceededEvent(Locator[] selection) {

        listeners.putCallback(new MediaSelectSucceededEvent(player, selection));

    }

    public Locator[] getCurrentSelection() {

        BDLocator locator = player.getCurrentLocator();

        if (locator == null)

            return new Locator[0];

        String[] tags = locator.getComponentTags();

        if (tags.length <= 0)

            return new Locator[0];

        Locator[] selections = new Locator[tags.length];

        String[] tag = new String[1];

        for (int i = 0; i < tags.length; i++) {

            tag[0] = tags[i];

            try {

                selections[i] = new BDLocator(

                                              locator.getDiscId(),

                                              locator.getTitleNumber(),

                                              locator.getPlayListId(),

                                              locator.getPlayItemId(),

                                              locator.getMarkId(),

                                              tag);

            } catch (Exception e) {

                e.printStackTrace();

                return new Locator[0];

            }

        }

        return selections;

    }

    public void selectServiceMediaComponents(Locator locator)

            throws InvalidLocatorException, InvalidServiceComponentException,

            InsufficientResourcesException {

        if (!(locator instanceof BDLocator))

            throw new InvalidLocatorException(locator);

        PlaylistInfo pi = player.getPlaylistInfo();

        if (pi == null)

            throw new InsufficientResourcesException();

        if (((BDLocator)locator).getPlayListId() != pi.getPlaylist())

            throw new InvalidLocatorException(locator);

        TIClip ci = player.getCurrentClipInfo();

        if (ci == null)

            throw new InsufficientResourcesException();

        String[] tags = ((BDLocator)locator).getComponentTags();

        String[] tag = new String[1];

        for (int i = 0; i < tags.length; i++) {

            tag[0] = tags[i];

            try {

                select(new BDLocator(null, -1, pi.getPlaylist(), ci.getIndex(), -1, tag));

            } catch (org.davic.net.InvalidLocatorException e) {

                e.printStackTrace();

                throw new InvalidLocatorException(locator);

            } catch (SecurityException e) {

                e.printStackTrace();

                throw new InsufficientResourcesException();

            }

        }

    }

    public Component getControlComponent() {

        return null;

    }

    private boolean checkLocator(Locator locator) {

        if ((locator == null) || !(locator instanceof BDLocator))

            return false;

        PlaylistInfo pi = player.getPlaylistInfo();

        if (pi == null)

            return false;

        BDLocator bdLocator = (BDLocator)locator;

        if (bdLocator.getComponentTagsCount() != 1)

            return false;

        if (bdLocator.getPlayListId() != -1 && bdLocator.getPlayListId() != pi.getPlaylist())

            return false;

        TIClip ci = player.getCurrentClipInfo();

        if (ci == null)

            return false;

        return (bdLocator.getPlayItemId() == -1) || (bdLocator.getPlayItemId() == ci.getIndex());

    }

    private int getStream(BDLocator locator) {

        if (locator.getPrimaryVideoStreamNumber() > 0)

            return locator.getPrimaryVideoStreamNumber();

        else if (locator.getPrimaryAudioStreamNumber() > 0)

            return locator.getPrimaryAudioStreamNumber();

        else if (locator.getSecondaryVideoStreamNumber() > 0)

            return locator.getSecondaryVideoStreamNumber();

        else if (locator.getSecondaryAudioStreamNumber() > 0)

            return locator.getSecondaryAudioStreamNumber();

        else if (locator.getPGTextStreamNumber() > 0)

            return locator.getPGTextStreamNumber();

        return -1;

    }

    private Control getControl(BDLocator locator) {

        if (locator.getPrimaryVideoStreamNumber() > 0)

            return player.getControl("org.bluray.media.BackgroundVideoPresentationControl");

        else if (locator.getPrimaryAudioStreamNumber() > 0)

            return player.getControl("org.bluray.media.PrimaryAudioControl");

        else if (locator.getSecondaryVideoStreamNumber() > 0)

            return player.getControl("org.bluray.media.AsynchronousPiPControl");

        else if (locator.getSecondaryAudioStreamNumber() > 0)

            return player.getControl("org.bluray.media.SecondaryAudioControl");

        else if (locator.getPGTextStreamNumber() > 0)

            return player.getControl("org.bluray.media.SubtitlingControl");

        return null;

    }

    private BDJListeners listeners = new BDJListeners();

    private Handler player;

}