/*****************************************************************************

 * stream_extractor.c

 *****************************************************************************

 * Copyright (C) 2016 VLC authors and VideoLAN

 *

 * This program 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 program 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 program; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.

 *****************************************************************************/

#ifndef STREAM_EXTRACTOR_H

#define STREAM_EXTRACTOR_H

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include <vlc_common.h>

#include <vlc_arrays.h>

#include <vlc_stream.h>

#include <vlc_stream_extractor.h>

#include <vlc_modules.h>

#include <vlc_url.h>

#include <vlc_memstream.h>

#include "../libvlc.h"

#include <assert.h>

#include "stream.h"

#include "mrl_helpers.h"

/**

 * \defgroup stream_extractor_Internals Stream Extractor Internals

 * \ingroup stream_extractor

 * \internal

 * @{

 * \file

 **/

struct stream_extractor_private {

    union {

        stream_extractor_t extractor;

        stream_directory_t directory;

    };

    /**

     * Callback to handle initialization

     *

     * \ref pf_init will be called after successful module probing to initialize

     * the relevant members of the underlying stream-extractor object, as well

     * as the wrapping stream.

     **/

    int (*pf_init)( struct stream_extractor_private*, stream_t* );

    /**

     * Callback to handle clean-up

     *

     * \ref pf_clean, unless NULL, will be called when the stream-extractor is to

     * be destroyed, and shall be used to clean-up resources (acquired during

     * initialization, see \ref pf_init).

     */

    void (*pf_clean)( struct stream_extractor_private* );

    stream_t* wrapper; /**< the wrapping \ref stream_t used to access the

                            underlying stream-extractor */

    stream_t* source; /**< the source stream consumed by the stream-extractor */

    module_t* module; /**< the stream-extractor module */

    vlc_object_t* object; /**< the underlying stream-extractor object */

};

/**

 * Create an MRL for a specific sub-entry

 *

 * This internal function is used to create an MRL that refers to \p subentry

 * within \p base, see \ref mrl_helpers for further information.

 **/

VLC_MALLOC static char*

StreamExtractorCreateMRL( char const* base, char const* subentry,

                          char const** volumes, size_t volumes_count )

{

    struct vlc_memstream buffer;

    char* escaped;

    escaped = mrl_EscapeFragmentIdentifier( subentry );

    if ( escaped == NULL )

        return NULL;

    if( vlc_memstream_open( &buffer ) )

    {

        free( escaped );

        return NULL;

    }

    vlc_memstream_puts( &buffer, base );

    if( !strstr( base, "#" ) )

        vlc_memstream_putc( &buffer, '#' );

    vlc_memstream_puts( &buffer, "!/" );

    vlc_memstream_puts( &buffer, escaped );

    for( size_t i=0; i<volumes_count; i++ )

    {

        vlc_memstream_puts( &buffer, "!+" );

        vlc_memstream_puts( &buffer, volumes[i] );

    }

    free( escaped );

    return vlc_memstream_close( &buffer ) ? NULL : buffer.ptr;

}

/**

 * Release the private data associated with a stream-extractor

 * \param priv pointer to the private section

 */

static void se_Release( struct stream_extractor_private* priv )

{

    if( priv->pf_clean )

        priv->pf_clean( priv );

    if( priv->module )

    {

        module_unneed( priv->object, priv->module );

        if( priv->source )

            vlc_stream_Delete( priv->source );

    }

    vlc_object_delete(priv->object);

}

/**

 * \name Callbacks to forward work to the underlying stream-extractor

 *

 * @{

 */

static void

se_StreamDelete( stream_t* stream )

{

    se_Release( stream->p_sys );

}

static ssize_t

se_StreamRead( stream_t* stream, void* buf, size_t len )

{

    struct stream_extractor_private* priv = stream->p_sys;

    return priv->extractor.pf_read( &priv->extractor, buf, len );

}

static block_t*

se_StreamBlock( stream_t* stream, bool* restrict eof )

{

    struct stream_extractor_private* priv = stream->p_sys;

    return priv->extractor.pf_block( &priv->extractor, eof );

}

static int

se_StreamSeek( stream_t* stream, uint64_t offset )

{

    struct stream_extractor_private* priv = stream->p_sys;

    return priv->extractor.pf_seek( &priv->extractor, offset );

}

static int

se_ReadDir( stream_t* stream, input_item_node_t* node )

{

    struct stream_extractor_private* priv = stream->p_sys;

    return priv->directory.pf_readdir( &priv->directory, node );

}

static int

se_StreamControl( stream_t* stream, int req, va_list args )

{

    struct stream_extractor_private* priv = stream->p_sys;

    return priv->extractor.pf_control( &priv->extractor, req, args );

}

static int

se_DirControl( stream_t* stream, int req, va_list args )

{

    (void)stream;

    (void)req;

    (void)args;

    return VLC_EGENERIC;

}

/**

 * @}

 **/

/**

 * \name stream-extractor resource handlers

 * \ingroup stream_extractor

 * @{

 */

static int

se_InitStream( struct stream_extractor_private* priv, stream_t* s )

{

    if( priv->extractor.pf_read ) s->pf_read = se_StreamRead;

    else                          s->pf_block = se_StreamBlock;

    s->pf_seek = se_StreamSeek;

    s->pf_control = se_StreamControl;

    s->psz_url = StreamExtractorCreateMRL( priv->extractor.source->psz_url,

                                           priv->extractor.identifier,

                                           (char const **) priv->extractor.volumes,

                                           priv->extractor.volumes_count );

    if( unlikely( !s->psz_url ) )

        return VLC_ENOMEM;

    return VLC_SUCCESS;

}

static void

se_CleanStreamExtractor( struct stream_extractor_private* priv )

{

    free( (char*)priv->extractor.identifier );

    for( size_t i=0; i<priv->extractor.volumes_count; i++ )

        free( priv->extractor.volumes[i] );

    free( priv->extractor.volumes );

}

static void

se_CleanStreamDirectory( struct stream_extractor_private* priv )

{

    for( size_t i=0; i<priv->directory.volumes_count; i++ )

        free( priv->directory.volumes[i] );

    free( priv->directory.volumes );

}

static int

se_InitDirectory( struct stream_extractor_private* priv, stream_t* s )

{

    stream_directory_t* directory = &priv->directory;

    s->pf_readdir = se_ReadDir;

    s->pf_control = se_DirControl;

    s->psz_url = strdup( directory->source->psz_url );

    if( unlikely( !s->psz_url ) )

        return VLC_EGENERIC;

    return VLC_SUCCESS;

}

/**

 * @}

 **/

/**

 * Create the public stream_t that wraps a stream-extractor

 *

 * This initializes the relevant data-members of the public stream_t which is

 * used to read from the underlying stream-extractor.

 *

 * \param priv the private section of the stream_extractor_t

 * \param source the source stream which the stream_extractor_t should

 *        will read from

 * \return VLC_SUCCESS on success, an error-code on failure.

 **/

static int

se_AttachWrapper( struct stream_extractor_private* priv, stream_t* source )

{

    stream_t* s = vlc_stream_CommonNew( vlc_object_parent(source),

                                        se_StreamDelete );

    if( unlikely( !s ) )

        return VLC_ENOMEM;

    if( priv->pf_init( priv, s ) )

    {

        stream_CommonDelete( s );

        return VLC_EGENERIC;

    }

    priv->wrapper = s;

    priv->wrapper->p_input_item = source->p_input_item;

    priv->wrapper->p_sys = priv;

    priv->source = source;

    priv->wrapper = stream_FilterChainNew( priv->wrapper, "prefetch,cache" );

    return VLC_SUCCESS;

}

static int

StreamExtractorAttach( stream_t** source, char const* identifier,

    char const* module_name, const char **volumes, size_t volumes_count )

{

    const bool extractor = identifier != NULL;

    char const* capability = extractor ? "stream_extractor"

                                       : "stream_directory";

    struct stream_extractor_private* priv = vlc_custom_create(

        vlc_object_parent(*source), sizeof( *priv ), capability );

    if( unlikely( !priv ) )

        return VLC_ENOMEM;

    char ***dst_volumes;

    size_t * dst_volumes_count;

    if( extractor )

    {

        priv->object = VLC_OBJECT( &priv->extractor );

        priv->pf_init = se_InitStream;

        priv->pf_clean = se_CleanStreamExtractor;

        priv->extractor.source = *source;

        priv->extractor.identifier = strdup( identifier );

        if( unlikely( !priv->extractor.identifier ) )

            goto error;

        dst_volumes = &priv->extractor.volumes;

        dst_volumes_count = &priv->extractor.volumes_count;

    }

    else

    {

        priv->object = VLC_OBJECT( &priv->directory );

        priv->pf_init = se_InitDirectory;

        priv->pf_clean = se_CleanStreamDirectory;

        priv->directory.source = *source;

        dst_volumes = &priv->directory.volumes;

        dst_volumes_count = &priv->directory.volumes_count;

    }

    if( volumes_count )

    {

        *dst_volumes = malloc(volumes_count * sizeof(char *));

        if( unlikely(!*dst_volumes) )

            goto error;

        for( *dst_volumes_count=0; *dst_volumes_count<volumes_count; (*dst_volumes_count)++ )

        {

            (*dst_volumes)[*dst_volumes_count] = strdup(volumes[*dst_volumes_count]);

            if( unlikely(!(*dst_volumes)[*dst_volumes_count]) )

                goto error;

        }

    }

    priv->module = module_need( priv->object, capability, module_name, true );

    if( !priv->module || se_AttachWrapper( priv, *source ) )

        goto error;

    *source = priv->wrapper;

    return VLC_SUCCESS;

error:

    se_Release( priv );

    return VLC_EGENERIC;

}

int

vlc_stream_directory_Attach( stream_t** source, char const* module_name,

                             const char **volumes, size_t volumes_count )

{

    return StreamExtractorAttach( source, NULL, module_name, volumes, volumes_count );

}

int

vlc_stream_extractor_Attach( stream_t** source, char const* identifier,

                             char const* module_name, const char **volumes, size_t volumes_count )

{

    return StreamExtractorAttach( source, identifier, module_name, volumes, volumes_count );

}

int

stream_extractor_AttachParsed( stream_t** source, const struct mrl_info *mrli )

{

    size_t count = vlc_array_count( &mrli->identifiers );

    size_t idx = 0;

    while( idx < count )

    {

        const char* id = vlc_array_item_at_index( &mrli->identifiers, idx );

        if( vlc_stream_extractor_Attach( source, id, NULL,

                                        (char const **) mrli->volumes.pp_elems,

                                        mrli->volumes.i_count ) )

            break;

        ++idx;

    }

    return idx == count ? VLC_SUCCESS : VLC_EGENERIC;

}

char*

vlc_stream_extractor_CreateMRL( stream_directory_t* directory,

                                char const* subentry,

                                char const **volumes, size_t volumes_count )

{

    return StreamExtractorCreateMRL( directory->source->psz_url, subentry,

                                     volumes, volumes_count );

}

/**

 * @}

 **/

#endif /* include-guard */