/*****************************************************************************
 * ts_metadata.c : TS demuxer metadata handling
 *****************************************************************************
 * Copyright (C) 2016 - VideoLAN Authors
 *
 * 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 General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <vlc_common.h>
#include <vlc_meta.h>
#include <vlc_es_out.h>
#include <vlc_block.h>

#include "ts_pid.h"
#include "ts_streams.h"
#include "ts_streams_private.h"
#include "ts_metadata.h"

#include "../../meta_engine/ID3Tag.h"
#include "../../meta_engine/ID3Meta.h"

#include <assert.h>

static int ID3TAG_Parse_Handler( uint32_t i_tag, const uint8_t *p_payload,
                                 size_t i_payload, void *p_priv )
{
    vlc_meta_t *p_meta = (vlc_meta_t *) p_priv;

    (void) ID3HandleTag( p_payload, i_payload, i_tag, p_meta, NULL );

    return VLC_SUCCESS;
}

typedef struct
{
    es_out_t *out;
    ts_stream_t *p_stream;
    block_t *p_head;
    block_t **pp_tail;
    uint8_t i_sequence_number;
} Metadata_stream_processor_context_t;

static void Metadata_stream_processor_Reset( ts_stream_processor_t *h )
{
    Metadata_stream_processor_context_t *ctx = (Metadata_stream_processor_context_t *) h->priv;
    block_ChainRelease(ctx->p_head);
    ctx->p_head = NULL;
    ctx->pp_tail = &ctx->p_head;
}

static void Metadata_stream_processor_Delete( ts_stream_processor_t *h )
{
    Metadata_stream_processor_context_t *ctx = (Metadata_stream_processor_context_t *) h->priv;
    block_ChainRelease(ctx->p_head);
    free( ctx );
    free( h );
}

static block_t * Metadata_stream_processor_AggregateMAU( ts_stream_processor_t *h,
                                                         uint8_t i_sequence, block_t *p_block,
                                                         size_t i_cellsize )
{
    Metadata_stream_processor_context_t *ctx = (Metadata_stream_processor_context_t *) h->priv;

    bool b_corrupt = ctx->p_head && i_sequence != ((ctx->i_sequence_number + 1) & 0xFF);

    if( unlikely(p_block->i_buffer > i_cellsize) )
    {
        block_t *cell = block_Duplicate( p_block );
        if( cell )
        {
            cell->i_buffer = i_cellsize;
            block_ChainLastAppend( &ctx->pp_tail, cell );
        }
        p_block->i_buffer -= i_cellsize;
        p_block->i_buffer += i_cellsize;
    }
    else
    {
        assert( p_block->i_buffer == i_cellsize );
        block_ChainLastAppend( &ctx->pp_tail, p_block );
        p_block = NULL;
    }

    ctx->i_sequence_number = i_sequence;
    if( b_corrupt )
        Metadata_stream_processor_Reset( h );

    return p_block;
}

static block_t * Metadata_stream_processor_OutputMAU( ts_stream_processor_t *h )
{
    Metadata_stream_processor_context_t *ctx = (Metadata_stream_processor_context_t *) h->priv;

    block_t *p_chain = ctx->p_head;
    if( !p_chain )
        return NULL;
    ctx->p_head = NULL;
    ctx->pp_tail = &ctx->p_head;
    return block_ChainGather( p_chain );
}

static block_t * Metadata_stream_processor_PushMAU( ts_stream_processor_t *h,
                                                    const ts_es_t *p_es, block_t *p_block )
{
    block_t *p_return_chain = NULL;
    block_t **pp_return = &p_return_chain;

    while( p_block->i_buffer >= 5 )
    {
        const uint8_t i_service_id = p_block->p_buffer[0];
        const uint8_t i_sequence = p_block->p_buffer[1];
        const uint8_t i_fragment_indication = p_block->p_buffer[2] >> 6;
        const uint16_t i_length = GetWBE(&p_block->p_buffer[3]);

        p_block->i_buffer -= 5;
        p_block->p_buffer += 5;

        if( p_block->i_buffer < i_length )
            break;

        if( i_service_id == p_es->metadata.i_service_id )
        {
            if( i_fragment_indication == 0x03 ) /* FULL AU */
            {
                Metadata_stream_processor_Reset( h ); /* flush anything that not went to last frag */
                p_block = Metadata_stream_processor_AggregateMAU( h, i_sequence, p_block, i_length );
            }
            else
            {
                if( i_fragment_indication == 0x02 ) /* First */
                    Metadata_stream_processor_Reset( h ); /* flush anything that not went to last frag */
                p_block = Metadata_stream_processor_AggregateMAU( h, i_sequence, p_block, i_length );
                if( i_fragment_indication == 0x01 ) /* Last */
                {
                    block_t *out = Metadata_stream_processor_OutputMAU( h );
                    if( out )
                        block_ChainLastAppend( &pp_return, out );
                }
            }
        }

        if( !p_block )
            break;

        p_block->i_buffer -= i_length;
        p_block->i_buffer += i_length;
    };

    if( p_block )
        block_Release( p_block );

    return p_return_chain;
}

static block_t * Metadata_stream_processor_Push( ts_stream_processor_t *h, uint8_t i_stream_id, block_t *p_block )
{
    Metadata_stream_processor_context_t *ctx = (Metadata_stream_processor_context_t *) h->priv;
    ts_es_t *p_es = ctx->p_stream->p_es;

    if( i_stream_id == 0xbd && /* Transport in PES packets, 2.12.3 */
        p_es->metadata.i_format_identifier == METADATA_IDENTIFIER_ID3 )
    {
        vlc_meta_t *p_meta = vlc_meta_New();
        if( p_meta )
        {
            (void) ID3TAG_Parse( p_block->p_buffer, p_block->i_buffer, ID3TAG_Parse_Handler, p_meta );
            es_out_Control( ctx->out, ES_OUT_SET_GROUP_META, p_es->p_program->i_number, p_meta );
            vlc_meta_Delete( p_meta );
        }
    }

    return p_block;
}

ts_stream_processor_t *Metadata_stream_processor_New( ts_stream_t *p_stream, es_out_t *out )
{
    ts_stream_processor_t *h = malloc(sizeof(*h));
    if(!h)
        return NULL;

    Metadata_stream_processor_context_t *ctx = malloc( sizeof(Metadata_stream_processor_context_t) );
    if(!ctx)
    {
        free(h);
        return NULL;
    }
    ctx->out = out;
    ctx->p_stream = p_stream;
    ctx->i_sequence_number = 0;
    ctx->p_head = NULL;
    ctx->pp_tail = &ctx->p_head;

    h->priv = ctx;
    h->pf_delete = Metadata_stream_processor_Delete;
    h->pf_push = Metadata_stream_processor_Push;
    h->pf_reset = Metadata_stream_processor_Reset;

    return h;
}