/*  This file is part of the KDE project.

Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

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 or 3 of the License.

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/>.

*/

#include "fakesource.h"

#include "iodevicereader.h"

#include "qaudiocdreader.h"

#include "mediagraph.h"

#include "mediaobject.h"

#include <QtCore/QUrl>

#include <QtCore/QDebug>

#include <qnetwork.h>

QT_BEGIN_NAMESPACE

namespace Phonon

{

    namespace DS9

    {

        //description of a connection

        struct GraphConnection

        {

            Filter output;

            int outputOffset;

            Filter input;

            int inputOffset;

        };

        static QList<GraphConnection> getConnections(Filter source)

        {

            QList<GraphConnection> ret;

            int outOffset = 0;

            const QList<OutputPin> outputs = BackendNode::pins(source, PINDIR_OUTPUT);

            for (int i = 0; i < outputs.count(); ++i) {

                InputPin input;

                if (outputs.at(i)->ConnectedTo(input.pparam()) == S_OK) {

                    PIN_INFO info;

                    input->QueryPinInfo(&info);

                    Filter current(info.pFilter);

                    if (current) {

                        //this is a valid connection

                        const int inOffset = BackendNode::pins(current, PINDIR_INPUT).indexOf(input);

                        const GraphConnection connection = {source, outOffset, current, inOffset};

                        ret += connection;

                        ret += getConnections(current); //get subsequent connections

                    }

                }

                outOffset++;

            }

            return ret;

        }

/*

        static HRESULT saveToFile(Graph graph, const QString &filepath)

        {

            const WCHAR wszStreamName[] = L"ActiveMovieGraph";

            HRESULT hr;

            ComPointer<IStorage> storage;

            // First, create a document file that will hold the GRF file

            hr = StgCreateDocfile((OLECHAR*)filepath.utf16(),

                STGM_CREATE | STGM_TRANSACTED | STGM_READWRITE |

                STGM_SHARE_EXCLUSIVE,

                0, storage.pparam());

            if (FAILED(hr)) {

                return hr;

            }

            // Next, create a stream to store.

            ComPointer<IStream> stream;

            hr = storage->CreateStream(wszStreamName,

                STGM_WRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,

                0, 0, stream.pparam());

            if (FAILED(hr)) {

                return hr;

            }

            // The IpersistStream::Save method converts a stream into a persistent object.

            ComPointer<IPersistStream> persist(graph, IID_IPersistStream);

            hr = persist->Save(stream, TRUE);

            if (SUCCEEDED(hr)) {

                hr = storage->Commit(STGC_DEFAULT);

            }

            return hr;

        }

*/

        MediaGraph::MediaGraph(MediaObject *mo, short index) :

            m_graph(CLSID_FilterGraph, IID_IGraphBuilder),

            m_fakeSource(new FakeSource()),

            m_hasVideo(false), m_hasAudio(false), m_connectionsDirty(false), 

            m_isStopping(false), m_isSeekable(false), m_result(S_OK),

            m_index(index), m_renderId(0), m_seekId(0),

            m_currentTime(0), m_totalTime(0), m_mediaObject(mo)

        {

            m_mediaControl = ComPointer<IMediaControl>(m_graph, IID_IMediaControl);

            Q_ASSERT(m_mediaControl);

            m_mediaSeeking = ComPointer<IMediaSeeking>(m_graph, IID_IMediaSeeking);

            Q_ASSERT(m_mediaSeeking);

            HRESULT hr = m_graph->AddFilter(m_fakeSource, 0);

            if (m_mediaObject->catchComError(hr)) {

                return;

            }

        }

        MediaGraph::~MediaGraph()

        {

        }

        short MediaGraph::index() const

        {

            return m_index;

        }

        void MediaGraph::grabNode(BackendNode *node)

        {

            grabFilter(node->filter(m_index));

        }

        void MediaGraph::grabFilter(Filter filter)

        {

            if (filter) {

                FILTER_INFO info;

                filter->QueryFilterInfo(&info);

                if (info.pGraph != m_graph) {

                    if (info.pGraph) {

                        m_mediaObject->catchComError(info.pGraph->RemoveFilter(filter));

                    }

                    m_mediaObject->catchComError(m_graph->AddFilter(filter, 0));

                }

                if (info.pGraph) {

                    info.pGraph->Release();

                }

            }

        }

        void MediaGraph::switchFilters(Filter oldFilter, Filter newFilter)

        {

            OAFilterState state = syncGetRealState();

            if (state != State_Stopped) {

                ensureStopped(); //to do the transaction

            }

            OutputPin connected;

            {

                InputPin pin = BackendNode::pins(oldFilter, PINDIR_INPUT).first();

                pin->ConnectedTo(connected.pparam());

            }

            m_graph->RemoveFilter(oldFilter);

            m_graph->AddFilter(newFilter, 0);

            if (connected) {

                InputPin pin = BackendNode::pins(newFilter, PINDIR_INPUT).first();

                //let's reestablish the connections

                m_graph->Connect(connected, pin);

            }

            switch(state)

            {

            case State_Running:

                play();

                break;

            case State_Paused:

                pause();

                break;

            default:

                break;

            }

        }

        OAFilterState MediaGraph::syncGetRealState() const

        {

            OAFilterState state;

            m_mediaControl->GetState(INFINITE, &state);

            return state;

        }

        void MediaGraph::ensureSourceDisconnected()

        {

            for (int i = 0; i < m_sinkConnections.count(); ++i) {

                const Filter currentFilter = m_sinkConnections.at(i)->filter(m_index);

                const QList<InputPin> inputs = BackendNode::pins(currentFilter, PINDIR_INPUT);

                const QList<InputPin> outputs = BackendNode::pins(m_fakeSource, PINDIR_OUTPUT);

                for (int i = 0; i < inputs.count(); ++i) {

                    for (int o = 0; o < outputs.count(); o++) {

                        tryDisconnect(outputs.at(o), inputs.at(i));

                    }

                    for (int d = 0; d < m_decoderPins.count(); ++d) {

                        tryDisconnect(m_decoderPins.at(d), inputs.at(i));

                    }

                }

            }

        }

        void MediaGraph::ensureSourceConnectedTo(bool force)

        {

            if (m_connectionsDirty == false && force == false) {

                return;

            }

            m_connectionsDirty = false;

            ensureSourceDisconnected();

            //reconnect the pins

            for (int i = 0; i < m_sinkConnections.count(); ++i) {

                const Filter currentFilter = m_sinkConnections.at(i)->filter(m_index);

                const QList<InputPin> inputs = BackendNode::pins(currentFilter, PINDIR_INPUT);

                for(int i = 0; i < inputs.count(); ++i) {

                    //we ensure the filter belongs to the graph

                    grabFilter(currentFilter);

                    for (int d = 0; d < m_decoderPins.count(); ++d) {

                        //a decoder has only one output

                        if (tryConnect(m_decoderPins.at(d), inputs.at(i))) {

                            break;

                        }

                    }

                }

            }

        }

        QList<Filter> MediaGraph::getAllFilters(Graph graph)

        {

            QList<Filter> ret;

            ComPointer<IEnumFilters> enumFilters;

            graph->EnumFilters(enumFilters.pparam());

            Filter current;

            while( enumFilters && enumFilters->Next(1, current.pparam(), 0) == S_OK) {

                ret += current;

            }

            return ret;

        }

        QList<Filter> MediaGraph::getAllFilters() const

        {

            return getAllFilters(m_graph);

        }

        bool MediaGraph::isSeekable() const

        {

            return m_isSeekable;

        }

        qint64 MediaGraph::absoluteTotalTime() const

        {

            if (m_seekId) {

                return m_totalTime;

            } else {

                qint64 ret = 0;

                if (m_mediaSeeking) {

                    m_mediaSeeking->GetDuration(&ret);

                    ret /= 10000; //convert to milliseconds

                }

                return ret;

            }

        }

        qint64 MediaGraph::absoluteCurrentTime() const

        {

            if (m_seekId) {

                return m_currentTime;

            } else {

                qint64 ret = -1;

                if (m_mediaSeeking) {

                    HRESULT hr = m_mediaSeeking->GetCurrentPosition(&ret);

                    if (FAILED(hr)) {

                        return ret;

                    }

                    ret /= 10000; //convert to milliseconds

                }

                return ret;

            }

        }

        Phonon::MediaSource MediaGraph::mediaSource() const

        {

            return m_mediaSource;

        }

        void MediaGraph::play()

        {

            ensureSourceConnectedTo();

            m_mediaObject->workerThread()->addStateChangeRequest(m_graph, State_Running, m_decoders);

        }

        void MediaGraph::pause()

        {

            ensureSourceConnectedTo();

            m_mediaObject->workerThread()->addStateChangeRequest(m_graph, State_Paused, m_decoders);

        }

        HRESULT MediaGraph::renderResult() const

        {

            return m_result;

        }

        bool MediaGraph::isStopping() const

        {

            return m_isStopping;

        }

        Graph MediaGraph::graph() const

        {

            return m_graph;

        }

        void MediaGraph::stop()

        {

            if (!isLoading()) {

                ensureStopped();

                absoluteSeek(0); //resets the clock

			} else {

				m_mediaObject->workerThread()->abortCurrentRender(m_renderId);

     			m_renderId = 0; //cancels current loading

			}

            m_mediaObject->workerThread()->addStateChangeRequest(m_graph, State_Stopped);

        }

        void MediaGraph::ensureStopped()

        {

            m_isStopping = true;

            //special case here because we want stopped to be synchronous

            m_graph->Abort();

            m_mediaControl->Stop(); 

            OAFilterState dummy;

            //this will wait until the change is effective

            m_mediaControl->GetState(INFINITE, &dummy);

            m_isStopping = false;

        }

        bool MediaGraph::isLoading() const

        {

            return m_renderId != 0;

        }

        void MediaGraph::absoluteSeek(qint64 time)

        {

            //this just sends a request

            if (m_seekId == 0) {

                m_currentTime = absoluteCurrentTime();

                m_totalTime = absoluteTotalTime();

            }

            m_seekId = m_mediaObject->workerThread()->addSeekRequest(m_graph, time);

        }

        HRESULT MediaGraph::removeFilter(const Filter& filter)

        {

            FILTER_INFO info;

            filter->QueryFilterInfo(&info);

#ifdef GRAPH_DEBUG

            qDebug() << "removeFilter" << QString::fromUtf16(info.achName);

#endif

            if (info.pGraph) {

                info.pGraph->Release();

                if (info.pGraph == m_graph)

                    return m_graph->RemoveFilter(filter);

            }

            //already removed

            return S_OK;

        }

        HRESULT MediaGraph::cleanup()

        {

            stop();

            ensureSourceDisconnected();

            QList<Filter> list = m_decoders;

            if (m_demux) {

                list << m_demux;

            }

            if (m_realSource) {

                list << m_realSource;

            }

            list << m_decoders;

            for (int i = 0; i < m_decoders.count(); ++i) {

                list += getFilterChain(m_demux, m_decoders.at(i));

            }

            for (int i = 0; i < list.count(); ++i) {

                removeFilter(list.at(i));

            }

            //Let's reinitialize the internal lists

            m_decoderPins.clear();

            m_decoders.clear();

            m_demux = Filter();

            m_realSource = Filter();

            m_mediaSource = Phonon::MediaSource();

            absoluteSeek(0); //resets the clock

            return S_OK;

        }

        bool MediaGraph::disconnectNodes(BackendNode *source, BackendNode *sink)

        {

            const Filter sinkFilter = sink->filter(m_index);

            const QList<InputPin> inputs = BackendNode::pins(sinkFilter, PINDIR_INPUT);

            QList<OutputPin> outputs;

            if (source == m_mediaObject) {

                outputs = BackendNode::pins(m_fakeSource, PINDIR_OUTPUT);

                outputs += m_decoderPins;

            } else {

                outputs = BackendNode::pins(source->filter(m_index), PINDIR_OUTPUT);

            }

            for (int i = 0; i < inputs.count(); ++i) {

                for (int o = 0; o < outputs.count(); ++o) {

                    tryDisconnect(outputs.at(o), inputs.at(i));

                }

            }

            if (m_sinkConnections.removeOne(sink)) {

                m_connectionsDirty = true;

            }

            return true;

        }

        bool MediaGraph::tryDisconnect(const OutputPin &out, const InputPin &in)

        {

            bool ret = false;

            OutputPin output;

            if (SUCCEEDED(in->ConnectedTo(output.pparam()))) {

                if (output == out) {

                    //we need a simple disconnection

                    ret = SUCCEEDED(out->Disconnect()) && SUCCEEDED(in->Disconnect());

                } else {

                    InputPin in2;

                    if (SUCCEEDED(out->ConnectedTo(in2.pparam()))) {

                        PIN_INFO info;

                        in2->QueryPinInfo(&info);

                        Filter tee(info.pFilter);

                        CLSID clsid;

                        tee->GetClassID(&clsid);

                        if (clsid == CLSID_InfTee) {

                            //we have to remove all intermediate filters between the tee and the sink

                            PIN_INFO info;

                            in->QueryPinInfo(&info);

                            Filter sink(info.pFilter);

                            QList<Filter> list = getFilterChain(tee, sink);

                            out->QueryPinInfo(&info);

                            Filter source(info.pFilter);

                            if (list.isEmpty()) {

                                output->QueryPinInfo(&info);

                                if (Filter(info.pFilter) == tee) {

                                    ret = SUCCEEDED(output->Disconnect()) && SUCCEEDED(in->Disconnect());

                                }

                            } else {

                                ret = true;

                                for (int i = 0; i < list.count(); ++i) {

                                    ret = ret && SUCCEEDED(removeFilter(list.at(i)));

                                }

                            }

                            //Let's try to see if the Tee filter is still useful

                            if (ret) {

                                int connections = 0;

                                const QList<OutputPin> outputs = BackendNode::pins(tee, PINDIR_OUTPUT);

                                for(int i = 0; i < outputs.count(); ++i) {

                                    InputPin p;

                                    if ( SUCCEEDED(outputs.at(i)->ConnectedTo(p.pparam()))) {

                                        connections++;

                                    }

                                }

                                if (connections == 0) {

                                    //this avoids a crash if the filter is destroyed

                                    //by the subsequent call to removeFilter

                                    output = OutputPin();

                                    removeFilter(tee); //there is no more output for the tee, we remove it

                                }

                            }

                        }

                    }

                }

            }

            return ret;

        }

        bool MediaGraph::tryConnect(const OutputPin &out, const InputPin &newIn)

        {

            ///The management of the creation of the Tees is done here (this is the only place where we call IPin::Connect

            InputPin inPin;

            if (SUCCEEDED(out->ConnectedTo(inPin.pparam()))) {

                //the fake source has another mechanism for the connection

                if (BackendNode::pins(m_fakeSource, PINDIR_OUTPUT).contains(out)) {

                    return false;